0001: /*
0002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
0003: *
0004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
0005: *
0006: * The contents of this file are subject to the terms of either the GNU
0007: * General Public License Version 2 only ("GPL") or the Common
0008: * Development and Distribution License("CDDL") (collectively, the
0009: * "License"). You may not use this file except in compliance with the
0010: * License. You can obtain a copy of the License at
0011: * http://www.netbeans.org/cddl-gplv2.html
0012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
0013: * specific language governing permissions and limitations under the
0014: * License. When distributing the software, include this License Header
0015: * Notice in each file and include the License file at
0016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
0017: * particular file as subject to the "Classpath" exception as provided
0018: * by Sun in the GPL Version 2 section of the License file that
0019: * accompanied this code. If applicable, add the following below the
0020: * License Header, with the fields enclosed by brackets [] replaced by
0021: * your own identifying information:
0022: * "Portions Copyrighted [year] [name of copyright owner]"
0023: *
0024: * Contributor(s):
0025: *
0026: * The Original Software is NetBeans. The Initial Developer of the Original
0027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
0028: * Microsystems, Inc. All Rights Reserved.
0029: *
0030: * If you wish your version of this file to be governed by only the CDDL
0031: * or only the GPL Version 2, indicate your decision by adding
0032: * "[Contributor] elects to include this software in this distribution
0033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
0034: * single choice of license, a recipient has the option to distribute
0035: * your version of this file under either the CDDL, the GPL Version 2 or
0036: * to extend the choice of license to its licensees as provided above.
0037: * However, if you add GPL Version 2 code and therefore, elected the GPL
0038: * Version 2 license, then the option applies only if the new code is
0039: * made subject to such option by the copyright holder.
0040: */
0041:
0042: package org.netbeans.modules.form;
0043:
0044: import java.util.*;
0045: import java.util.logging.Level;
0046: import java.util.logging.Logger;
0047: import javax.swing.undo.*;
0048:
0049: import org.openide.nodes.Node;
0050:
0051: import org.netbeans.modules.form.layoutsupport.*;
0052: import org.openide.ErrorManager;
0053:
0054: /**
0055: * Describes single change in FormModel. Provides UndoableEdit capable to
0056: * undo/redo the change.
0057: *
0058: * @author Tran Duc Trung, Tomas Pavek
0059: */
0060:
0061: public class FormModelEvent extends EventObject {
0062: // possible types of changes
0063: public static final int FORM_LOADED = 1;
0064: public static final int FORM_TO_BE_SAVED = 2;
0065: public static final int FORM_TO_BE_CLOSED = 3;
0066: public static final int CONTAINER_LAYOUT_EXCHANGED = 4;
0067: public static final int CONTAINER_LAYOUT_CHANGED = 5;
0068: public static final int COMPONENT_LAYOUT_CHANGED = 6;
0069: public static final int COMPONENT_ADDED = 7;
0070: public static final int COMPONENT_REMOVED = 8;
0071: public static final int COMPONENTS_REORDERED = 9;
0072: public static final int COMPONENT_PROPERTY_CHANGED = 10;
0073: public static final int BINDING_PROPERTY_CHANGED = 16;
0074: public static final int SYNTHETIC_PROPERTY_CHANGED = 11;
0075: public static final int EVENT_HANDLER_ADDED = 12;
0076: public static final int EVENT_HANDLER_REMOVED = 13;
0077: public static final int EVENT_HANDLER_RENAMED = 14;
0078: public static final int OTHER_CHANGE = 15;
0079:
0080: // data about the change
0081: private int changeType;
0082:
0083: private boolean createdDeleted;
0084: private RADComponent component;
0085: private ComponentContainer container;
0086: private LayoutConstraints constraints;
0087: private int componentIndex = -1;
0088: private int[] reordering;
0089: private String propertyName;
0090: private String subPropertyName;
0091: private Object oldPropertyValue;
0092: private Object newPropertyValue;
0093: private Event componentEvent;
0094:
0095: private UndoableEdit undoableEdit;
0096:
0097: // -----------
0098:
0099: private FormModelEvent additionalEvent;
0100: private static List<FormModelEvent> interestList; // events interested in additional events
0101:
0102: // -----------
0103:
0104: FormModelEvent(FormModel source, int changeType) {
0105: super (source);
0106: this .changeType = changeType;
0107: informInterestedEvents(this );
0108: }
0109:
0110: void setProperty(String propName, Object oldValue, Object newValue) {
0111: propertyName = propName;
0112: oldPropertyValue = oldValue;
0113: newPropertyValue = newValue;
0114: }
0115:
0116: void setSubProperty(String subPropertyName) {
0117: this .subPropertyName = subPropertyName;
0118: }
0119:
0120: void setComponentAndContainer(RADComponent metacomp,
0121: ComponentContainer metacont) {
0122: component = metacomp;
0123: container = metacont != null ? metacont
0124: : deriveContainer(metacomp);
0125: }
0126:
0127: void setLayout(RADVisualContainer metacont,
0128: LayoutSupportDelegate oldLayoutSupp,
0129: LayoutSupportDelegate newLayoutSupp) {
0130: component = metacont;
0131: container = metacont;
0132: oldPropertyValue = oldLayoutSupp;
0133: newPropertyValue = newLayoutSupp;
0134: }
0135:
0136: void setReordering(int[] perm) {
0137: reordering = perm;
0138: }
0139:
0140: void setAddData(RADComponent metacomp, ComponentContainer metacont,
0141: boolean addedNew) {
0142: setComponentAndContainer(metacomp, metacont);
0143: createdDeleted = addedNew;
0144:
0145: if (component instanceof RADVisualComponent
0146: && container instanceof RADVisualContainer) {
0147: componentIndex = container.getIndexOf(component);
0148: if (componentIndex >= 0) {
0149: LayoutSupportManager laysup = ((RADVisualContainer) container)
0150: .getLayoutSupport();
0151: if (laysup != null)
0152: constraints = laysup.getConstraints(componentIndex);
0153: }
0154: }
0155: }
0156:
0157: void setRemoveData(RADComponent metacomp,
0158: ComponentContainer metacont, int index,
0159: boolean removedFromModel) {
0160: component = metacomp;
0161: container = metacont;
0162: componentIndex = index;
0163: createdDeleted = removedFromModel;
0164:
0165: if (metacomp instanceof RADVisualComponent
0166: && metacont instanceof RADVisualContainer) {
0167: LayoutSupportManager laysup = ((RADVisualContainer) metacont)
0168: .getLayoutSupport();
0169: constraints = laysup == null ? null
0170: : laysup
0171: .getStoredConstraints((RADVisualComponent) metacomp);
0172: }
0173: }
0174:
0175: void setEvent(
0176: Event event, // may be null if the handler is just updated
0177: String handler, String bodyText, String annotationText,
0178: boolean createdNew) {
0179: if (event != null)
0180: component = event.getComponent();
0181: componentEvent = event;
0182: propertyName = handler;
0183: newPropertyValue = bodyText;
0184: oldPropertyValue = annotationText;
0185: createdDeleted = createdNew;
0186: }
0187:
0188: void setEvent(String oldHandlerName, String newHandlerName) {
0189: oldPropertyValue = oldHandlerName;
0190: propertyName = newHandlerName;
0191: newPropertyValue = newHandlerName;
0192: }
0193:
0194: void setChangeType(int changeType) {
0195: this .changeType = changeType;
0196: }
0197:
0198: private static ComponentContainer deriveContainer(RADComponent comp) {
0199: if (comp == null)
0200: return null;
0201: if (comp.getParentComponent() instanceof ComponentContainer)
0202: return (ComponentContainer) comp.getParentComponent();
0203: else if (comp.getParentComponent() == null)
0204: return comp.getFormModel().getModelContainer();
0205: return null;
0206: }
0207:
0208: // -------
0209:
0210: public final FormModel getFormModel() {
0211: return (FormModel) getSource();
0212: }
0213:
0214: public final int getChangeType() {
0215: return changeType;
0216: }
0217:
0218: public final boolean isModifying() {
0219: return changeType != FORM_LOADED
0220: && changeType != FORM_TO_BE_SAVED
0221: && changeType != FORM_TO_BE_CLOSED
0222: && (changeType != EVENT_HANDLER_ADDED || componentEvent != null);
0223: }
0224:
0225: public final boolean getCreatedDeleted() {
0226: return createdDeleted;
0227: }
0228:
0229: public final ComponentContainer getContainer() {
0230: return container;
0231: }
0232:
0233: public final RADComponent getComponent() {
0234: return component;
0235: }
0236:
0237: public final LayoutConstraints getComponentLayoutConstraints() {
0238: return constraints;
0239: }
0240:
0241: public final int getComponentIndex() {
0242: return componentIndex;
0243: }
0244:
0245: public final String getPropertyName() {
0246: return propertyName;
0247: }
0248:
0249: public final String getSubPropertyName() {
0250: return subPropertyName;
0251: }
0252:
0253: public final RADProperty getComponentProperty() {
0254: return component != null && propertyName != null ? component
0255: .getBeanProperty(propertyName) : null;
0256: }
0257:
0258: public final Object getOldPropertyValue() {
0259: return oldPropertyValue;
0260: }
0261:
0262: public final Object getNewPropertyValue() {
0263: return newPropertyValue;
0264: }
0265:
0266: public final MetaBinding getOldBinding() {
0267: return (MetaBinding) oldPropertyValue;
0268: }
0269:
0270: public final MetaBinding getNewBinding() {
0271: return (MetaBinding) newPropertyValue;
0272: }
0273:
0274: public final LayoutSupportDelegate getOldLayoutSupport() {
0275: return (LayoutSupportDelegate) oldPropertyValue;
0276: }
0277:
0278: public final LayoutSupportDelegate getNewLayoutSupport() {
0279: return (LayoutSupportDelegate) newPropertyValue;
0280: }
0281:
0282: public final int[] getReordering() {
0283: return reordering;
0284: }
0285:
0286: public final Event getComponentEvent() {
0287: return componentEvent;
0288: }
0289:
0290: public final String getEventHandler() {
0291: return propertyName;
0292: }
0293:
0294: public final String getOldEventHandler() {
0295: return (String) oldPropertyValue;
0296: }
0297:
0298: public final String getNewEventHandler() {
0299: return (String) newPropertyValue;
0300: }
0301:
0302: public final String getNewEventHandlerContent() {
0303: return changeType == EVENT_HANDLER_ADDED
0304: || changeType == EVENT_HANDLER_REMOVED ? (String) newPropertyValue
0305: : null;
0306: }
0307:
0308: public final String getNewEventHandlerAnnotation() {
0309: return (changeType == EVENT_HANDLER_ADDED || changeType == EVENT_HANDLER_REMOVED) ? (String) oldPropertyValue
0310: : null;
0311: }
0312:
0313: public final String getOldEventHandlerContent() {
0314: if (changeType == EVENT_HANDLER_ADDED
0315: || changeType == EVENT_HANDLER_REMOVED) {
0316: if (additionalEvent != null) {
0317: if (additionalEvent.changeType == EVENT_HANDLER_REMOVED
0318: || additionalEvent.changeType == EVENT_HANDLER_ADDED) {
0319: oldPropertyValue = additionalEvent.oldPropertyValue;
0320: }
0321: additionalEvent = null;
0322: }
0323: return (String) oldPropertyValue;
0324: }
0325: return null;
0326: }
0327:
0328: public final void setOldEventHandlerContent(String text) {
0329: if (changeType == EVENT_HANDLER_ADDED
0330: || changeType == EVENT_HANDLER_REMOVED)
0331: oldPropertyValue = text;
0332: }
0333:
0334: public final String getOldEventHandlerAnnotation() {
0335: if (changeType == EVENT_HANDLER_ADDED
0336: || changeType == EVENT_HANDLER_REMOVED) {
0337: if (additionalEvent != null) {
0338: if (additionalEvent.changeType == EVENT_HANDLER_REMOVED
0339: || additionalEvent.changeType == EVENT_HANDLER_ADDED) {
0340: newPropertyValue = additionalEvent.newPropertyValue;
0341: }
0342: additionalEvent = null;
0343: }
0344: return (String) newPropertyValue;
0345: }
0346: return null;
0347: }
0348:
0349: public final void setOldEventHandlerAnnotation(String text) {
0350: if (changeType == EVENT_HANDLER_ADDED
0351: || changeType == EVENT_HANDLER_REMOVED) {
0352: newPropertyValue = text;
0353: }
0354: }
0355:
0356: // ----------
0357:
0358: UndoableEdit getUndoableEdit() {
0359: if (undoableEdit == null)
0360: undoableEdit = new FormUndoableEdit();
0361: return undoableEdit;
0362: }
0363:
0364: // ----------
0365: // methods for events interested in additional events occured
0366: // (used for undo/redo processing of event handlers)
0367:
0368: private static void addToInterestList(FormModelEvent ev) {
0369: if (interestList == null) {
0370: interestList = new ArrayList<FormModelEvent>();
0371: } else {
0372: interestList.remove(ev);
0373: }
0374:
0375: interestList.add(ev);
0376: }
0377:
0378: private static void removeFromInterestList(FormModelEvent ev) {
0379: if (interestList != null)
0380: interestList.remove(ev);
0381: }
0382:
0383: private static void informInterestedEvents(FormModelEvent newEvent) {
0384: if (interestList != null)
0385: for (Iterator it = interestList.iterator(); it.hasNext();)
0386: ((FormModelEvent) it.next()).newEventCreated(newEvent);
0387: }
0388:
0389: private void newEventCreated(FormModelEvent newEvent) {
0390: additionalEvent = newEvent;
0391: }
0392:
0393: // ----------
0394:
0395: private class FormUndoableEdit extends AbstractUndoableEdit {
0396: @Override
0397: public void undo() throws CannotUndoException {
0398: super .undo();
0399:
0400: // turn off undo/redo monitoring in FormModel while undoing!
0401: boolean undoRedoOn = getFormModel().isUndoRedoRecording();
0402: if (undoRedoOn)
0403: getFormModel().setUndoRedoRecording(false);
0404:
0405: switch (changeType) {
0406: case CONTAINER_LAYOUT_EXCHANGED:
0407: FormModel.t("UNDO: container layout change"); // NOI18N
0408: undoContainerLayoutExchange();
0409: break;
0410: case CONTAINER_LAYOUT_CHANGED:
0411: FormModel.t("UNDO: container layout property change"); // NOI18N
0412: undoContainerLayoutChange();
0413: break;
0414: case COMPONENT_LAYOUT_CHANGED:
0415: FormModel
0416: .t("UNDO: component layout constraints change"); // NOI18N
0417: undoComponentLayoutChange();
0418: break;
0419: case COMPONENTS_REORDERED:
0420: FormModel.t("UNDO: components reorder"); // NOI18N
0421: undoComponentsReorder();
0422: break;
0423: case COMPONENT_ADDED:
0424: FormModel.t("UNDO: component addition"); // NOI18N
0425: undoComponentAddition();
0426: break;
0427: case COMPONENT_REMOVED:
0428: FormModel.t("UNDO: component removal"); // NOI18N
0429: undoComponentRemoval();
0430: break;
0431: case COMPONENT_PROPERTY_CHANGED:
0432: FormModel.t("UNDO: component property change"); // NOI18N
0433: undoComponentPropertyChange();
0434: break;
0435: case SYNTHETIC_PROPERTY_CHANGED:
0436: FormModel.t("UNDO: synthetic property change"); // NOI18N
0437: undoSyntheticPropertyChange();
0438: break;
0439: case EVENT_HANDLER_ADDED:
0440: FormModel.t("UNDO: event handler addition"); // NOI18N
0441: undoEventHandlerAddition();
0442: break;
0443: case EVENT_HANDLER_REMOVED:
0444: FormModel.t("UNDO: event handler removal"); // NOI18N
0445: undoEventHandlerRemoval();
0446: break;
0447: case EVENT_HANDLER_RENAMED:
0448: FormModel.t("UNDO: event handler renaming"); // NOI18N
0449: undoEventHandlerRenaming();
0450: break;
0451: case BINDING_PROPERTY_CHANGED:
0452: FormModel.t("UNDO: binding property change"); // NOI18N
0453: undoBindingPropertyChange();
0454: break;
0455:
0456: default:
0457: FormModel.t("UNDO: " + changeType); // NOI18N
0458: break;
0459: }
0460:
0461: if (undoRedoOn) // turn on undo/redo monitoring again
0462: getFormModel().setUndoRedoRecording(true);
0463: }
0464:
0465: @Override
0466: public void redo() throws CannotRedoException {
0467: super .redo();
0468:
0469: // turn off undo/redo monitoring in FormModel while redoing!
0470: boolean undoRedoOn = getFormModel().isUndoRedoRecording();
0471: if (undoRedoOn)
0472: getFormModel().setUndoRedoRecording(false);
0473:
0474: switch (changeType) {
0475: case CONTAINER_LAYOUT_EXCHANGED:
0476: FormModel.t("REDO: container layout change"); // NOI18N
0477: redoContainerLayoutExchange();
0478: break;
0479: case CONTAINER_LAYOUT_CHANGED:
0480: FormModel.t("REDO: container layout property change"); // NOI18N
0481: redoContainerLayoutChange();
0482: break;
0483: case COMPONENT_LAYOUT_CHANGED:
0484: FormModel
0485: .t("REDO: component layout constraints change"); // NOI18N
0486: redoComponentLayoutChange();
0487: break;
0488: case COMPONENTS_REORDERED:
0489: FormModel.t("REDO: components reorder"); // NOI18N
0490: redoComponentsReorder();
0491: break;
0492: case COMPONENT_ADDED:
0493: FormModel.t("REDO: component addition"); // NOI18N
0494: redoComponentAddition();
0495: break;
0496: case COMPONENT_REMOVED:
0497: FormModel.t("REDO: component removal"); // NOI18N
0498: redoComponentRemoval();
0499: break;
0500: case COMPONENT_PROPERTY_CHANGED:
0501: FormModel.t("REDO: component property change"); // NOI18N
0502: redoComponentPropertyChange();
0503: break;
0504: case SYNTHETIC_PROPERTY_CHANGED:
0505: FormModel.t("REDO: synthetic property change"); // NOI18N
0506: redoSyntheticPropertyChange();
0507: break;
0508: case EVENT_HANDLER_ADDED:
0509: FormModel.t("REDO: event handler addition"); // NOI18N
0510: redoEventHandlerAddition();
0511: break;
0512: case EVENT_HANDLER_REMOVED:
0513: FormModel.t("REDO: event handler removal"); // NOI18N
0514: redoEventHandlerRemoval();
0515: break;
0516: case EVENT_HANDLER_RENAMED:
0517: FormModel.t("REDO: event handler renaming"); // NOI18N
0518: redoEventHandlerRenaming();
0519: break;
0520: case BINDING_PROPERTY_CHANGED:
0521: FormModel.t("REDO: binding property change"); // NOI18N
0522: redoBindingPropertyChange();
0523: break;
0524:
0525: default:
0526: FormModel.t("REDO: " + changeType); // NOI18N
0527: break;
0528: }
0529:
0530: if (undoRedoOn) // turn on undo/redo monitoring again
0531: getFormModel().setUndoRedoRecording(true);
0532: }
0533:
0534: @Override
0535: public String getUndoPresentationName() {
0536: return ""; // NOI18N
0537: }
0538:
0539: @Override
0540: public String getRedoPresentationName() {
0541: return ""; // NOI18N
0542: }
0543:
0544: // -------------
0545:
0546: private void undoContainerLayoutExchange() {
0547: try {
0548: LayoutSupportDelegate layoutDelegate = getOldLayoutSupport();
0549: if (layoutDelegate != null) {
0550: getFormModel().setContainerLayoutImpl(
0551: (RADVisualContainer) getContainer(),
0552: layoutDelegate);
0553: } else {
0554: getFormModel().setNaturalContainerLayoutImpl(
0555: (RADVisualContainer) getContainer());
0556: }
0557: } catch (Exception ex) {
0558: ErrorManager.getDefault().notify(
0559: ErrorManager.INFORMATIONAL, ex);
0560: }
0561: }
0562:
0563: private void redoContainerLayoutExchange() {
0564: try {
0565: LayoutSupportDelegate layoutDelegate = getNewLayoutSupport();
0566: if (layoutDelegate != null) {
0567: getFormModel().setContainerLayoutImpl(
0568: (RADVisualContainer) getContainer(),
0569: layoutDelegate);
0570: } else {
0571: getFormModel().setNaturalContainerLayoutImpl(
0572: (RADVisualContainer) getContainer());
0573: }
0574: } catch (Exception ex) {
0575: ErrorManager.getDefault().notify(
0576: ErrorManager.INFORMATIONAL, ex);
0577: }
0578: }
0579:
0580: private void undoContainerLayoutChange() {
0581: RADVisualContainer metacont = (RADVisualContainer) getComponent();
0582: LayoutSupportManager laysup = metacont.getLayoutSupport();
0583: if (laysup != null) {
0584: String propName = getPropertyName();
0585: if (propName != null) {
0586: Node.Property prop = laysup
0587: .getLayoutProperty(propName);
0588: if (prop != null) {
0589: try {
0590: prop.setValue(getOldPropertyValue());
0591: } catch (Exception ex) { // should not happen
0592: Logger.getLogger(getClass().getName()).log(
0593: Level.INFO, ex.getMessage(), ex);
0594: }
0595: }
0596: }
0597: } else {
0598: getFormModel().fireContainerLayoutChanged(metacont,
0599: null, null, null);
0600: }
0601: }
0602:
0603: private void redoContainerLayoutChange() {
0604: RADVisualContainer metacont = (RADVisualContainer) getComponent();
0605: LayoutSupportManager laysup = metacont.getLayoutSupport();
0606: if (laysup != null) {
0607: String propName = getPropertyName();
0608: if (propName != null) {
0609: Node.Property prop = laysup
0610: .getLayoutProperty(propName);
0611: if (prop != null) {
0612: try {
0613: prop.setValue(getNewPropertyValue());
0614: } catch (Exception ex) { // should not happen
0615: Logger.getLogger(getClass().getName()).log(
0616: Level.INFO, ex.getMessage(), ex);
0617: }
0618: }
0619: }
0620: } else {
0621: getFormModel().fireContainerLayoutChanged(metacont,
0622: null, null, null);
0623: }
0624: }
0625:
0626: private void undoComponentLayoutChange() {
0627: if (getComponent() instanceof RADVisualComponent) {
0628: ((RADVisualComponent) getComponent())
0629: .getConstraintsProperties();
0630: Node.Property prop = getComponent().getPropertyByName(
0631: getPropertyName());
0632: if (prop != null)
0633: try {
0634: prop.setValue(getOldPropertyValue());
0635: } catch (Exception ex) { // should not happen
0636: Logger.getLogger(getClass().getName()).log(
0637: Level.INFO, ex.getMessage(), ex);
0638: }
0639: }
0640: }
0641:
0642: private void redoComponentLayoutChange() {
0643: if (getComponent() instanceof RADVisualComponent) {
0644: ((RADVisualComponent) getComponent())
0645: .getConstraintsProperties();
0646: Node.Property prop = getComponent().getPropertyByName(
0647: getPropertyName());
0648: if (prop != null)
0649: try {
0650: prop.setValue(getNewPropertyValue());
0651: } catch (Exception ex) { // should not happen
0652: Logger.getLogger(getClass().getName()).log(
0653: Level.INFO, ex.getMessage(), ex);
0654: }
0655: }
0656: }
0657:
0658: private void undoComponentAddition() {
0659: removeComponent();
0660: }
0661:
0662: private void undoComponentRemoval() {
0663: addComponent();
0664: }
0665:
0666: private void redoComponentAddition() {
0667: addComponent();
0668: }
0669:
0670: private void redoComponentRemoval() {
0671: removeComponent();
0672: }
0673:
0674: private void addComponent() {
0675: RADComponent component = getComponent();
0676: ComponentContainer container = getContainer();
0677: RADComponent[] currentSubComps = container.getSubBeans();
0678: RADComponent[] undoneSubComps = new RADComponent[currentSubComps.length + 1];
0679:
0680: if (componentIndex < 0)
0681: componentIndex = currentSubComps.length;
0682:
0683: for (int i = 0, j = 0; j < undoneSubComps.length; i++, j++) {
0684: if (i == componentIndex) {
0685: undoneSubComps[j] = component;
0686: if (i == currentSubComps.length)
0687: break;
0688: j++;
0689: }
0690: undoneSubComps[j] = currentSubComps[i];
0691: }
0692:
0693: if (getCreatedDeleted() || !component.isInModel()) {
0694: FormModel.setInModelRecursively(component, true);
0695: }
0696:
0697: container.initSubComponents(undoneSubComps);
0698:
0699: if (component instanceof RADVisualComponent) {
0700: if (container instanceof RADVisualContainer) {
0701: LayoutSupportManager layoutSupport = ((RADVisualContainer) container)
0702: .getLayoutSupport();
0703: if (layoutSupport != null)
0704: layoutSupport
0705: .addComponents(
0706: new RADVisualComponent[] { (RADVisualComponent) component },
0707: new LayoutConstraints[] { getComponentLayoutConstraints() },
0708: componentIndex);
0709: } else {
0710: ((RADVisualComponent) component)
0711: .resetConstraintsProperties();
0712: }
0713: }
0714:
0715: getFormModel().fireComponentAdded(component,
0716: getCreatedDeleted());
0717: }
0718:
0719: private void removeComponent() {
0720: getFormModel().removeComponentImpl(getComponent(),
0721: getCreatedDeleted());
0722: }
0723:
0724: private void undoComponentsReorder() {
0725: if (getContainer() != null && reordering != null) {
0726: int[] revPerm = new int[reordering.length];
0727: for (int i = 0; i < reordering.length; i++)
0728: revPerm[reordering[i]] = i;
0729:
0730: getContainer().reorderSubComponents(revPerm);
0731: getFormModel().fireComponentsReordered(getContainer(),
0732: revPerm);
0733: }
0734: }
0735:
0736: private void redoComponentsReorder() {
0737: if (getContainer() != null && reordering != null) {
0738: getContainer().reorderSubComponents(reordering);
0739: getFormModel().fireComponentsReordered(getContainer(),
0740: reordering);
0741: }
0742: }
0743:
0744: private void undoComponentPropertyChange() {
0745: Node.Property prop = getComponent().getPropertyByName(
0746: getPropertyName());
0747: if (prop != null)
0748: try {
0749: prop.setValue(getOldPropertyValue());
0750: } catch (Exception ex) { // should not happen
0751: Logger.getLogger(getClass().getName()).log(
0752: Level.INFO, ex.getMessage(), ex);
0753: }
0754: }
0755:
0756: private void redoComponentPropertyChange() {
0757: Node.Property prop = getComponent().getPropertyByName(
0758: getPropertyName());
0759: if (prop != null)
0760: try {
0761: prop.setValue(getNewPropertyValue());
0762: } catch (Exception ex) { // should not happen
0763: Logger.getLogger(getClass().getName()).log(
0764: Level.INFO, ex.getMessage(), ex);
0765: }
0766: }
0767:
0768: private void undoBindingPropertyChange() {
0769: String subPropName = getSubPropertyName();
0770: BindingProperty prop = getComponent().getBindingProperty(
0771: getPropertyName());
0772: if (subPropName == null) {
0773: if (prop != null) {
0774: try {
0775: prop.setValue(getOldBinding());
0776: } catch (Exception ex) { // should not happen
0777: Logger.getLogger(getClass().getName()).log(
0778: Level.INFO, ex.getMessage(), ex);
0779: }
0780: }
0781: } else {
0782: FormProperty subProp = prop.getSubProperty(subPropName);
0783: try {
0784: subProp.setValue(getOldPropertyValue());
0785: } catch (Exception ex) {
0786: Logger.getLogger(getClass().getName()).log(
0787: Level.INFO, ex.getMessage(), ex);
0788: }
0789: }
0790: }
0791:
0792: private void redoBindingPropertyChange() {
0793: String subPropName = getSubPropertyName();
0794: BindingProperty prop = getComponent().getBindingProperty(
0795: getPropertyName());
0796: if (subPropName == null) {
0797: if (prop != null) {
0798: try {
0799: prop.setValue(getNewBinding());
0800: } catch (Exception ex) { // should not happen
0801: Logger.getLogger(getClass().getName()).log(
0802: Level.INFO, ex.getMessage(), ex);
0803: }
0804: }
0805: } else {
0806: FormProperty subProp = prop.getSubProperty(subPropName);
0807: try {
0808: subProp.setValue(getNewPropertyValue());
0809: } catch (Exception ex) {
0810: Logger.getLogger(getClass().getName()).log(
0811: Level.INFO, ex.getMessage(), ex);
0812: }
0813: }
0814: }
0815:
0816: private void undoSyntheticPropertyChange() {
0817: String propName = getPropertyName();
0818: if (propName.startsWith(RADProperty.SYNTH_PREFIX)) {
0819: // special case - pre/post init code of a property
0820: if (propName.startsWith(RADProperty.SYNTH_PRE_CODE)) {
0821: FormProperty prop = (FormProperty) getComponent()
0822: .getPropertyByName(
0823: propName
0824: .substring(RADProperty.SYNTH_PRE_CODE
0825: .length()));
0826: prop.setPreCode((String) getOldPropertyValue());
0827: } else if (propName
0828: .startsWith(RADProperty.SYNTH_POST_CODE)) {
0829: FormProperty prop = (FormProperty) getComponent()
0830: .getPropertyByName(
0831: propName
0832: .substring(RADProperty.SYNTH_POST_CODE
0833: .length()));
0834: prop.setPostCode((String) getOldPropertyValue());
0835: }
0836: } else {
0837: Node.Property[] props;
0838: if (getComponent() == null) { // form synthetic property
0839: FormEditor formEditor = FormEditor
0840: .getFormEditor(getFormModel());
0841: FormRootNode rootNode = (FormRootNode) formEditor
0842: .getFormRootNode();
0843: props = rootNode.getAllProperties();
0844: } else { // component synthetic property
0845: props = getComponent().getSyntheticProperties();
0846: }
0847: for (int i = 0; i < props.length; i++) {
0848: if (props[i].getName().equals(propName)) {
0849: try {
0850: props[i].setValue(getOldPropertyValue());
0851: } catch (Exception ex) { // should not happen
0852: Logger.getLogger(getClass().getName()).log(
0853: Level.INFO, ex.getMessage(), ex);
0854: }
0855: break;
0856: }
0857: }
0858: }
0859: }
0860:
0861: private void redoSyntheticPropertyChange() {
0862: String propName = getPropertyName();
0863: if (propName.startsWith(RADProperty.SYNTH_PREFIX)) {
0864: // special case - pre/post init code of a property
0865: if (propName.startsWith(RADProperty.SYNTH_PRE_CODE)) {
0866: FormProperty prop = (FormProperty) getComponent()
0867: .getPropertyByName(
0868: propName
0869: .substring(RADProperty.SYNTH_PRE_CODE
0870: .length()));
0871: prop.setPreCode((String) getNewPropertyValue());
0872: } else if (propName
0873: .startsWith(RADProperty.SYNTH_POST_CODE)) {
0874: FormProperty prop = (FormProperty) getComponent()
0875: .getPropertyByName(
0876: propName
0877: .substring(RADProperty.SYNTH_POST_CODE
0878: .length()));
0879: prop.setPostCode((String) getNewPropertyValue());
0880: }
0881: } else {
0882: Node.Property[] props;
0883: if (getComponent() == null) { // form synthetic property
0884: FormEditor formEditor = FormEditor
0885: .getFormEditor(getFormModel());
0886: FormRootNode rootNode = (FormRootNode) formEditor
0887: .getFormRootNode();
0888: props = rootNode.getAllProperties();
0889: } else { // component synthetic property
0890: props = getComponent().getSyntheticProperties();
0891: }
0892: for (int i = 0; i < props.length; i++) {
0893: if (props[i].getName().equals(propName)) {
0894: try {
0895: props[i].setValue(getNewPropertyValue());
0896: } catch (Exception ex) { // should not happen
0897: Logger.getLogger(getClass().getName()).log(
0898: Level.INFO, ex.getMessage(), ex);
0899: }
0900: break;
0901: }
0902: }
0903: }
0904: }
0905:
0906: private void undoEventHandlerAddition() {
0907: Event event = getComponentEvent();
0908: if (event == null)
0909: return;
0910:
0911: addToInterestList(FormModelEvent.this );
0912:
0913: getFormModel().getFormEvents().detachEvent(event,
0914: getEventHandler());
0915:
0916: removeFromInterestList(FormModelEvent.this );
0917:
0918: // hack: reset the event property to update the property sheet
0919: Node.Property prop = getComponent().getPropertyByName(
0920: event.getId());
0921: if (prop != null) {
0922: try {
0923: if (getEventHandler().equals(prop.getValue()))
0924: prop.setValue(null);
0925: } catch (Exception ex) { // should not happen
0926: Logger.getLogger(getClass().getName()).log(
0927: Level.INFO, ex.getMessage(), ex);
0928: }
0929: }
0930: }
0931:
0932: private void redoEventHandlerAddition() {
0933: Event event = getComponentEvent();
0934: if (event == null)
0935: return;
0936:
0937: getFormModel().getFormEvents().attachEvent(event,
0938: getEventHandler(), getOldEventHandlerContent(),
0939: getOldEventHandlerAnnotation());
0940:
0941: // hack: set the event property to update the property sheet
0942: Node.Property prop = getComponent().getPropertyByName(
0943: event.getId());
0944: if (prop != null) {
0945: try {
0946: prop.setValue(getEventHandler());
0947: } catch (Exception ex) { // should not happen
0948: Logger.getLogger(getClass().getName()).log(
0949: Level.INFO, ex.getMessage(), ex);
0950: }
0951: }
0952: }
0953:
0954: private void undoEventHandlerRemoval() {
0955: Event event = getComponentEvent();
0956: if (event == null)
0957: return;
0958:
0959: getFormModel().getFormEvents().attachEvent(event,
0960: getEventHandler(), getOldEventHandlerContent(),
0961: getOldEventHandlerAnnotation());
0962:
0963: // hack: set the event property to update the property sheet
0964: Node.Property prop = getComponent().getPropertyByName(
0965: event.getId());
0966: if (prop != null) {
0967: try {
0968: prop.setValue(getEventHandler());
0969: } catch (Exception ex) { // should not happen
0970: Logger.getLogger(getClass().getName()).log(
0971: Level.INFO, ex.getMessage(), ex);
0972: }
0973: }
0974: }
0975:
0976: private void redoEventHandlerRemoval() {
0977: Event event = getComponentEvent();
0978: if (event == null)
0979: return;
0980:
0981: addToInterestList(FormModelEvent.this );
0982:
0983: getFormModel().getFormEvents().detachEvent(event,
0984: getEventHandler());
0985:
0986: removeFromInterestList(FormModelEvent.this );
0987:
0988: // hack: reset the event property to reflect the change in property sheet
0989: Node.Property prop = getComponent().getPropertyByName(
0990: event.getId());
0991: if (prop != null) {
0992: try {
0993: if (getEventHandler().equals(prop.getValue()))
0994: prop.setValue(null);
0995: } catch (Exception ex) { // should not happen
0996: Logger.getLogger(getClass().getName()).log(
0997: Level.INFO, ex.getMessage(), ex);
0998: }
0999: }
1000: }
1001:
1002: private void undoEventHandlerRenaming() {
1003: FormEvents formEvents = getFormModel().getFormEvents();
1004:
1005: formEvents.renameEventHandler(getNewEventHandler(),
1006: getOldEventHandler());
1007:
1008: Event[] events = formEvents
1009: .getEventsForHandler(getOldEventHandler());
1010: for (int i = 0; i < events.length; i++) {
1011: Node.Property prop = events[i].getComponent()
1012: .getPropertyByName(events[i].getId());
1013: if (prop != null) {
1014: try {
1015: prop.setValue(getOldEventHandler());
1016: } catch (Exception ex) { // should not happen
1017: Logger.getLogger(getClass().getName()).log(
1018: Level.INFO, ex.getMessage(), ex);
1019: }
1020: }
1021: }
1022: }
1023:
1024: private void redoEventHandlerRenaming() {
1025: FormEvents formEvents = getFormModel().getFormEvents();
1026:
1027: formEvents.renameEventHandler(getOldEventHandler(),
1028: getNewEventHandler());
1029:
1030: Event[] events = formEvents
1031: .getEventsForHandler(getNewEventHandler());
1032: for (int i = 0; i < events.length; i++) {
1033: Node.Property prop = events[i].getComponent()
1034: .getPropertyByName(events[i].getId());
1035: if (prop != null) {
1036: try {
1037: prop.setValue(getNewEventHandler());
1038: } catch (Exception ex) { // should not happen
1039: Logger.getLogger(getClass().getName()).log(
1040: Level.INFO, ex.getMessage(), ex);
1041: }
1042: }
1043: }
1044: }
1045: }
1046: }
|