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-2007 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.uml.core.metamodel.infrastructure.coreinfrastructure;
0043:
0044: import java.util.Vector;
0045:
0046: import org.netbeans.modules.uml.core.eventframework.EventDispatcher;
0047: import org.netbeans.modules.uml.core.eventframework.EventFunctor;
0048: import org.netbeans.modules.uml.core.eventframework.EventManager;
0049: import org.netbeans.modules.uml.core.eventframework.IEventPayload;
0050: import org.netbeans.modules.uml.core.metamodel.core.constructs.IEnumerationLiteral;
0051: import org.netbeans.modules.uml.core.metamodel.core.foundation.IConstraint;
0052: import org.netbeans.modules.uml.core.metamodel.core.foundation.IExpression;
0053: import org.netbeans.modules.uml.core.metamodel.core.foundation.IMultiplicity;
0054: import org.netbeans.modules.uml.core.metamodel.core.foundation.IMultiplicityRange;
0055: import org.netbeans.modules.uml.core.metamodel.core.foundation.IVersionableElement;
0056:
0057: import org.netbeans.modules.uml.core.support.umlsupport.IResultCell;
0058: import org.netbeans.modules.uml.core.support.umlutils.ETList;
0059:
0060: public class ClassifierEventDispatcher extends EventDispatcher
0061: implements IClassifierEventDispatcher {
0062: private EventManager<IClassifierFeatureEventsSink> m_ClassifierSink = null;
0063: private EventManager<IFeatureEventsSink> m_FeatureSink = null;
0064: private EventManager<IStructuralFeatureEventsSink> m_StructFeatureSink = null;
0065: private EventManager<IBehavioralFeatureEventsSink> m_BehavFeatureSink = null;
0066: private EventManager<IParameterEventsSink> m_ParmSink = null;
0067: private EventManager<ITypedElementEventsSink> m_TypeSink = null;
0068: private EventManager<IAttributeEventsSink> m_AttrSink = null;
0069: private EventManager<IOperationEventsSink> m_OperSink = null;
0070: private EventManager<IClassifierTransformEventsSink> m_TransformSink = null;
0071: private EventManager<IAssociationEndTransformEventsSink> m_AssociationEndTransformSink = null;
0072: private EventManager<IAssociationEndEventsSink> m_AssociationEndEventsSink = null;
0073: private EventManager<IAffectedElementEventsSink> m_AffectedSink = null;
0074:
0075: public ClassifierEventDispatcher() {
0076: m_ClassifierSink = new EventManager<IClassifierFeatureEventsSink>();
0077: m_FeatureSink = new EventManager<IFeatureEventsSink>();
0078: m_StructFeatureSink = new EventManager<IStructuralFeatureEventsSink>();
0079: m_BehavFeatureSink = new EventManager<IBehavioralFeatureEventsSink>();
0080: m_ParmSink = new EventManager<IParameterEventsSink>();
0081: m_TypeSink = new EventManager<ITypedElementEventsSink>();
0082: m_AttrSink = new EventManager<IAttributeEventsSink>();
0083: m_OperSink = new EventManager<IOperationEventsSink>();
0084: m_TransformSink = new EventManager<IClassifierTransformEventsSink>();
0085: m_AssociationEndTransformSink = new EventManager<IAssociationEndTransformEventsSink>();
0086: m_AssociationEndEventsSink = new EventManager<IAssociationEndEventsSink>();
0087: m_AffectedSink = new EventManager<IAffectedElementEventsSink>();
0088: }
0089:
0090: /**
0091: * Fired whenever an existing parameter is about to be removed from the behavioral
0092: * feature's list of parameters.
0093: *
0094: * @param feature[in]
0095: * @param parm[in]
0096: * @param payload[in]
0097: */
0098: public boolean firePreParameterRemoved(IBehavioralFeature feature,
0099: IParameter parm, IEventPayload payload) {
0100: boolean proceed = true;
0101:
0102: Vector<Object> vect = new Vector<Object>();
0103: vect.add(0, feature);
0104: vect.add(1, parm);
0105: Object var = prepareVariant(vect);
0106:
0107: if (validateEvent("PreParameterRemoved", var)) {
0108: IResultCell cell = prepareResultCell(payload);
0109: EventFunctor preParameterRemoved = new EventFunctor(
0110: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
0111: "onPreParameterRemoved");
0112:
0113: Object[] parms = new Object[2];
0114: parms[0] = var;
0115: parms[1] = cell;
0116: preParameterRemoved.setParameters(parms);
0117: m_BehavFeatureSink
0118: .notifyListenersWithQualifiedProceed(preParameterRemoved);
0119: if (cell != null) {
0120: proceed = cell.canContinue();
0121: }
0122: }
0123: return proceed;
0124: }
0125:
0126: /**
0127: * Fired whenever an existing parameter was just removed from the behavioral
0128: * feature's list of parameters.
0129: *
0130: * @param feature[in]
0131: * @param parm[in]
0132: */
0133: public void fireParameterRemoved(IBehavioralFeature feature,
0134: IParameter parm, IEventPayload payload) {
0135: if (validateEvent("ParameterRemoved", feature)) {
0136: IResultCell cell = prepareResultCell(payload);
0137: EventFunctor paramRemoved = new EventFunctor(
0138: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
0139: "onParameterRemoved");
0140:
0141: Object[] parms = new Object[] { feature, parm, cell };
0142: paramRemoved.setParameters(parms);
0143: m_BehavFeatureSink.notifyListeners(paramRemoved);
0144: }
0145: }
0146:
0147: /**
0148: * Fired whenever the abstract flag on the behavioral feature is about to be
0149: * modified.
0150: *
0151: * @param feature[in]
0152: * @param proposedValue[in]
0153: * @param payload[in]
0154: */
0155: public boolean firePreAbstractModified(IBehavioralFeature feature,
0156: boolean proposedValue, IEventPayload payload) {
0157: boolean proceed = true;
0158:
0159: Vector<Object> vect = new Vector<Object>();
0160: vect.add(0, feature);
0161: vect.add(1, new Boolean(proposedValue));
0162: Object var = prepareVariant(vect);
0163:
0164: if (validateEvent("PreAbstractModified", var)) {
0165: IResultCell cell = prepareResultCell(payload);
0166: EventFunctor preAbstractModified = new EventFunctor(
0167: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
0168: "onPreAbstractModified");
0169:
0170: Object[] parms = new Object[2];
0171: parms[0] = var;
0172: parms[1] = cell;
0173: preAbstractModified.setParameters(parms);
0174: m_BehavFeatureSink
0175: .notifyListenersWithQualifiedProceed(preAbstractModified);
0176: if (cell != null) {
0177: proceed = cell.canContinue();
0178: }
0179: }
0180: return proceed;
0181: }
0182:
0183: /**
0184: * Fired whenever the abstract flag on the behavioral feature has been modified.
0185: *
0186: * @param feature[in]
0187: * @param payload[in]
0188: */
0189: public void fireAbstractModified(IBehavioralFeature feature,
0190: IEventPayload payload) {
0191: if (validateEvent("AbstractModified", feature)) {
0192: IResultCell cell = prepareResultCell(payload);
0193: EventFunctor abstractModified = new EventFunctor(
0194: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
0195: "onAbstractModified");
0196:
0197: Object[] parms = new Object[2];
0198: parms[0] = feature;
0199: parms[1] = cell;
0200: abstractModified.setParameters(parms);
0201: m_BehavFeatureSink.notifyListeners(abstractModified);
0202: }
0203: }
0204:
0205: public boolean firePreStrictFPModified(IBehavioralFeature feature,
0206: boolean proposedValue, IEventPayload payload) {
0207: boolean proceed = true;
0208:
0209: Vector<Object> vect = new Vector<Object>();
0210: vect.add(0, feature);
0211: vect.add(1, new Boolean(proposedValue));
0212:
0213: Object var = prepareVariant(vect);
0214:
0215: if (validateEvent("PreStrictFPModified", var)) {
0216: IResultCell cell = prepareResultCell(payload);
0217: EventFunctor preStrictFPModified = new EventFunctor(
0218: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
0219: "onPreStrictFPModified");
0220:
0221: Object[] parms = new Object[2];
0222: parms[0] = var;
0223: parms[1] = cell;
0224: preStrictFPModified.setParameters(parms);
0225: m_BehavFeatureSink
0226: .notifyListenersWithQualifiedProceed(preStrictFPModified);
0227: if (cell != null) {
0228: proceed = cell.canContinue();
0229: }
0230: }
0231: return proceed;
0232: }
0233:
0234: public void fireStrictFPModified(IBehavioralFeature feature,
0235: IEventPayload payload) {
0236: if (validateEvent("StrictFPModified", feature)) {
0237: IResultCell cell = prepareResultCell(payload);
0238: EventFunctor strictFPModified = new EventFunctor(
0239: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
0240: "onStrictFPModified");
0241:
0242: Object[] parms = new Object[2];
0243: parms[0] = feature;
0244: parms[1] = cell;
0245: strictFPModified.setParameters(parms);
0246: m_BehavFeatureSink.notifyListeners(strictFPModified);
0247: }
0248: }
0249:
0250: /**
0251: * Fired whenever the default expression for the parameter
0252: * is about to change.
0253: *
0254: * @param feature[in]
0255: * @param proposedValue[in]
0256: * @param payload[in]
0257: */
0258: public boolean firePreDefaultExpModified(IParameter feature,
0259: IExpression proposedValue, IEventPayload payload) {
0260: boolean proceed = true;
0261:
0262: Vector<Object> vect = new Vector<Object>();
0263: vect.add(0, feature);
0264: vect.add(1, proposedValue);
0265: Object var = prepareVariant(vect);
0266:
0267: if (validateEvent("PreDefaultExpModified", var)) {
0268: IResultCell cell = prepareResultCell(payload);
0269: EventFunctor preDefaultExpModified = new EventFunctor(
0270: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterEventsSink",
0271: "onPreDefaultExpModified");
0272:
0273: Object[] parms = new Object[2];
0274: parms[0] = var;
0275: parms[1] = cell;
0276: preDefaultExpModified.setParameters(parms);
0277: m_ParmSink
0278: .notifyListenersWithQualifiedProceed(preDefaultExpModified);
0279: if (cell != null) {
0280: proceed = cell.canContinue();
0281: }
0282: }
0283: return proceed;
0284: }
0285:
0286: /* (non-Javadoc)
0287: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireDefaultExpModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameter, org.netbeans.modules.uml.core.eventframework.IEventPayload)
0288: */
0289: public void fireDefaultExpModified(IParameter feature,
0290: IEventPayload payload) {
0291: if (validateEvent("DefaultExpModified", feature)) {
0292: IResultCell cell = prepareResultCell(payload);
0293: EventFunctor defaultExpModified = new EventFunctor(
0294: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterEventsSink",
0295: "onDefaultExpModified");
0296:
0297: Object[] parms = new Object[2];
0298: parms[0] = feature;
0299: parms[1] = cell;
0300: defaultExpModified.setParameters(parms);
0301: m_ParmSink.notifyListeners(defaultExpModified);
0302: }
0303: }
0304:
0305: /**
0306: * Fired whenever the default expression's body property for the
0307: * parameter is about to change.
0308: *
0309: * @param feature[in]
0310: * @param bodyValue[in]
0311: * @param payload[in]
0312: */
0313: public boolean firePreDefaultExpBodyModified(IParameter feature,
0314: String bodyValue, IEventPayload payload) {
0315: boolean proceed = true;
0316:
0317: Vector<Object> vect = new Vector<Object>();
0318: vect.add(0, feature);
0319: vect.add(1, bodyValue);
0320: Object var = prepareVariant(vect);
0321:
0322: if (validateEvent("PreDefaultExpBodyModified", var)) {
0323: IResultCell cell = prepareResultCell(payload);
0324: EventFunctor preDefaultExpBodyModified = new EventFunctor(
0325: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterEventsSink",
0326: "onPreDefaultExpBodyModified");
0327:
0328: Object[] parms = new Object[2];
0329: parms[0] = var;
0330: parms[1] = cell;
0331: preDefaultExpBodyModified.setParameters(parms);
0332: m_ParmSink
0333: .notifyListenersWithQualifiedProceed(preDefaultExpBodyModified);
0334: if (cell != null) {
0335: proceed = cell.canContinue();
0336: }
0337: }
0338: return proceed;
0339: }
0340:
0341: /* (non-Javadoc)
0342: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireDefaultExpBodyModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameter, org.netbeans.modules.uml.core.eventframework.IEventPayload)
0343: */
0344: public void fireDefaultExpBodyModified(IParameter feature,
0345: IEventPayload payload) {
0346: if (validateEvent("DefaultExpBodyModified", feature)) {
0347: IResultCell cell = prepareResultCell(payload);
0348: EventFunctor defaultExpBodyModified = new EventFunctor(
0349: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterEventsSink",
0350: "onDefaultExpBodyModified");
0351:
0352: Object[] parms = new Object[2];
0353: parms[0] = feature;
0354: parms[1] = cell;
0355: defaultExpBodyModified.setParameters(parms);
0356: m_ParmSink.notifyListeners(defaultExpBodyModified);
0357: }
0358: }
0359:
0360: /**
0361: * Fired whenever the default expression's language property for the
0362: * parameter is about to change.
0363: *
0364: * @param feature[in]
0365: * @param language[in]
0366: * @param payload[in]
0367: */
0368: public boolean firePreDefaultExpLanguageModified(
0369: IParameter feature, String language, IEventPayload payload) {
0370: boolean proceed = true;
0371:
0372: Vector<Object> vect = new Vector<Object>();
0373: vect.add(0, feature);
0374: vect.add(1, language);
0375: Object var = prepareVariant(vect);
0376:
0377: if (validateEvent("PreDefaultExpLanguageModified", var)) {
0378: IResultCell cell = prepareResultCell(payload);
0379: EventFunctor preDefaultExpLanguageModified = new EventFunctor(
0380: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterEventsSink",
0381: "onPreDefaultExpLanguageModified");
0382:
0383: Object[] params = new Object[2];
0384: params[0] = var;
0385: params[1] = cell;
0386: preDefaultExpLanguageModified.setParameters(params);
0387: m_ParmSink
0388: .notifyListenersWithQualifiedProceed(preDefaultExpLanguageModified);
0389: if (cell != null) {
0390: proceed = cell.canContinue();
0391: }
0392: }
0393: return proceed;
0394: }
0395:
0396: /**
0397: * Fired whenever the default expression's language property for the
0398: * parameter has changed.
0399: *
0400: * @param feature[in]
0401: * @param payload[in]
0402: */
0403: public void fireDefaultExpLanguageModified(IParameter feature,
0404: IEventPayload payload) {
0405: if (validateEvent("DefaultExpLanguageModified", feature)) {
0406: IResultCell cell = prepareResultCell(payload);
0407: EventFunctor defaultExpLanguageModified = new EventFunctor(
0408: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterEventsSink",
0409: "onDefaultExpLanguageModified");
0410:
0411: Object[] params = new Object[2];
0412: params[0] = feature;
0413: params[1] = cell;
0414: defaultExpLanguageModified.setParameters(params);
0415: m_ParmSink.notifyListeners(defaultExpLanguageModified);
0416: }
0417: }
0418:
0419: /**
0420: * Fired whenever the direction value of the parameter is about to change.
0421: *
0422: * @param feature[in]
0423: * @param proposedValue[in]
0424: * @param payload[in]
0425: */
0426: public boolean firePreDirectionModified(IParameter feature,
0427: int proposedValue, IEventPayload payload) {
0428: boolean proceed = true;
0429:
0430: Vector<Object> vect = new Vector<Object>();
0431: vect.add(0, feature);
0432: vect.add(1, new Integer(proposedValue));
0433: Object var = prepareVariant(vect);
0434:
0435: if (validateEvent("PreDirectionModified", var)) {
0436: IResultCell cell = prepareResultCell(payload);
0437: EventFunctor preDirectionModified = new EventFunctor(
0438: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterEventsSink",
0439: "onPreDirectionModified");
0440:
0441: Object[] parms = new Object[2];
0442: parms[0] = var;
0443: parms[1] = cell;
0444: preDirectionModified.setParameters(parms);
0445: m_ParmSink
0446: .notifyListenersWithQualifiedProceed(preDirectionModified);
0447: if (cell != null) {
0448: proceed = cell.canContinue();
0449: }
0450: }
0451: return proceed;
0452: }
0453:
0454: /**
0455: * Fired whenever the direction value of the parameter has changed
0456: *
0457: * @param feature[in]
0458: * @param payload[in]
0459: */
0460: public void fireDirectionModified(IParameter feature,
0461: IEventPayload payload) {
0462: if (validateEvent("DirectionModified", feature)) {
0463: IResultCell cell = prepareResultCell(payload);
0464: EventFunctor directionModified = new EventFunctor(
0465: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterEventsSink",
0466: "onDirectionModified");
0467:
0468: Object[] parms = new Object[2];
0469: parms[0] = feature;
0470: parms[1] = cell;
0471: directionModified.setParameters(parms);
0472: m_ParmSink.notifyListeners(directionModified);
0473: }
0474: }
0475:
0476: /**
0477: * Fired whenever the Multiplicity object on a particular element is about
0478: * to be modified.
0479: *
0480: * @param element[in]
0481: * @param proposedValue[in]
0482: * @param payload[in]
0483: */
0484: public boolean firePreMultiplicityModified(ITypedElement element,
0485: IMultiplicity proposedValue, IEventPayload payload) {
0486: boolean proceed = true;
0487:
0488: Vector<Object> vect = new Vector<Object>();
0489: vect.add(0, element);
0490: vect.add(1, proposedValue);
0491: Object var = prepareVariant(vect);
0492:
0493: if (validateEvent("PreMultiplicityModified", var)) {
0494: IResultCell cell = prepareResultCell(payload);
0495: EventFunctor preMultiplicityModified = new EventFunctor(
0496: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0497: "onPreMultiplicityModified");
0498:
0499: Object[] parms = new Object[2];
0500: parms[0] = var;
0501: parms[1] = cell;
0502: preMultiplicityModified.setParameters(parms);
0503: m_TypeSink
0504: .notifyListenersWithQualifiedProceed(preMultiplicityModified);
0505: if (cell != null) {
0506: proceed = cell.canContinue();
0507: }
0508: }
0509: return proceed;
0510: }
0511:
0512: /* (non-Javadoc)
0513: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireMultiplicityModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElement, org.netbeans.modules.uml.core.eventframework.IEventPayload)
0514: */
0515: public void fireMultiplicityModified(ITypedElement element,
0516: IEventPayload payload) {
0517: if (validateEvent("MultiplicityModified", element)) {
0518: IResultCell cell = prepareResultCell(payload);
0519: EventFunctor multiplicityModified = new EventFunctor(
0520: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0521: "onMultiplicityModified");
0522:
0523: Object[] parms = new Object[2];
0524: parms[0] = element;
0525: parms[1] = cell;
0526: multiplicityModified.setParameters(parms);
0527: m_TypeSink.notifyListeners(multiplicityModified);
0528: }
0529: }
0530:
0531: /**
0532: * Fired whenever the type on a particular element is about to be modifed.
0533: *
0534: * @param element[in]
0535: * @param proposedValue[in]
0536: * @param payload[in]
0537: */
0538: public boolean firePreTypeModified(ITypedElement element,
0539: IClassifier proposedValue, IEventPayload payload) {
0540: boolean proceed = true;
0541:
0542: Vector<Object> vect = new Vector<Object>();
0543: vect.add(0, element);
0544: vect.add(1, proposedValue);
0545: Object var = prepareVariant(vect);
0546:
0547: if (validateEvent("PreTypeModified", var)) {
0548: IResultCell cell = prepareResultCell(payload);
0549: EventFunctor preTypeModified = new EventFunctor(
0550: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0551: "onPreTypeModified");
0552:
0553: Object[] parms = new Object[2];
0554: parms[0] = var;
0555: parms[1] = cell;
0556: preTypeModified.setParameters(parms);
0557: m_TypeSink
0558: .notifyListenersWithQualifiedProceed(preTypeModified);
0559: if (cell != null) {
0560: proceed = cell.canContinue();
0561: }
0562: }
0563: return proceed;
0564: }
0565:
0566: /**
0567: * Fired whenever the type flag on a particular element was just modified.
0568: *
0569: * @param element[in]
0570: * @param payload[in]
0571: */
0572: public void fireTypeModified(ITypedElement element,
0573: IEventPayload payload) {
0574: if (validateEvent("TypeModified", element)) {
0575: IResultCell cell = prepareResultCell(payload);
0576: EventFunctor typeModified = new EventFunctor(
0577: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0578: "onTypeModified");
0579:
0580: Object[] parms = new Object[2];
0581: parms[0] = element;
0582: parms[1] = cell;
0583: typeModified.setParameters(parms);
0584: m_TypeSink.notifyListeners(typeModified);
0585: }
0586:
0587: }
0588:
0589: /**
0590: * Fired whenever the lower property on the passed-in range is about
0591: * to be modified.
0592: *
0593: * @param element[in]
0594: * @param mult[in]
0595: * @param range[in]
0596: * @param proposedValue[in]
0597: * @param payload[in]
0598: */
0599: public boolean firePreLowerModified(ITypedElement element,
0600: IMultiplicity mult, IMultiplicityRange range,
0601: String proposedValue, IEventPayload payload) {
0602: boolean proceed = true;
0603:
0604: Vector<Object> vect = new Vector<Object>();
0605: vect.add(0, element);
0606: vect.add(1, mult);
0607: vect.add(2, range);
0608: vect.add(3, proposedValue);
0609: Object var = prepareVariant(vect);
0610:
0611: if (validateEvent("PreLowerModified", var)) {
0612: IResultCell cell = prepareResultCell(payload);
0613: EventFunctor preLowerModified = new EventFunctor(
0614: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0615: "onPreLowerModified");
0616:
0617: Object[] params = new Object[2];
0618: params[0] = var;
0619: params[1] = cell;
0620: preLowerModified.setParameters(params);
0621: m_TypeSink
0622: .notifyListenersWithQualifiedProceed(preLowerModified);
0623: if (cell != null) {
0624: proceed = cell.canContinue();
0625: }
0626: }
0627: return proceed;
0628: }
0629:
0630: /**
0631: * Fired whenever the lower property on the passed-in range was modified.
0632: *
0633: * @param element[in]
0634: * @param mult[in]
0635: * @param range[in]
0636: */
0637: public void fireLowerModified(ITypedElement element,
0638: IMultiplicity mult, IMultiplicityRange range,
0639: IEventPayload payload) {
0640: Vector<Object> vect = new Vector<Object>();
0641: vect.add(0, element);
0642: vect.add(1, mult);
0643: vect.add(2, range);
0644:
0645: Object var = prepareVariant(vect);
0646:
0647: if (validateEvent("LowerModified", var)) {
0648: IResultCell cell = prepareResultCell(payload);
0649: EventFunctor lowerModified = new EventFunctor(
0650: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0651: "onLowerModified");
0652:
0653: Object[] params = new Object[2];
0654: params[0] = var;
0655: params[1] = cell;
0656: lowerModified.setParameters(params);
0657: m_TypeSink.notifyListeners(lowerModified);
0658: }
0659: }
0660:
0661: /**
0662: * Fired whenever the lower property on the passed-in range was modified.
0663: *
0664: * @param element
0665: * @param mult
0666: * @param range
0667: * @param payload
0668: */
0669: public void fireCollectionTypeModified(ITypedElement element,
0670: IMultiplicity mult, IMultiplicityRange range,
0671: IEventPayload payload) {
0672: Vector<Object> vect = new Vector<Object>();
0673: vect.add(0, element);
0674: vect.add(1, mult);
0675: vect.add(2, range);
0676:
0677: Object var = prepareVariant(vect);
0678:
0679: if (validateEvent("CollectionTypeModified", var)) {
0680: IResultCell cell = prepareResultCell(payload);
0681: EventFunctor lowerModified = new EventFunctor(
0682: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0683: "onCollectionTypeModified");
0684:
0685: Object[] params = new Object[2];
0686: params[0] = var;
0687: params[1] = cell;
0688: lowerModified.setParameters(params);
0689: m_TypeSink.notifyListeners(lowerModified);
0690: }
0691: }
0692:
0693: /* (non-Javadoc)
0694: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#firePreUpperModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElement, org.netbeans.modules.uml.core.metamodel.core.foundation.IMultiplicity, org.netbeans.modules.uml.core.metamodel.core.foundation.IMultiplicityRange, java.lang.String, org.netbeans.modules.uml.core.eventframework.IEventPayload)
0695: */
0696: public boolean firePreUpperModified(ITypedElement element,
0697: IMultiplicity mult, IMultiplicityRange range,
0698: String proposedValue, IEventPayload payload) {
0699: boolean proceed = true;
0700:
0701: Vector<Object> vect = new Vector<Object>();
0702: vect.add(0, element);
0703: vect.add(1, mult);
0704: vect.add(2, range);
0705: vect.add(3, proposedValue);
0706: Object var = prepareVariant(vect);
0707:
0708: if (validateEvent("PreUpperModified", var)) {
0709: IResultCell cell = prepareResultCell(payload);
0710: EventFunctor preUpperModified = new EventFunctor(
0711: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0712: "onPreUpperModified");
0713:
0714: Object[] params = new Object[2];
0715: params[0] = var;
0716: params[1] = cell;
0717: preUpperModified.setParameters(params);
0718: m_TypeSink
0719: .notifyListenersWithQualifiedProceed(preUpperModified);
0720: if (cell != null) {
0721: proceed = cell.canContinue();
0722: }
0723: }
0724: return proceed;
0725: }
0726:
0727: /**
0728: * Fired when the upper property on the passed-in range was modified.
0729: *
0730: * @param element[in]
0731: * @param mult[in]
0732: * @param range[in]
0733: */
0734: public void fireUpperModified(ITypedElement element,
0735: IMultiplicity mult, IMultiplicityRange range,
0736: IEventPayload payload) {
0737: Vector<Object> vect = new Vector<Object>();
0738: vect.add(0, element);
0739: vect.add(1, mult);
0740: vect.add(2, range);
0741:
0742: Object var = prepareVariant(vect);
0743:
0744: if (validateEvent("UpperModified", var)) {
0745: IResultCell cell = prepareResultCell(payload);
0746: EventFunctor upperModified = new EventFunctor(
0747: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0748: "onUpperModified");
0749:
0750: Object[] params = new Object[2];
0751: params[0] = var;
0752: params[1] = cell;
0753: upperModified.setParameters(params);
0754: m_TypeSink.notifyListeners(upperModified);
0755: }
0756: }
0757:
0758: /**
0759: * Fired when a new range is about to be added to the passed-in
0760: * multiplicity.
0761: *
0762: * @param element[in]
0763: * @param mult[in]
0764: * @param range[in]
0765: * @param payload[in]
0766: */
0767: public boolean firePreRangeAdded(ITypedElement element,
0768: IMultiplicity mult, IMultiplicityRange range,
0769: IEventPayload payload) {
0770: boolean proceed = true;
0771:
0772: Vector<Object> vect = new Vector<Object>();
0773: vect.add(0, element);
0774: vect.add(1, mult);
0775: vect.add(2, range);
0776: Object var = prepareVariant(vect);
0777:
0778: if (validateEvent("PreRangeAdded", var)) {
0779: IResultCell cell = prepareResultCell(payload);
0780: EventFunctor preRangeAdded = new EventFunctor(
0781: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0782: "onPreRangeAdded");
0783:
0784: Object[] params = new Object[2];
0785: params[0] = var;
0786: params[1] = cell;
0787: preRangeAdded.setParameters(params);
0788: m_TypeSink
0789: .notifyListenersWithQualifiedProceed(preRangeAdded);
0790: if (cell != null) {
0791: proceed = cell.canContinue();
0792: }
0793: }
0794: return proceed;
0795: }
0796:
0797: /**
0798: * Fired when a new range is added to the passed-in multiplicity.
0799: *
0800: * @param element[in]
0801: * @param mult[in]
0802: * @param range[in]
0803: * @param payload[in]
0804: */
0805: public void fireRangeAdded(ITypedElement element,
0806: IMultiplicity mult, IMultiplicityRange range,
0807: IEventPayload payload) {
0808: Vector<Object> vect = new Vector<Object>();
0809: vect.add(0, element);
0810: vect.add(1, mult);
0811: vect.add(2, range);
0812:
0813: Object var = prepareVariant(vect);
0814:
0815: if (validateEvent("RangeAdded", var)) {
0816: IResultCell cell = prepareResultCell(payload);
0817: EventFunctor rangeAdded = new EventFunctor(
0818: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0819: "onRangeAdded");
0820:
0821: Object[] params = new Object[2];
0822: params[0] = var;
0823: params[1] = cell;
0824: rangeAdded.setParameters(params);
0825: m_TypeSink.notifyListeners(rangeAdded);
0826: }
0827: }
0828:
0829: /**
0830: * Fired when an existing range is about to be removed from the passed-in
0831: * multiplicity.
0832: *
0833: * @param element[in]
0834: * @param mult[in]
0835: * @param range[in]
0836: * @param payload[in]
0837: */
0838: public boolean firePreRangeRemoved(ITypedElement element,
0839: IMultiplicity mult, IMultiplicityRange range,
0840: IEventPayload payload) {
0841: boolean proceed = true;
0842:
0843: Vector<Object> vect = new Vector<Object>();
0844: vect.add(0, element);
0845: vect.add(1, mult);
0846: vect.add(2, range);
0847: Object var = prepareVariant(vect);
0848:
0849: if (validateEvent("PreRangeRemoved", var)) {
0850: IResultCell cell = prepareResultCell(payload);
0851: EventFunctor preRangeRemoved = new EventFunctor(
0852: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0853: "onPreRangeRemoved");
0854:
0855: Object[] params = new Object[2];
0856: params[0] = var;
0857: params[1] = cell;
0858: preRangeRemoved.setParameters(params);
0859: m_TypeSink
0860: .notifyListenersWithQualifiedProceed(preRangeRemoved);
0861: if (cell != null) {
0862: proceed = cell.canContinue();
0863: }
0864: }
0865: return proceed;
0866: }
0867:
0868: /**
0869: * Fired when an existing range is removed from the passed-in multiplicity.
0870: *
0871: * @param element[in]
0872: * @param mult[in]
0873: * @param range[in]
0874: * @param payload[in]
0875: */
0876: public void fireRangeRemoved(ITypedElement element,
0877: IMultiplicity mult, IMultiplicityRange range,
0878: IEventPayload payload) {
0879: Vector<Object> vect = new Vector<Object>();
0880: vect.add(0, element);
0881: vect.add(1, mult);
0882: vect.add(2, range);
0883:
0884: Object var = prepareVariant(vect);
0885:
0886: if (validateEvent("RangeRemoved", var)) {
0887: IResultCell cell = prepareResultCell(payload);
0888: EventFunctor rangeRemoved = new EventFunctor(
0889: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0890: "onRangeRemoved");
0891:
0892: Object[] params = new Object[2];
0893: params[0] = var;
0894: params[1] = cell;
0895: rangeRemoved.setParameters(params);
0896: m_TypeSink.notifyListeners(rangeRemoved);
0897: }
0898: }
0899:
0900: /**
0901: * Fired when the order property is about to be changed on the passed-in
0902: * multiplicity.
0903: *
0904: * @param element[in]
0905: * @param mult[in]
0906: * @param proposedValue
0907: * @param range[in]
0908: * @param payload[in]
0909: */
0910: public boolean firePreOrderModified(ITypedElement element,
0911: IMultiplicity mult, boolean proposedValue,
0912: IEventPayload payload) {
0913: boolean proceed = true;
0914:
0915: Vector<Object> vect = new Vector<Object>();
0916: vect.add(0, element);
0917: vect.add(1, mult);
0918: vect.add(2, new Boolean(proposedValue));
0919: Object var = prepareVariant(vect);
0920:
0921: if (validateEvent("PreOrderModified", var)) {
0922: IResultCell cell = prepareResultCell(payload);
0923: EventFunctor preOrderModified = new EventFunctor(
0924: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0925: "onPreOrderModified");
0926:
0927: Object[] params = new Object[2];
0928: params[0] = var;
0929: params[1] = cell;
0930: preOrderModified.setParameters(params);
0931: m_TypeSink
0932: .notifyListenersWithQualifiedProceed(preOrderModified);
0933: if (cell != null) {
0934: proceed = cell.canContinue();
0935: }
0936: }
0937: return proceed;
0938: }
0939:
0940: /* (non-Javadoc)
0941: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireOrderModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElement, org.netbeans.modules.uml.core.metamodel.core.foundation.IMultiplicity, org.netbeans.modules.uml.core.eventframework.IEventPayload)
0942: */
0943: public void fireOrderModified(ITypedElement element,
0944: IMultiplicity mult, IEventPayload payload) {
0945: Vector<Object> vect = new Vector<Object>();
0946: vect.add(0, element);
0947: vect.add(1, mult);
0948:
0949: Object var = prepareVariant(vect);
0950:
0951: if (validateEvent("OrderModified", var)) {
0952: IResultCell cell = prepareResultCell(payload);
0953: EventFunctor m_OrderModified = new EventFunctor(
0954: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.ITypedElementEventsSink",
0955: "onOrderModified");
0956:
0957: Object[] params = new Object[2];
0958: params[0] = var;
0959: params[1] = cell;
0960: m_OrderModified.setParameters(params);
0961: m_TypeSink.notifyListeners(m_OrderModified);
0962: }
0963: }
0964:
0965: public boolean fireDefaultPreModified(IAttribute attr,
0966: IExpression proposedValue, IEventPayload payload) {
0967: boolean proceed = true;
0968:
0969: Vector<Object> vect = new Vector<Object>();
0970: vect.add(0, attr);
0971: vect.add(1, proposedValue);
0972: Object var = prepareVariant(vect);
0973:
0974: if (validateEvent("DefaultPreModified", var)) {
0975: IResultCell cell = prepareResultCell(payload);
0976: EventFunctor defaultPreModified = new EventFunctor(
0977: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
0978: "onDefaultPreModified");
0979:
0980: Object[] parms = new Object[2];
0981: parms[0] = var;
0982: parms[1] = cell;
0983: defaultPreModified.setParameters(parms);
0984: m_AttrSink
0985: .notifyListenersWithQualifiedProceed(defaultPreModified);
0986: if (cell != null) {
0987: proceed = cell.canContinue();
0988: }
0989: }
0990: return proceed;
0991: }
0992:
0993: /* (non-Javadoc)
0994: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireDefaultModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttribute, org.netbeans.modules.uml.core.eventframework.IEventPayload)
0995: */
0996: public void fireDefaultModified(IAttribute attr,
0997: IEventPayload payload) {
0998: if (validateEvent("DefaultModified", attr)) {
0999: IResultCell cell = prepareResultCell(payload);
1000: EventFunctor defaultModified = new EventFunctor(
1001: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
1002: "onDefaultModified");
1003:
1004: Object[] parms = new Object[2];
1005: parms[0] = attr;
1006: parms[1] = cell;
1007: defaultModified.setParameters(parms);
1008:
1009: m_AttrSink.notifyListeners(defaultModified);
1010: }
1011: }
1012:
1013: /**
1014: * Fired whenever the default expression's body property for the attribute
1015: * is about to change.
1016: *
1017: * @param attr[in]
1018: * @param proposedValue
1019: * @param payload[in]
1020: */
1021: public boolean firePreDefaultBodyModified(IAttribute feature,
1022: String bodyValue, IEventPayload payload) {
1023: boolean proceed = true;
1024:
1025: Vector<Object> vect = new Vector<Object>();
1026: vect.add(0, feature);
1027: vect.add(1, bodyValue);
1028: Object var = prepareVariant(vect);
1029:
1030: if (validateEvent("PreDefaultBodyModified", var)) {
1031: IResultCell cell = prepareResultCell(payload);
1032: EventFunctor preDefaultBodyModified = new EventFunctor(
1033: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
1034: "onPreDefaultBodyModified");
1035:
1036: Object[] parms = new Object[2];
1037: parms[0] = var;
1038: parms[1] = cell;
1039: preDefaultBodyModified.setParameters(parms);
1040: m_AttrSink
1041: .notifyListenersWithQualifiedProceed(preDefaultBodyModified);
1042: if (cell != null) {
1043: proceed = cell.canContinue();
1044: }
1045: }
1046: return proceed;
1047: }
1048:
1049: /**
1050: * Fired whenever the default expression's body property for the
1051: * attribue has changed.
1052: *
1053: * @param attr[in]
1054: * @param payload[in]
1055: */
1056: public void fireDefaultBodyModified(IAttribute feature,
1057: IEventPayload payload) {
1058: if (validateEvent("DefaultBodyModified", feature)) {
1059: IResultCell cell = prepareResultCell(payload);
1060: EventFunctor defaultBodyModified = new EventFunctor(
1061: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
1062: "onDefaultBodyModified");
1063:
1064: Object[] parms = new Object[2];
1065: parms[0] = feature;
1066: parms[1] = cell;
1067: defaultBodyModified.setParameters(parms);
1068: m_AttrSink.notifyListeners(defaultBodyModified);
1069: }
1070: }
1071:
1072: /**
1073: * Fired whenever the default expression's language property for the
1074: * attribute is about to change.
1075: *
1076: * @param attr[in]
1077: * @param proposedValue
1078: * @param payload[in]
1079: */
1080: public boolean firePreDefaultLanguageModified(IAttribute feature,
1081: String language, IEventPayload payload) {
1082: boolean proceed = true;
1083:
1084: Vector<Object> vect = new Vector<Object>();
1085: vect.add(0, feature);
1086: vect.add(1, language);
1087: Object var = prepareVariant(vect);
1088:
1089: if (validateEvent("PreDefaultLanguageModified", var)) {
1090: IResultCell cell = prepareResultCell(payload);
1091: EventFunctor preDefaultLanguageModified = new EventFunctor(
1092: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
1093: "onPreDefaultLanguageModified");
1094:
1095: Object[] parms = new Object[2];
1096: parms[0] = var;
1097: parms[1] = cell;
1098: preDefaultLanguageModified.setParameters(parms);
1099: m_AttrSink
1100: .notifyListenersWithQualifiedProceed(preDefaultLanguageModified);
1101: if (cell != null) {
1102: proceed = cell.canContinue();
1103: }
1104: }
1105: return proceed;
1106: }
1107:
1108: /**
1109: * Fired whenever the default expression's language property for the
1110: * attribute has changed.
1111: *
1112: * @param attr[in]
1113: * @param payload[in]
1114: */
1115: public void fireDefaultLanguageModified(IAttribute feature,
1116: IEventPayload payload) {
1117: if (validateEvent("DefaultLanguageModified", feature)) {
1118: IResultCell cell = prepareResultCell(payload);
1119: EventFunctor defaultLanguageModified = new EventFunctor(
1120: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
1121: "onDefaultLanguageModified");
1122:
1123: Object[] parms = new Object[2];
1124: parms[0] = feature;
1125: parms[1] = cell;
1126: defaultLanguageModified.setParameters(parms);
1127: m_AttrSink.notifyListeners(defaultLanguageModified);
1128: }
1129: }
1130:
1131: /**
1132: * Fired whenever the attributes derived property is about to change.
1133: *
1134: * @param attr[in]
1135: * @param proposedValue
1136: * @param payload[in]
1137: */
1138: public boolean firePreDerivedModified(IAttribute feature,
1139: boolean proposedValue, IEventPayload payload) {
1140: boolean proceed = true;
1141:
1142: Vector<Object> vect = new Vector<Object>();
1143: vect.add(0, feature);
1144: vect.add(1, new Boolean(proposedValue));
1145: Object var = prepareVariant(vect);
1146:
1147: if (validateEvent("PreDerivedModified", var)) {
1148: IResultCell cell = prepareResultCell(payload);
1149: EventFunctor m_PreDerivedModified = new EventFunctor(
1150: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
1151: "onPreDerivedModified");
1152:
1153: Object[] parms = new Object[2];
1154: parms[0] = var;
1155: parms[1] = cell;
1156: m_PreDerivedModified.setParameters(parms);
1157: m_AttrSink
1158: .notifyListenersWithQualifiedProceed(m_PreDerivedModified);
1159: if (cell != null) {
1160: proceed = cell.canContinue();
1161: }
1162: }
1163: return proceed;
1164: }
1165:
1166: /* (non-Javadoc)
1167: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireDerivedModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttribute, org.netbeans.modules.uml.core.eventframework.IEventPayload)
1168: */
1169: public void fireDerivedModified(IAttribute feature,
1170: IEventPayload payload) {
1171: if (validateEvent("DerivedModified", feature)) {
1172: IResultCell cell = prepareResultCell(payload);
1173: EventFunctor m_DerivedModified = new EventFunctor(
1174: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
1175: "onDerivedModified");
1176:
1177: Object[] parms = new Object[2];
1178: parms[0] = feature;
1179: parms[1] = cell;
1180: m_DerivedModified.setParameters(parms);
1181: m_AttrSink.notifyListeners(m_DerivedModified);
1182: }
1183: }
1184:
1185: /**
1186: * Fired whenever the attributes primary key is about to change.
1187: *
1188: * @param attr[in]
1189: * @param proposedValue
1190: * @param payload[in]
1191: */
1192: public boolean firePrePrimaryKeyModified(IAttribute feature,
1193: boolean proposedValue, IEventPayload payload) {
1194: boolean proceed = true;
1195:
1196: Vector<Object> vect = new Vector<Object>();
1197: vect.add(0, feature);
1198: vect.add(1, new Boolean(proposedValue));
1199: Object var = prepareVariant(vect);
1200:
1201: if (validateEvent("PrePrimaryKeyModified", var)) {
1202: IResultCell cell = prepareResultCell(payload);
1203: EventFunctor prePrimaryKeyModified = new EventFunctor(
1204: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
1205: "onPrePrimaryKeyModified");
1206:
1207: Object[] parms = new Object[2];
1208: parms[0] = var;
1209: parms[1] = cell;
1210: prePrimaryKeyModified.setParameters(parms);
1211: m_AttrSink
1212: .notifyListenersWithQualifiedProceed(prePrimaryKeyModified);
1213: if (cell != null) {
1214: proceed = cell.canContinue();
1215: }
1216: }
1217: return proceed;
1218: }
1219:
1220: /**
1221: * Fired whenever the attributes primary key has changed.
1222: *
1223: * @param attr[in]
1224: * @param payload[in]
1225: */
1226: public void firePrimaryKeyModified(IAttribute feature,
1227: IEventPayload payload) {
1228: if (validateEvent("PrimaryKeyModified", feature)) {
1229: IResultCell cell = prepareResultCell(payload);
1230: EventFunctor primaryKeyModified = new EventFunctor(
1231: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttributeEventsSink",
1232: "onPrimaryKeyModified");
1233:
1234: Object[] parms = new Object[2];
1235: parms[0] = feature;
1236: parms[1] = cell;
1237: primaryKeyModified.setParameters(parms);
1238: m_AttrSink.notifyListeners(primaryKeyModified);
1239: }
1240: }
1241:
1242: /**
1243: * Fired whenever a pre- or post-condition is about to be added to an operation.
1244: *
1245: * @param oper[in]
1246: * @param condition[in]
1247: * @param isPreCondition
1248: * @param payload[in]
1249: */
1250: public boolean fireConditionPreAdded(IOperation oper,
1251: IConstraint condition, boolean isPreCondition,
1252: IEventPayload payload) {
1253: boolean proceed = true;
1254:
1255: Vector<Object> vect = new Vector<Object>();
1256: vect.add(0, oper);
1257: vect.add(1, condition);
1258: vect.add(2, new Boolean(isPreCondition));
1259: Object var = prepareVariant(vect);
1260:
1261: if (validateEvent("ConditionPreAdded", var)) {
1262: IResultCell cell = prepareResultCell(payload);
1263: EventFunctor conditionPreAdded = new EventFunctor(
1264: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1265: "onConditionPreAdded");
1266:
1267: Object[] parms = new Object[2];
1268: parms[0] = var;
1269: parms[1] = cell;
1270: conditionPreAdded.setParameters(parms);
1271: m_OperSink
1272: .notifyListenersWithQualifiedProceed(conditionPreAdded);
1273: if (cell != null) {
1274: proceed = cell.canContinue();
1275: }
1276: }
1277: return proceed;
1278: }
1279:
1280: /**
1281: * Fired whenever a pre- or post- condition has been added to an operation.
1282: *
1283: * @param oper[in]
1284: * @param condition[in]
1285: * @param isPreCondition[in]
1286: */
1287: public void fireConditionAdded(IOperation oper,
1288: IConstraint condition, boolean isPreCondition,
1289: IEventPayload payload) {
1290: Vector<Object> vect = new Vector<Object>();
1291: vect.add(0, oper);
1292: vect.add(1, condition);
1293: vect.add(2, new Boolean(isPreCondition));
1294: Object var = prepareVariant(vect);
1295:
1296: if (validateEvent("ConditionAdded", var)) {
1297: IResultCell cell = prepareResultCell(payload);
1298: EventFunctor conditionAdded = new EventFunctor(
1299: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1300: "onConditionAdded");
1301:
1302: Object[] parms = new Object[2];
1303: parms[0] = var;
1304: parms[1] = cell;
1305: conditionAdded.setParameters(parms);
1306: m_OperSink.notifyListeners(conditionAdded);
1307: }
1308: }
1309:
1310: /**
1311: * Fired whenever a pre- or post-condition is about to be removed from an
1312: * operation.
1313: *
1314: * @param oper[in]
1315: * @param condition[in]
1316: * @param isPreCondition
1317: * @param payload[in]
1318: */
1319: public boolean fireConditionPreRemoved(IOperation oper,
1320: IConstraint condition, boolean isPreCondition,
1321: IEventPayload payload) {
1322: boolean proceed = true;
1323:
1324: Vector<Object> vect = new Vector<Object>();
1325: vect.add(0, oper);
1326: vect.add(1, condition);
1327: vect.add(2, new Boolean(isPreCondition));
1328: Object var = prepareVariant(vect);
1329:
1330: if (validateEvent("ConditionPreRemoved", var)) {
1331: IResultCell cell = prepareResultCell(payload);
1332: EventFunctor conditionPreRemoved = new EventFunctor(
1333: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1334: "onConditionPreRemoved");
1335:
1336: Object[] parms = new Object[2];
1337: parms[0] = var;
1338: parms[1] = cell;
1339: conditionPreRemoved.setParameters(parms);
1340: m_OperSink
1341: .notifyListenersWithQualifiedProceed(conditionPreRemoved);
1342: if (cell != null) {
1343: proceed = cell.canContinue();
1344: }
1345: }
1346: return proceed;
1347: }
1348:
1349: /**
1350: * Fired whenever a pre- or post-condition is about to be removed from
1351: * an operation.
1352: *
1353: * @param oper[in]
1354: * @param condition[in]
1355: * @param isPreCondition
1356: */
1357: public void fireConditionRemoved(IOperation oper,
1358: IConstraint condition, boolean isPreCondition,
1359: IEventPayload payload) {
1360:
1361: Vector<Object> vect = new Vector<Object>();
1362: vect.add(0, oper);
1363: vect.add(1, condition);
1364: vect.add(2, new Boolean(isPreCondition));
1365: Object var = prepareVariant(vect);
1366:
1367: if (validateEvent("ConditionRemoved", var)) {
1368: IResultCell cell = prepareResultCell(payload);
1369: EventFunctor conditionRemoved = new EventFunctor(
1370: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1371: "onConditionRemoved");
1372:
1373: Object[] parms = new Object[2];
1374: parms[0] = var;
1375: parms[1] = cell;
1376: conditionRemoved.setParameters(parms);
1377: m_OperSink.notifyListeners(conditionRemoved);
1378: }
1379: }
1380:
1381: /**
1382: * Fired whenever the query flag on an operation is about to be modified.
1383: *
1384: * @param oper[in]
1385: * @param proposedValue[in]
1386: * @param payload[in]
1387: */
1388: public boolean firePreQueryModified(IOperation oper,
1389: boolean proposedValue, IEventPayload payload) {
1390: boolean proceed = true;
1391:
1392: Vector<Object> vect = new Vector<Object>();
1393: vect.add(0, oper);
1394: vect.add(1, new Boolean(proposedValue));
1395: Object var = prepareVariant(vect);
1396:
1397: if (validateEvent("PreQueryModified", var)) {
1398: IResultCell cell = prepareResultCell(payload);
1399: EventFunctor preQueryModified = new EventFunctor(
1400: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1401: "onPreQueryModified");
1402:
1403: Object[] parms = new Object[2];
1404: parms[0] = var;
1405: parms[1] = cell;
1406: preQueryModified.setParameters(parms);
1407: m_OperSink
1408: .notifyListenersWithQualifiedProceed(preQueryModified);
1409: if (cell != null) {
1410: proceed = cell.canContinue();
1411: }
1412: }
1413: return proceed;
1414: }
1415:
1416: /**
1417: * Fired whenever the query flag on an operatoin has been modified.
1418: *
1419: * @param oper[in]
1420: * @param payload[in]
1421: */
1422: public void fireQueryModified(IOperation oper, IEventPayload payload) {
1423: if (validateEvent("QueryModified", oper)) {
1424: IResultCell cell = prepareResultCell(payload);
1425: EventFunctor queryModified = new EventFunctor(
1426: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1427: "onQueryModified");
1428:
1429: Object[] parms = new Object[2];
1430: parms[0] = oper;
1431: parms[1] = cell;
1432: queryModified.setParameters(parms);
1433: m_OperSink.notifyListeners(queryModified);
1434: }
1435: }
1436:
1437: /**
1438: * Description
1439: *
1440: * @param oper[in]
1441: * @param pExceptoin[in]
1442: * @param payload[in]
1443: */
1444: public boolean fireRaisedExceptionPreAdded(IOperation oper,
1445: IClassifier pException, IEventPayload payload) {
1446: boolean proceed = true;
1447:
1448: Vector<Object> vect = new Vector<Object>();
1449: vect.add(0, oper);
1450: vect.add(1, pException);
1451: Object var = prepareVariant(vect);
1452:
1453: if (validateEvent("RaisedExceptionPreAdded", var)) {
1454: IResultCell cell = prepareResultCell(payload);
1455: EventFunctor raisedExceptionPreAdded = new EventFunctor(
1456: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1457: "onRaisedExceptionPreAdded");
1458:
1459: Object[] parms = new Object[2];
1460: parms[0] = var;
1461: parms[1] = cell;
1462: raisedExceptionPreAdded.setParameters(parms);
1463: m_OperSink
1464: .notifyListenersWithQualifiedProceed(raisedExceptionPreAdded);
1465: if (cell != null) {
1466: proceed = cell.canContinue();
1467: }
1468: }
1469: return proceed;
1470: }
1471:
1472: /**
1473: * Description.
1474: *
1475: * @param oper[in]
1476: * @param pException[in]
1477: * @param payload[in]
1478: */
1479: public void fireRaisedExceptionAdded(IOperation oper,
1480: IClassifier pException, IEventPayload payload) {
1481: Vector<Object> vect = new Vector<Object>();
1482: vect.add(0, oper);
1483: vect.add(1, pException);
1484: Object var = prepareVariant(vect);
1485:
1486: if (validateEvent("RaisedExceptionAdded", var)) {
1487: IResultCell cell = prepareResultCell(payload);
1488: EventFunctor raisedExceptionAdded = new EventFunctor(
1489: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1490: "onRaisedExceptionAdded");
1491:
1492: Object[] parms = new Object[2];
1493: parms[0] = var;
1494: parms[1] = cell;
1495: raisedExceptionAdded.setParameters(parms);
1496: m_OperSink.notifyListeners(raisedExceptionAdded);
1497: }
1498: }
1499:
1500: /**
1501: * Descriptoin
1502: *
1503: * @param oper[in]
1504: * @param pException[in]
1505: * @param payload[in]
1506: */
1507: public boolean fireRaisedExceptionPreRemoved(IOperation oper,
1508: IClassifier pException, IEventPayload payload) {
1509: boolean proceed = true;
1510:
1511: Vector<Object> vect = new Vector<Object>();
1512: vect.add(0, oper);
1513: vect.add(1, pException);
1514: Object var = prepareVariant(vect);
1515:
1516: if (validateEvent("RaisedExceptionPreRemoved", var)) {
1517: IResultCell cell = prepareResultCell(payload);
1518: EventFunctor raisedExceptionPreRemoved = new EventFunctor(
1519: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1520: "onRaisedExceptionPreRemoved");
1521:
1522: Object[] parms = new Object[2];
1523: parms[0] = var;
1524: parms[1] = cell;
1525: raisedExceptionPreRemoved.setParameters(parms);
1526: m_OperSink
1527: .notifyListenersWithQualifiedProceed(raisedExceptionPreRemoved);
1528: if (cell != null) {
1529: proceed = cell.canContinue();
1530: }
1531: }
1532: return proceed;
1533: }
1534:
1535: /**
1536: * Description
1537: *
1538: * @param oper[in]
1539: * @param pException[in]
1540: */
1541: public void fireRaisedExceptionRemoved(IOperation oper,
1542: IClassifier pException, IEventPayload payload) {
1543: Vector<Object> vect = new Vector<Object>();
1544: vect.add(0, oper);
1545: vect.add(1, pException);
1546: Object var = prepareVariant(vect);
1547:
1548: if (validateEvent("RaisedExceptionRemoved", var)) {
1549: IResultCell cell = prepareResultCell(payload);
1550: EventFunctor raisedExceptionRemoved = new EventFunctor(
1551: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
1552: "onRaisedExceptionRemoved");
1553:
1554: Object[] parms = new Object[2];
1555: parms[0] = var;
1556: parms[1] = cell;
1557: raisedExceptionRemoved.setParameters(parms);
1558: m_OperSink.notifyListeners(raisedExceptionRemoved);
1559: }
1560: }
1561:
1562: /**
1563: *
1564: * Fired whenever the name of a Classifier is about to change
1565: *
1566: * @param classifier[in] The Classifier in question
1567: * @param impacted[in] The collection of elements potentially impacted by the change
1568: * @param payload[in] The event payload
1569: */
1570: public boolean firePreImpacted(IClassifier classifier,
1571: ETList<IVersionableElement> impacted, IEventPayload payload) {
1572: boolean proceed = true;
1573:
1574: Vector<Object> vect = new Vector<Object>();
1575: vect.add(0, classifier);
1576: vect.add(1, impacted);
1577: Object var = prepareVariant(vect);
1578:
1579: if (validateEvent("PreImpacted", var)) {
1580: IResultCell cell = prepareResultCell(payload);
1581: EventFunctor preImpacted = new EventFunctor(
1582: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAffectedElementEventsSink",
1583: "onPreImpacted");
1584:
1585: Object[] params = new Object[2];
1586: params[0] = var;
1587: params[1] = cell;
1588: preImpacted.setParameters(params);
1589: m_AffectedSink
1590: .notifyListenersWithQualifiedProceed(preImpacted);
1591: if (cell != null) {
1592: proceed = cell.canContinue();
1593: }
1594: }
1595: return proceed;
1596: }
1597:
1598: /**
1599: *
1600: * Fired after the Classifier has changed. Most likely due to a name change.
1601: *
1602: * @param classifier[in] The affected Classifier
1603: * @param impacted[in] The collection of impacted elements
1604: * @param payload[in] The payload
1605: */
1606: public void fireImpacted(IClassifier classifier,
1607: ETList<IVersionableElement> impacted, IEventPayload payload) {
1608: Vector<Object> vect = new Vector<Object>();
1609: vect.add(0, classifier);
1610: vect.add(1, impacted);
1611: Object var = prepareVariant(vect);
1612:
1613: if (validateEvent("Impacted", var)) {
1614: IResultCell cell = prepareResultCell(payload);
1615: EventFunctor impactedFunctor = new EventFunctor(
1616: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAffectedElementEventsSink",
1617: "onImpacted");
1618:
1619: Object[] params = new Object[2];
1620: params[0] = var;
1621: params[1] = cell;
1622: impactedFunctor.setParameters(params);
1623: m_AffectedSink.notifyListeners(impactedFunctor);
1624: }
1625: }
1626:
1627: public boolean firePreQualifierAttributeAdded(IAssociationEnd pEnd,
1628: IAttribute pAttr, IEventPayload payload) {
1629: boolean proceed = true;
1630:
1631: Vector<Object> vect = new Vector<Object>();
1632: vect.add(0, pEnd);
1633: vect.add(1, pAttr);
1634: Object var = prepareVariant(vect);
1635:
1636: if (validateEvent("PreQualifierAttributeAdded", var)) {
1637: IResultCell cell = prepareResultCell(payload);
1638: EventFunctor preQualifierAttributeAdded = new EventFunctor(
1639: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEndEventsSink",
1640: "onPreQualifierAttributeAdded");
1641:
1642: Object[] params = new Object[2];
1643: params[0] = var;
1644: params[1] = cell;
1645: preQualifierAttributeAdded.setParameters(params);
1646: m_AssociationEndEventsSink
1647: .notifyListenersWithQualifiedProceed(preQualifierAttributeAdded);
1648: if (cell != null) {
1649: proceed = cell.canContinue();
1650: }
1651: }
1652: return proceed;
1653: }
1654:
1655: public void fireQualifierAttributeAdded(IAssociationEnd pEnd,
1656: IAttribute pAttr, IEventPayload payload) {
1657:
1658: Vector<Object> vect = new Vector<Object>();
1659: vect.add(0, pEnd);
1660: vect.add(1, pAttr);
1661: Object var = prepareVariant(vect);
1662:
1663: if (validateEvent("QualifierAttributeAdded", var)) {
1664: IResultCell cell = prepareResultCell(payload);
1665: EventFunctor qualifierAttributeAdded = new EventFunctor(
1666: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEndEventsSink",
1667: "onQualifierAttributeAdded");
1668:
1669: Object[] params = new Object[2];
1670: params[0] = var;
1671: params[1] = cell;
1672: qualifierAttributeAdded.setParameters(params);
1673: m_AssociationEndEventsSink
1674: .notifyListeners(qualifierAttributeAdded);
1675: }
1676: }
1677:
1678: /* (non-Javadoc)
1679: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#firePreQualifierAttributeRemoved(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEnd, org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttribute, org.netbeans.modules.uml.core.eventframework.IEventPayload)
1680: */
1681: public boolean firePreQualifierAttributeRemoved(
1682: IAssociationEnd pEnd, IAttribute pAttr,
1683: IEventPayload payload) {
1684: boolean proceed = true;
1685:
1686: Vector<Object> vect = new Vector<Object>();
1687: vect.add(0, pEnd);
1688: vect.add(1, pAttr);
1689: Object var = prepareVariant(vect);
1690:
1691: if (validateEvent("PreQualifierAttributeRemoved", var)) {
1692: IResultCell cell = prepareResultCell(payload);
1693: EventFunctor preQualifierAttributeRemoved = new EventFunctor(
1694: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEndEventsSink",
1695: "onPreQualifierAttributeRemoved");
1696:
1697: Object[] params = new Object[2];
1698: params[0] = var;
1699: params[1] = cell;
1700: preQualifierAttributeRemoved.setParameters(params);
1701: m_AssociationEndEventsSink
1702: .notifyListenersWithQualifiedProceed(preQualifierAttributeRemoved);
1703: if (cell != null) {
1704: proceed = cell.canContinue();
1705: }
1706: }
1707: return proceed;
1708: }
1709:
1710: /* (non-Javadoc)
1711: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireQualifierAttributeRemoved(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEnd, org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAttribute, org.netbeans.modules.uml.core.eventframework.IEventPayload)
1712: */
1713: public void fireQualifierAttributeRemoved(IAssociationEnd pEnd,
1714: IAttribute pAttr, IEventPayload payload) {
1715: Vector<Object> vect = new Vector<Object>();
1716: vect.add(0, pEnd);
1717: vect.add(1, pAttr);
1718: Object var = prepareVariant(vect);
1719:
1720: if (validateEvent("QualifierAttributeRemoved", var)) {
1721: IResultCell cell = prepareResultCell(payload);
1722: EventFunctor qualifierAttributeRemoved = new EventFunctor(
1723: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEndEventsSink",
1724: "onQualifierAttributeRemoved");
1725:
1726: Object[] params = new Object[2];
1727: params[0] = var;
1728: params[1] = cell;
1729: qualifierAttributeRemoved.setParameters(params);
1730: m_AssociationEndEventsSink
1731: .notifyListeners(qualifierAttributeRemoved);
1732: }
1733: }
1734:
1735: /**
1736: *
1737: * Registers the passed-in event sink with this dispatcher.
1738: *
1739: * @param handler[in] The actual sink that will receive notifications
1740: */
1741: public void registerForClassifierFeatureEvents(
1742: IClassifierFeatureEventsSink handler) {
1743: m_ClassifierSink.addListener(handler, null);
1744: }
1745:
1746: /**
1747: * Removes a listener from the current list.
1748: *
1749: * @param handler[in]
1750: */
1751: public void revokeClassifierFeatureSink(
1752: IClassifierFeatureEventsSink handler) {
1753: m_ClassifierSink.removeListener(handler);
1754: }
1755:
1756: /**
1757: * Registers the passed-in event sink with this dispatcher.
1758: *
1759: * @param sink[in] The actual sink that will recieve notifications
1760: */
1761: public void registerForFeatureEvents(IFeatureEventsSink handler) {
1762: m_FeatureSink.addListener(handler, null);
1763: }
1764:
1765: /**
1766: * Removes a listener from the current list.
1767: *
1768: * @param handler[in] IFeatureEventsSink.
1769: */
1770: public void revokeFeatureSink(IFeatureEventsSink handler) {
1771: m_FeatureSink.removeListener(handler);
1772: }
1773:
1774: /**
1775: * Registers the passed-in event sink with this dispatcher.
1776: *
1777: * @param sink[in] The actual sink that will receive notifications
1778: */
1779: public void registerForStructuralFeatureEvents(
1780: IStructuralFeatureEventsSink handler) {
1781: m_StructFeatureSink.addListener(handler, null);
1782: }
1783:
1784: /**
1785: * Removes a listener from the current list.
1786: *
1787: * @param handler[in] IStructuralFeatureEventsSink.
1788: */
1789: public void revokeStructuralFeatureSink(
1790: IStructuralFeatureEventsSink handler) {
1791: m_StructFeatureSink.removeListener(handler);
1792: }
1793:
1794: /**
1795: * Registers the passed-in event sink with this dispatcher.
1796: *
1797: * @param sink[in] The actual sink that will recieve notifications
1798: */
1799: public void registerForBehavioralFeatureEvents(
1800: IBehavioralFeatureEventsSink handler) {
1801: m_BehavFeatureSink.addListener(handler, null);
1802: }
1803:
1804: /**
1805: * Removes a listener from the current list.
1806: *
1807: * @param handler[in] IBehavioralFeatureEventsSink.
1808: */
1809: public void revokeBehavioralFeatureSink(
1810: IBehavioralFeatureEventsSink handler) {
1811: m_BehavFeatureSink.removeListener(handler);
1812: }
1813:
1814: /**
1815: * Registers the passed-in event sink with this dispatcher.
1816: *
1817: * @param sink[in] The actual sink that will receive notifications
1818: */
1819: public void registerForParameterEvents(IParameterEventsSink handler) {
1820: m_ParmSink.addListener(handler, null);
1821: }
1822:
1823: /**
1824: * Removes a listener from the current list.
1825: *
1826: * @param handler[in] IParameterEventsSink.
1827: */
1828: public void revokeParameterSink(IParameterEventsSink handler) {
1829: m_ParmSink.removeListener(handler);
1830: }
1831:
1832: /**
1833: * Registers the passed-in event sink with this dispatcher.
1834: *
1835: * @param sink[in] The actual sink that will recieve notifications
1836: */
1837: public void registerForTypedElementEvents(
1838: ITypedElementEventsSink handler) {
1839: m_TypeSink.addListener(handler, null);
1840: }
1841:
1842: /**
1843: * Removes a listener from the current list.
1844: *
1845: * @param handler[in] ITypedElementEventsSink.
1846: */
1847: public void revokeTypedElementSink(ITypedElementEventsSink handler) {
1848: m_TypeSink.removeListener(handler);
1849: }
1850:
1851: /**
1852: * Registers the passed-in event sink with this dispatcher.
1853: *
1854: * @param sink[in] The actual sink that will recieve notifications
1855: */
1856: public void registerForAttributeEvents(IAttributeEventsSink handler) {
1857: m_AttrSink.addListener(handler, null);
1858: }
1859:
1860: /**
1861: * Removes a listener from the current list.
1862: *
1863: * @param handler[in] IAttributeEventsSink.
1864: */
1865: public void revokeAttributeSink(IAttributeEventsSink handler) {
1866: m_AttrSink.removeListener(handler);
1867: }
1868:
1869: /**
1870: * Registers the passed-in event sink with this dispatcher.
1871: *
1872: * @param sink[in] The actual sink that will receive notifications
1873: */
1874: public void registerForOperationEvents(IOperationEventsSink handler) {
1875: m_OperSink.addListener(handler, null);
1876: }
1877:
1878: /**
1879: * Removes a listener from the current list.
1880: *
1881: * @param handler[in] IOperationEventsSink.
1882: */
1883: public void revokeOperationSink(IOperationEventsSink handler) {
1884: m_OperSink.removeListener(handler);
1885: }
1886:
1887: /**
1888: * Registers the passed-in event sink with this dispatcher.
1889: *
1890: * @param sink[in] The actual sink that will recieve notifications
1891: */
1892: public void registerForTransformEvents(
1893: IClassifierTransformEventsSink handler) {
1894: m_TransformSink.addListener(handler, null);
1895: }
1896:
1897: /**
1898: * Removes a listener from the current list.
1899: */
1900: public void revokeTransformSink(
1901: IClassifierTransformEventsSink handler) {
1902: m_TransformSink.removeListener(handler);
1903: }
1904:
1905: /**
1906: * Registers the passed-in event sink with this dispatcher.
1907: *
1908: * @param sink[in] The actual sink that will recieve notifications
1909: */
1910: public void registerForAssociationEndTransformEvents(
1911: IAssociationEndTransformEventsSink handler) {
1912: m_AssociationEndTransformSink.addListener(handler, null);
1913: }
1914:
1915: /**
1916: * Removes a listener from the current list.
1917: * @param handler IAssociationEndTransformEventsSink.
1918: */
1919: public void revokeAssociationEndTransformSink(
1920: IAssociationEndTransformEventsSink handler) {
1921: m_AssociationEndTransformSink.removeListener(handler);
1922: }
1923:
1924: /**
1925: *
1926: * Registers the passed-in event sink with this dispatcher.
1927: *
1928: * @param handler[in] The actual sink that will recieve notifications
1929: */
1930: public void registerForAffectedElementEvents(
1931: IAffectedElementEventsSink handler) {
1932: m_AffectedSink.addListener(handler, null);
1933: }
1934:
1935: /**
1936: *
1937: * Removes a listener from the current list.
1938: * @param handler[in] The actual sink that need to be removed
1939: */
1940: public void revokeAffectedElementEvents(
1941: IAffectedElementEventsSink handler) {
1942: m_AffectedSink.removeListener(handler);
1943: }
1944:
1945: /**
1946: * Registers the passed-in event sink with this dispatcher.
1947: *
1948: * @param sink[in] The actual sink that will receive notifications
1949: */
1950: public void registerForAssociationEndEvents(
1951: IAssociationEndEventsSink handler) {
1952: m_AssociationEndEventsSink.addListener(handler, null);
1953: }
1954:
1955: /**
1956: * Removes a listener from the current list.
1957: *
1958: * @param handler IAssociationEndEventsSink.
1959: */
1960: public void revokeAssociationEndSink(
1961: IAssociationEndEventsSink handler) {
1962: m_AssociationEndEventsSink.removeListener(handler);
1963: }
1964:
1965: /**
1966: * Called whenever a feature is about to be added to a classifier.
1967: *
1968: * @param classifier[in]
1969: * @param feature[in]
1970: * @param payload[in]
1971: *
1972: * @return boolean proceed
1973: */
1974: public boolean fireFeaturePreAdded(IClassifier classifier,
1975: IFeature feature, IEventPayload payload) {
1976: boolean proceed = true;
1977:
1978: Vector<Object> vect = new Vector<Object>();
1979: vect.add(0, classifier);
1980: vect.add(1, feature);
1981: Object var = prepareVariant(vect);
1982:
1983: if (validateEvent("FeaturePreAdded", var)) {
1984: IResultCell cell = prepareResultCell(payload);
1985: EventFunctor featurePreAdded = new EventFunctor(
1986: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
1987: "onFeaturePreAdded");
1988:
1989: Object[] parms = new Object[2];
1990: parms[0] = var;
1991: parms[1] = cell;
1992: featurePreAdded.setParameters(parms);
1993: m_ClassifierSink
1994: .notifyListenersWithQualifiedProceed(featurePreAdded);
1995: if (cell != null) {
1996: proceed = cell.canContinue();
1997: }
1998: }
1999: return proceed;
2000: }
2001:
2002: /**
2003: * Called whenever a feature was added to a classifier.
2004: *
2005: * @param classifier[in]
2006: * @param feature[in]
2007: * @param payload[in]
2008: */
2009: public void fireFeatureAdded(IClassifier classifier,
2010: IFeature feature, IEventPayload payload) {
2011: Vector<Object> vect = new Vector<Object>();
2012: vect.add(0, classifier);
2013: vect.add(1, feature);
2014: Object var = prepareVariant(vect);
2015: if (validateEvent("FeatureAdded", var)) {
2016: IResultCell cell = prepareResultCell(payload);
2017: EventFunctor featureAdded = new EventFunctor(
2018: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2019: "onFeatureAdded");
2020:
2021: Object[] parms = new Object[2];
2022: parms[0] = var;
2023: parms[1] = cell;
2024: featureAdded.setParameters(parms);
2025: m_ClassifierSink.notifyListeners(featureAdded);
2026: }
2027: }
2028:
2029: /* (non-Javadoc)
2030: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireFeaturePreRemoved(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifier, org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IFeature, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2031: */
2032: public boolean fireFeaturePreRemoved(IClassifier classifier,
2033: IFeature feature, IEventPayload payload) {
2034: boolean proceed = true;
2035: Vector<Object> vect = new Vector<Object>();
2036: vect.add(0, classifier);
2037: vect.add(1, feature);
2038: Object var = prepareVariant(vect);
2039: if (validateEvent("FeaturePreRemoved", var)) {
2040: IResultCell cell = prepareResultCell(payload);
2041: EventFunctor featurePreRemoved = new EventFunctor(
2042: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2043: "onFeaturePreRemoved");
2044:
2045: Object[] parms = new Object[2];
2046: parms[0] = var;
2047: parms[1] = cell;
2048: featurePreRemoved.setParameters(parms);
2049: m_ClassifierSink
2050: .notifyListenersWithQualifiedProceed(featurePreRemoved);
2051: if (cell != null) {
2052: proceed = cell.canContinue();
2053: }
2054: }
2055: return proceed;
2056: }
2057:
2058: /* (non-Javadoc)
2059: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireFeatureRemoved(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifier, org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IFeature, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2060: */
2061: public void fireFeatureRemoved(IClassifier classifier,
2062: IFeature feature, IEventPayload payload) {
2063: Vector<Object> vect = new Vector<Object>();
2064: vect.add(0, classifier);
2065: vect.add(1, feature);
2066: Object var = prepareVariant(vect);
2067: if (validateEvent("FeatureRemoved", var)) {
2068: IResultCell cell = prepareResultCell(payload);
2069: EventFunctor featureRemoved = new EventFunctor(
2070: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2071: "onFeatureRemoved");
2072:
2073: Object[] parms = new Object[2];
2074: parms[0] = var;
2075: parms[1] = cell;
2076: featureRemoved.setParameters(parms);
2077: m_ClassifierSink.notifyListeners(featureRemoved);
2078: }
2079: }
2080:
2081: /**
2082: * Called whenever a feature is to be moved to a classifier.
2083: *
2084: * @param classifier[in]
2085: * @param feature[in]
2086: * @param payload[in]
2087: */
2088: public boolean fireFeaturePreMoved(IClassifier classifier,
2089: IFeature feature, IEventPayload payload) {
2090: boolean proceed = true;
2091:
2092: Vector<Object> vect = new Vector<Object>();
2093: vect.add(0, classifier);
2094: vect.add(1, feature);
2095: Object var = prepareVariant(vect);
2096:
2097: if (validateEvent("FeaturePreMoved", var)) {
2098: IResultCell cell = prepareResultCell(payload);
2099: EventFunctor featurePreMoved = new EventFunctor(
2100: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2101: "onFeaturePreMoved");
2102:
2103: Object[] parms = new Object[2];
2104: parms[0] = var;
2105: parms[1] = cell;
2106: featurePreMoved.setParameters(parms);
2107: m_ClassifierSink
2108: .notifyListenersWithQualifiedProceed(featurePreMoved);
2109: if (cell != null) {
2110: proceed = cell.canContinue();
2111: }
2112: }
2113: return proceed;
2114:
2115: }
2116:
2117: /**
2118: * Called whenever a feature is moved to a classifier.
2119: *
2120: * @param classifier[in]
2121: * @param feature[in]
2122: * @param payload[in]
2123: */
2124: public void fireFeatureMoved(IClassifier classifier,
2125: IFeature feature, IEventPayload payload) {
2126: Vector<Object> vect = new Vector<Object>();
2127: vect.add(0, classifier);
2128: vect.add(1, feature);
2129: Object var = prepareVariant(vect);
2130: if (validateEvent("FeatureMoved", var)) {
2131: IResultCell cell = prepareResultCell(payload);
2132: EventFunctor featureMoved = new EventFunctor(
2133: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2134: "onFeatureMoved");
2135:
2136: Object[] parms = new Object[2];
2137: parms[0] = var;
2138: parms[1] = cell;
2139: featureMoved.setParameters(parms);
2140: m_ClassifierSink.notifyListeners(featureMoved);
2141: }
2142: }
2143:
2144: /**
2145: * Description.
2146: *
2147: * @param classifier[in]
2148: * @param feature[in]
2149: * @param payload[in]
2150: */
2151:
2152: public boolean fireFeaturePreDuplicatedToClassifier(
2153: IClassifier classifier, IFeature feature,
2154: IEventPayload payload) {
2155: boolean proceed = true;
2156:
2157: Vector<Object> vect = new Vector<Object>();
2158: vect.add(0, classifier);
2159: vect.add(1, feature);
2160: Object var = prepareVariant(vect);
2161:
2162: if (validateEvent("FeaturePreDuplicatedToClassifier", var)) {
2163: IResultCell cell = prepareResultCell(payload);
2164: EventFunctor featurePreDuplicatedToClassifier = new EventFunctor(
2165: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2166: "onFeaturePreDuplicatedToClassifier");
2167:
2168: Object[] parms = new Object[2];
2169: parms[0] = var;
2170: parms[1] = cell;
2171: featurePreDuplicatedToClassifier.setParameters(parms);
2172: m_ClassifierSink
2173: .notifyListenersWithQualifiedProceed(featurePreDuplicatedToClassifier);
2174: if (cell != null) {
2175: proceed = cell.canContinue();
2176: }
2177: }
2178: return proceed;
2179: }
2180:
2181: /**
2182: * Description.
2183: *
2184: * @param pOldClassifier[in]
2185: * @param pOldFeature[in]
2186: * @param pNewClassifier[in]
2187: * @param pnewFeature[in]
2188: */
2189:
2190: public boolean fireFeatureDuplicatedToClassifier(
2191: IClassifier pOldClassifier, IFeature pOldFeature,
2192: IClassifier pNewClassifier, IFeature pNewFeature,
2193: IEventPayload payload) {
2194: Vector<Object> vect = new Vector<Object>();
2195: vect.add(0, pOldClassifier);
2196: vect.add(1, pOldFeature);
2197: vect.add(2, pNewClassifier);
2198: vect.add(3, pNewFeature);
2199: Object var = prepareVariant(vect);
2200: if (validateEvent("FeatureDuplicatedToClassifier", var)) {
2201: IResultCell cell = prepareResultCell(payload);
2202: EventFunctor featureDuplicatedToClassifier = new EventFunctor(
2203: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2204: "onFeatureDuplicatedToClassifier");
2205:
2206: Object[] parms = new Object[2];
2207: parms[0] = var;
2208: parms[1] = cell;
2209: featureDuplicatedToClassifier.setParameters(parms);
2210: m_ClassifierSink
2211: .notifyListeners(featureDuplicatedToClassifier);
2212: }
2213: return true;
2214: }
2215:
2216: /**
2217: * Called whenever the abstract flag on the Classifier is about to be modified.
2218: *
2219: * @param feature[in]
2220: * @param proposedValue[in]
2221: * @param payload[in]
2222: */
2223: public boolean fireClassifierPreAbstractModified(
2224: IClassifier feature, boolean proposedValue,
2225: IEventPayload payload) {
2226: boolean proceed = true;
2227:
2228: Vector<Object> vect = new Vector<Object>();
2229: vect.add(0, feature);
2230: vect.add(1, new Boolean(proposedValue));
2231: Object var = prepareVariant(vect);
2232:
2233: if (validateEvent("PreAbstractModified", var)) {
2234: IResultCell cell = prepareResultCell(payload);
2235: EventFunctor classifierFeaturePreAbstractModified = new EventFunctor(
2236: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2237: "onPreAbstractModified");
2238:
2239: Object[] parms = new Object[2];
2240: parms[0] = var;
2241: parms[1] = cell;
2242: classifierFeaturePreAbstractModified.setParameters(parms);
2243: m_ClassifierSink
2244: .notifyListenersWithQualifiedProceed(classifierFeaturePreAbstractModified);
2245: if (cell != null) {
2246: proceed = cell.canContinue();
2247: }
2248: }
2249: return proceed;
2250: }
2251:
2252: /**
2253: * Called whenever the abstract flag on the Classifier has been modified..
2254: *
2255: * @param feature[in]
2256: * @param payload[in]
2257: */
2258: public void fireClassifierAbstractModified(IClassifier feature,
2259: IEventPayload payload) {
2260: if (validateEvent("AbstractModified", feature)) {
2261: IResultCell cell = prepareResultCell(payload);
2262: EventFunctor classifierFeatureAbstractModified = new EventFunctor(
2263: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2264: "onAbstractModified");
2265:
2266: Object[] params = new Object[2];
2267: params[0] = feature;
2268: params[1] = cell;
2269: classifierFeatureAbstractModified.setParameters(params);
2270: m_ClassifierSink
2271: .notifyListeners(classifierFeatureAbstractModified);
2272: }
2273: }
2274:
2275: /**
2276: * Called whenever the leaf flag on the Classifier is about to be modified.
2277: *
2278: * @param feature[in]
2279: * @param proposedValue[in]
2280: * @param payload[in]
2281: */
2282:
2283: public boolean firePreLeafModified(IClassifier feature,
2284: boolean proposedValue, IEventPayload payload) {
2285: boolean proceed = true;
2286:
2287: Vector<Object> vect = new Vector<Object>();
2288: vect.add(0, feature);
2289: vect.add(1, new Boolean(proposedValue));
2290: Object var = prepareVariant(vect);
2291:
2292: if (validateEvent("PreLeafModified", var)) {
2293: IResultCell cell = prepareResultCell(payload);
2294: EventFunctor preLeafModified = new EventFunctor(
2295: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2296: "onPreLeafModified");
2297:
2298: Object[] parms = new Object[2];
2299: parms[0] = var;
2300: parms[1] = cell;
2301: preLeafModified.setParameters(parms);
2302: m_ClassifierSink
2303: .notifyListenersWithQualifiedProceed(preLeafModified);
2304: if (cell != null) {
2305: proceed = cell.canContinue();
2306: }
2307: }
2308: return proceed;
2309: }
2310:
2311: /* (non-Javadoc)
2312: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireLeafModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifier, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2313: */
2314: public void fireLeafModified(IClassifier feature,
2315: IEventPayload payload) {
2316: if (validateEvent("LeafModified", feature)) {
2317: IResultCell cell = prepareResultCell(payload);
2318: EventFunctor leafModified = new EventFunctor(
2319: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2320: "onLeafModified");
2321:
2322: Object[] parms = new Object[2];
2323: parms[0] = feature;
2324: parms[1] = cell;
2325: leafModified.setParameters(parms);
2326: m_ClassifierSink.notifyListeners(leafModified);
2327: }
2328: }
2329:
2330: /**
2331: * Called whenever the transient flag on the Classifier is about to be modified.
2332: *
2333: * @param feature[in]
2334: * @param proposedValue[in]
2335: * @param payload[in]
2336: */
2337: public boolean fireClassifierPreTransientModified(
2338: IClassifier feature, boolean proposedValue,
2339: IEventPayload payload) {
2340: boolean proceed = true;
2341:
2342: Vector<Object> vect = new Vector<Object>();
2343: vect.add(0, feature);
2344: vect.add(1, new Boolean(proposedValue));
2345: Object var = prepareVariant(vect);
2346:
2347: if (validateEvent("PreTransientModified", var)) {
2348: IResultCell cell = prepareResultCell(payload);
2349: EventFunctor classifierPreTransientModified = new EventFunctor(
2350: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2351: "onPreTransientModified");
2352:
2353: Object[] parms = new Object[2];
2354: parms[0] = var;
2355: parms[1] = cell;
2356: classifierPreTransientModified.setParameters(parms);
2357: m_ClassifierSink
2358: .notifyListenersWithQualifiedProceed(classifierPreTransientModified);
2359: if (cell != null) {
2360: proceed = cell.canContinue();
2361: }
2362: }
2363: return proceed;
2364: }
2365:
2366: /* (non-Javadoc)
2367: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireClassifierTransientModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifier, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2368: */
2369: public void fireClassifierTransientModified(IClassifier feature,
2370: IEventPayload payload) {
2371: if (validateEvent("TransientModified", feature)) {
2372: IResultCell cell = prepareResultCell(payload);
2373: EventFunctor classifierTransientModified = new EventFunctor(
2374: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2375: "onTransientModified");
2376:
2377: Object[] parms = new Object[2];
2378: parms[0] = feature;
2379: parms[1] = cell;
2380: classifierTransientModified.setParameters(parms);
2381: m_ClassifierSink
2382: .notifyListeners(classifierTransientModified);
2383: }
2384: }
2385:
2386: public boolean firePreTemplateParameterAdded(
2387: IClassifier pClassifier, IParameterableElement pParam,
2388: IEventPayload payload) {
2389: boolean proceed = true;
2390:
2391: Vector<Object> vect = new Vector<Object>();
2392: vect.add(0, pClassifier);
2393: vect.add(1, pParam);
2394: Object var = prepareVariant(vect);
2395:
2396: if (validateEvent("PreTemplateParameterAdded", var)) {
2397: IResultCell cell = prepareResultCell(payload);
2398: EventFunctor preTemplateParameterAdded = new EventFunctor(
2399: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2400: "onPreTemplateParameterAdded");
2401:
2402: Object[] parms = new Object[2];
2403: parms[0] = var;
2404: parms[1] = cell;
2405: preTemplateParameterAdded.setParameters(parms);
2406: m_ClassifierSink
2407: .notifyListenersWithQualifiedProceed(preTemplateParameterAdded);
2408: if (cell != null) {
2409: proceed = cell.canContinue();
2410: }
2411: }
2412: return proceed;
2413: }
2414:
2415: public void fireTemplateParameterAdded(IClassifier pClassifier,
2416: IParameterableElement pParam, IEventPayload payload) {
2417: Vector<Object> vect = new Vector<Object>();
2418: vect.add(0, pClassifier);
2419: vect.add(1, pParam);
2420: Object var = prepareVariant(vect);
2421:
2422: if (validateEvent("TemplateParameterAdded", var)) {
2423: IResultCell cell = prepareResultCell(payload);
2424: EventFunctor templateParameterAdded = new EventFunctor(
2425: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2426: "onTemplateParameterAdded");
2427:
2428: Object[] parms = new Object[2];
2429: parms[0] = var;
2430: parms[1] = cell;
2431: templateParameterAdded.setParameters(parms);
2432: m_ClassifierSink.notifyListeners(templateParameterAdded);
2433: }
2434: }
2435:
2436: /* (non-Javadoc)
2437: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#firePreTemplateParameterRemoved(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifier, org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterableElement, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2438: */
2439: public boolean firePreTemplateParameterRemoved(
2440: IClassifier pClassifier, IParameterableElement pParam,
2441: IEventPayload payload) {
2442: boolean proceed = true;
2443:
2444: Vector<Object> vect = new Vector<Object>();
2445: vect.add(0, pClassifier);
2446: vect.add(1, pParam);
2447: Object var = prepareVariant(vect);
2448:
2449: if (validateEvent("PreTemplateParameterRemoved", var)) {
2450: IResultCell cell = prepareResultCell(payload);
2451: EventFunctor preTemplateParameterRemoved = new EventFunctor(
2452: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2453: "onPreTemplateParameterRemoved");
2454:
2455: Object[] parms = new Object[2];
2456: parms[0] = var;
2457: parms[1] = cell;
2458: preTemplateParameterRemoved.setParameters(parms);
2459: m_ClassifierSink
2460: .notifyListenersWithQualifiedProceed(preTemplateParameterRemoved);
2461: if (cell != null) {
2462: proceed = cell.canContinue();
2463: }
2464: }
2465: return proceed;
2466: }
2467:
2468: /* (non-Javadoc)
2469: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireTemplateParameterRemoved(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifier, org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IParameterableElement, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2470: */
2471: public void fireTemplateParameterRemoved(IClassifier pClassifier,
2472: IParameterableElement pParam, IEventPayload payload) {
2473: Vector<Object> vect = new Vector<Object>();
2474: vect.add(0, pClassifier);
2475: vect.add(1, pParam);
2476: Object var = prepareVariant(vect);
2477:
2478: if (validateEvent("TemplateParameterRemoved", var)) {
2479: IResultCell cell = prepareResultCell(payload);
2480: EventFunctor templateParameterRemoved = new EventFunctor(
2481: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
2482: "onTemplateParameterRemoved");
2483:
2484: Object[] parms = new Object[2];
2485: parms[0] = var;
2486: parms[1] = cell;
2487: templateParameterRemoved.setParameters(parms);
2488: m_ClassifierSink.notifyListeners(templateParameterRemoved);
2489: }
2490: }
2491:
2492: /* (non-Javadoc)
2493: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#firePreTransform(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifier, java.lang.String, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2494: */
2495: public boolean firePreTransform(IClassifier classifier,
2496: String newForm, IEventPayload payload) {
2497: boolean proceed = true;
2498:
2499: Vector<Object> vect = new Vector<Object>();
2500: vect.add(0, classifier);
2501: vect.add(1, newForm);
2502: Object var = prepareVariant(vect);
2503:
2504: if (validateEvent("PreTransform", var)) {
2505: IResultCell cell = prepareResultCell(payload);
2506: EventFunctor preTransform = new EventFunctor(
2507: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierTransformEventsSink",
2508: "onPreTransform");
2509:
2510: Object[] parms = new Object[3];
2511: parms[0] = classifier;
2512: parms[1] = newForm;
2513: parms[2] = cell;
2514: preTransform.setParameters(parms);
2515: m_TransformSink
2516: .notifyListenersWithQualifiedProceed(preTransform);
2517: if (cell != null) {
2518: proceed = cell.canContinue();
2519: }
2520: }
2521: return proceed;
2522: }
2523:
2524: /* (non-Javadoc)
2525: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireTransformed(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifier, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2526: */
2527: public void fireTransformed(IClassifier classifier,
2528: IEventPayload payload) {
2529: if (validateEvent("Transformed", classifier)) {
2530: IResultCell cell = prepareResultCell(payload);
2531: EventFunctor transformed = new EventFunctor(
2532: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierTransformEventsSink",
2533: "onTransformed");
2534:
2535: Object[] parms = new Object[2];
2536: parms[0] = classifier;
2537: parms[1] = cell;
2538: transformed.setParameters(parms);
2539: m_TransformSink.notifyListeners(transformed);
2540: }
2541:
2542: }
2543:
2544: /* (non-Javadoc)
2545: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#firePreAssociationEndTransform(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEnd, java.lang.String, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2546: */
2547: public boolean firePreAssociationEndTransform(IAssociationEnd pEnd,
2548: String newForm, IEventPayload payload) {
2549: boolean proceed = true;
2550:
2551: Vector<Object> vect = new Vector<Object>();
2552: vect.add(0, pEnd);
2553: vect.add(1, newForm);
2554: Object var = prepareVariant(vect);
2555:
2556: if (validateEvent("PreTransform", var)) {
2557: IResultCell cell = prepareResultCell(payload);
2558: EventFunctor preAssociationEndTransform = new EventFunctor(
2559: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEndTransformEventsSink",
2560: "onPreTransform");
2561:
2562: Object[] parms = new Object[2];
2563: parms[0] = var;
2564: parms[1] = cell;
2565: preAssociationEndTransform.setParameters(parms);
2566: m_AssociationEndTransformSink
2567: .notifyListenersWithQualifiedProceed(preAssociationEndTransform);
2568: if (cell != null) {
2569: proceed = cell.canContinue();
2570: }
2571: }
2572: return proceed;
2573: }
2574:
2575: /* (non-Javadoc)
2576: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireAssociationEndTransformed(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEnd, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2577: */
2578: public void fireAssociationEndTransformed(IAssociationEnd pEnd,
2579: IEventPayload payload) {
2580: if (validateEvent("Transformed", pEnd)) {
2581: IResultCell cell = prepareResultCell(payload);
2582: EventFunctor associationEndTransformed = new EventFunctor(
2583: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IAssociationEndTransformEventsSink",
2584: "onTransformed");
2585:
2586: Object[] parms = new Object[2];
2587: parms[0] = pEnd;
2588: parms[1] = cell;
2589: associationEndTransformed.setParameters(parms);
2590: m_AssociationEndTransformSink
2591: .notifyListeners(associationEndTransformed);
2592: }
2593: }
2594:
2595: /**
2596: * Fired whenever the static flag on a particular feature is about
2597: * to be modified.
2598: *
2599: * @param feature[in]
2600: * @param proposedValue[in]
2601: * @param payload[in]
2602: */
2603: public boolean firePreStaticModified(IFeature feature,
2604: boolean proposedValue, IEventPayload payload) {
2605: boolean proceed = true;
2606:
2607: Vector<Object> vect = new Vector<Object>();
2608: vect.add(0, feature);
2609: vect.add(1, new Boolean(proposedValue));
2610: Object var = prepareVariant(vect);
2611:
2612: if (validateEvent("PreStaticModified", var)) {
2613: IResultCell cell = prepareResultCell(payload);
2614: EventFunctor preStaticModified = new EventFunctor(
2615: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IFeatureEventsSink",
2616: "onPreStaticModified");
2617:
2618: Object[] parms = new Object[2];
2619: parms[0] = var;
2620: parms[1] = cell;
2621: preStaticModified.setParameters(parms);
2622: m_FeatureSink
2623: .notifyListenersWithQualifiedProceed(preStaticModified);
2624: if (cell != null) {
2625: proceed = cell.canContinue();
2626: }
2627: }
2628: return proceed;
2629: }
2630:
2631: /**
2632: * Fired whenever the static flag on a particular feature
2633: * was just modified.
2634: *
2635: * @param feature[in]
2636: * @param payload[in]
2637: */
2638: public void fireStaticModified(IFeature feature,
2639: IEventPayload payload) {
2640: if (validateEvent("StaticModified", feature)) {
2641: IResultCell cell = prepareResultCell(payload);
2642: EventFunctor staticModified = new EventFunctor(
2643: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IFeatureEventsSink",
2644: "onStaticModified");
2645:
2646: Object[] params = new Object[2];
2647: params[0] = feature;
2648: params[1] = cell;
2649: staticModified.setParameters(params);
2650: m_FeatureSink.notifyListeners(staticModified);
2651: }
2652: }
2653:
2654: /**
2655: * Fired whenever the native flag on a particular feature is
2656: * about to be modified.
2657: *
2658: * @param feature[in]
2659: * @param proposedValue[in]
2660: * @param payload[in]
2661: */
2662: public boolean firePreNativeModified(IFeature feature,
2663: boolean proposedValue, IEventPayload payload) {
2664: boolean proceed = true;
2665:
2666: Vector<Object> vect = new Vector<Object>();
2667: vect.add(0, feature);
2668: vect.add(1, new Boolean(proposedValue));
2669: Object var = prepareVariant(vect);
2670:
2671: if (validateEvent("PreNativeModified", var)) {
2672: IResultCell cell = prepareResultCell(payload);
2673: EventFunctor preNativeModified = new EventFunctor(
2674: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IFeatureEventsSink",
2675: "onPreNativeModified");
2676:
2677: Object[] parms = new Object[2];
2678: parms[0] = var;
2679: parms[1] = cell;
2680: preNativeModified.setParameters(parms);
2681: m_FeatureSink
2682: .notifyListenersWithQualifiedProceed(preNativeModified);
2683: if (cell != null) {
2684: proceed = cell.canContinue();
2685: }
2686: }
2687: return proceed;
2688: }
2689:
2690: /* (non-Javadoc)
2691: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireNativeModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IFeature, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2692: */
2693: public void fireNativeModified(IFeature feature,
2694: IEventPayload payload) {
2695: if (validateEvent("NativeModified", feature)) {
2696: IResultCell cell = prepareResultCell(payload);
2697: EventFunctor nativeModified = new EventFunctor(
2698: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IFeatureEventsSink",
2699: "onNativeModified");
2700:
2701: Object[] params = new Object[2];
2702: params[0] = feature;
2703: params[1] = cell;
2704: nativeModified.setParameters(params);
2705: m_FeatureSink.notifyListeners(nativeModified);
2706: }
2707: }
2708:
2709: /**
2710: * Fired whenever the ClientChangeability flag on a particular feature
2711: * is about to be modified.
2712: *
2713: * @param feature[in]
2714: * @param proposedValue[in]
2715: * @param payload[in]
2716: */
2717: public boolean firePreChangeabilityModified(
2718: IStructuralFeature feature, int proposedValue,
2719: IEventPayload payload) {
2720: boolean proceed = true;
2721:
2722: Vector<Object> vect = new Vector<Object>();
2723: vect.add(0, feature);
2724: vect.add(1, new Integer(proposedValue));
2725: Object var = prepareVariant(vect);
2726:
2727: if (validateEvent("PreChangeabilityModified", var)) {
2728: IResultCell cell = prepareResultCell(payload);
2729: EventFunctor preChangeabilityModified = new EventFunctor(
2730: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IStructuralFeatureEventsSink",
2731: "onPreChangeabilityModified");
2732:
2733: Object[] parms = new Object[2];
2734: parms[0] = var;
2735: parms[1] = cell;
2736: preChangeabilityModified.setParameters(parms);
2737: m_StructFeatureSink
2738: .notifyListenersWithQualifiedProceed(preChangeabilityModified);
2739: if (cell != null) {
2740: proceed = cell.canContinue();
2741: }
2742: }
2743: return proceed;
2744: }
2745:
2746: /* (non-Javadoc)
2747: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireChangeabilityModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IStructuralFeature, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2748: */
2749: public void fireChangeabilityModified(IStructuralFeature feature,
2750: IEventPayload payload) {
2751: if (validateEvent("ChangeabilityModified", feature)) {
2752: IResultCell cell = prepareResultCell(payload);
2753: EventFunctor changeabilityModified = new EventFunctor(
2754: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IStructuralFeatureEventsSink",
2755: "onChangeabilityModified");
2756:
2757: Object[] params = new Object[2];
2758: params[0] = feature;
2759: params[1] = cell;
2760: changeabilityModified.setParameters(params);
2761: m_StructFeatureSink.notifyListeners(changeabilityModified);
2762: }
2763: }
2764:
2765: /**
2766: * Fired whenever the volatile flag on a particular feature is about
2767: * to be modified.
2768: *
2769: * @param feature[in]
2770: * @param proposedValue[in]
2771: * @param payload[in]
2772: */
2773: public boolean firePreVolatileModified(IStructuralFeature feature,
2774: boolean proposedValue, IEventPayload payload) {
2775: boolean proceed = true;
2776:
2777: Vector<Object> vect = new Vector<Object>();
2778: vect.add(0, feature);
2779: vect.add(1, new Boolean(proposedValue));
2780: Object var = prepareVariant(vect);
2781:
2782: if (validateEvent("PreVolatileModified", var)) {
2783: IResultCell cell = prepareResultCell(payload);
2784: EventFunctor preVolatileModified = new EventFunctor(
2785: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IStructuralFeatureEventsSink",
2786: "onPreVolatileModified");
2787:
2788: Object[] parms = new Object[2];
2789: parms[0] = var;
2790: parms[1] = cell;
2791: preVolatileModified.setParameters(parms);
2792: m_StructFeatureSink
2793: .notifyListenersWithQualifiedProceed(preVolatileModified);
2794: if (cell != null) {
2795: proceed = cell.canContinue();
2796: }
2797: }
2798: return proceed;
2799: }
2800:
2801: /* (non-Javadoc)
2802: * @see org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierEventDispatcher#fireVolatileModified(org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IStructuralFeature, org.netbeans.modules.uml.core.eventframework.IEventPayload)
2803: */
2804: public void fireVolatileModified(IStructuralFeature feature,
2805: IEventPayload payload) {
2806: if (validateEvent("VolatileModified", feature)) {
2807: IResultCell cell = prepareResultCell(payload);
2808: EventFunctor volatileModified = new EventFunctor(
2809: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IStructuralFeatureEventsSink",
2810: "onVolatileModified");
2811:
2812: Object[] params = new Object[2];
2813: params[0] = feature;
2814: params[1] = cell;
2815: volatileModified.setParameters(params);
2816: m_StructFeatureSink.notifyListeners(volatileModified);
2817: }
2818: }
2819:
2820: /**
2821: * Fired whenever the transient flag on a particular feature is about to be modified.
2822: *
2823: * @param feature[in]
2824: * @param proposedValue[in]
2825: * @param payload[in]
2826: */
2827: public boolean firePreTransientModified(IStructuralFeature feature,
2828: boolean proposedValue, IEventPayload payload) {
2829: boolean proceed = true;
2830:
2831: Vector<Object> vect = new Vector<Object>();
2832: vect.add(0, feature);
2833: vect.add(1, new Boolean(proposedValue));
2834: Object var = prepareVariant(vect);
2835:
2836: if (validateEvent("PreTransientModified", var)) {
2837: IResultCell cell = prepareResultCell(payload);
2838: EventFunctor preTransientModified = new EventFunctor(
2839: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IStructuralFeatureEventsSink",
2840: "onPreTransientModified");
2841:
2842: Object[] parms = new Object[2];
2843: parms[0] = var;
2844: parms[1] = cell;
2845: preTransientModified.setParameters(parms);
2846: m_StructFeatureSink
2847: .notifyListenersWithQualifiedProceed(preTransientModified);
2848: if (cell != null) {
2849: proceed = cell.canContinue();
2850: }
2851: }
2852: return proceed;
2853: }
2854:
2855: /**
2856: * Fired whenever the transient flag on a particular feature has been modified.
2857: *
2858: * @param feature[in]
2859: * @param payload[in]
2860: */
2861: public void fireTransientModified(IStructuralFeature feature,
2862: IEventPayload payload) {
2863: if (validateEvent("TransientModified", feature)) {
2864: IResultCell cell = prepareResultCell(payload);
2865: EventFunctor transientModified = new EventFunctor(
2866: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IStructuralFeatureEventsSink",
2867: "onTransientModified");
2868:
2869: Object[] params = new Object[2];
2870: params[0] = feature;
2871: params[1] = cell;
2872: transientModified.setParameters(params);
2873: m_StructFeatureSink.notifyListeners(transientModified);
2874: }
2875: }
2876:
2877: /**
2878: * Fired whenever the concurrency value of a behavior feature is about to
2879: * be modified
2880: *
2881: * @param feature[in]
2882: * @param proposedValue[in]
2883: * @param payload[in]
2884: */
2885: public boolean fireConcurrencyPreModified(
2886: IBehavioralFeature feature, int proposedValue,
2887: IEventPayload payload) {
2888: boolean proceed = true;
2889:
2890: Vector<Object> vect = new Vector<Object>();
2891: vect.add(0, feature);
2892: vect.add(1, new Integer(proposedValue));
2893: Object var = prepareVariant(vect);
2894:
2895: if (validateEvent("ConcurrencyPreModified", var)) {
2896: IResultCell cell = prepareResultCell(payload);
2897: EventFunctor concurrencyPreModified = new EventFunctor(
2898: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
2899: "onConcurrencyPreModified");
2900:
2901: Object[] params = new Object[2];
2902: params[0] = var;
2903: params[1] = cell;
2904: concurrencyPreModified.setParameters(params);
2905: m_BehavFeatureSink
2906: .notifyListenersWithQualifiedProceed(concurrencyPreModified);
2907: if (cell != null) {
2908: proceed = cell.canContinue();
2909: }
2910: }
2911: return proceed;
2912: }
2913:
2914: /**
2915: * Fired whenever the concurrency value of a behavioral feature was modified
2916: *
2917: * @param feature[in]
2918: * @param payload[in]
2919: */
2920: public void fireConcurrencyModified(IBehavioralFeature feature,
2921: IEventPayload payload) {
2922: if (validateEvent("ConcurrencyModified", feature)) {
2923: IResultCell cell = prepareResultCell(payload);
2924: EventFunctor concurrencyModified = new EventFunctor(
2925: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
2926: "onConcurrencyModified");
2927:
2928: Object[] parms = new Object[2];
2929: parms[0] = feature;
2930: parms[1] = cell;
2931: concurrencyModified.setParameters(parms);
2932: m_BehavFeatureSink.notifyListeners(concurrencyModified);
2933: }
2934: }
2935:
2936: /**
2937: * Fired whenever a signal is about to be added to the behavioral feature,
2938: * indicating that the feature can 'catch' the specified signal.
2939: *
2940: * @param feature[in]
2941: * @param proposedValue[in]
2942: * @param payload[in]
2943: */
2944: public boolean firePreHandledSignalAdded(
2945: IBehavioralFeature feature, ISignal proposedValue,
2946: IEventPayload payload) {
2947: boolean proceed = true;
2948:
2949: Vector<Object> vect = new Vector<Object>();
2950: vect.add(0, feature);
2951: vect.add(1, proposedValue);
2952: Object var = prepareVariant(vect);
2953:
2954: if (validateEvent("PreHandledSignalAdded", var)) {
2955: IResultCell cell = prepareResultCell(payload);
2956: EventFunctor preHandledSignalAdded = new EventFunctor(
2957: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
2958: "onPreHandledSignalAdded");
2959:
2960: Object[] parms = new Object[2];
2961: parms[0] = var;
2962: parms[1] = cell;
2963: preHandledSignalAdded.setParameters(parms);
2964: m_BehavFeatureSink
2965: .notifyListenersWithQualifiedProceed(preHandledSignalAdded);
2966: if (cell != null) {
2967: proceed = cell.canContinue();
2968: }
2969: }
2970: return proceed;
2971: }
2972:
2973: /**
2974: * Fired whenever a signal is added to the behavioral feature, indicating that the
2975: * feature can 'catch' the specified signal.
2976: *
2977: * @param feature[in]
2978: * @param payload[in]
2979: */
2980: public void fireHandledSignalAdded(IBehavioralFeature feature,
2981: IEventPayload payload) {
2982: if (validateEvent("HandledSignalAdded", feature)) {
2983: IResultCell cell = prepareResultCell(payload);
2984: EventFunctor handledSignalAdded = new EventFunctor(
2985: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
2986: "onHandledSignalAdded");
2987:
2988: Object[] parms = new Object[2];
2989: parms[0] = feature;
2990: parms[1] = cell;
2991: handledSignalAdded.setParameters(parms);
2992: m_BehavFeatureSink.notifyListeners(handledSignalAdded);
2993: }
2994: }
2995:
2996: /**
2997: * Fired whenever a signal is about to be removed from the behavioral
2998: * feature, indicating that the feature can no longer 'catch' the
2999: * specified signal.
3000: *
3001: * @param feature[in]
3002: * @param proposedValue[in]
3003: * @param payload[in]
3004: */
3005: public boolean firePreHandledSignalRemoved(
3006: IBehavioralFeature feature, ISignal proposedValue,
3007: IEventPayload payload) {
3008: boolean proceed = true;
3009:
3010: Vector<Object> vect = new Vector<Object>();
3011: vect.add(0, feature);
3012: vect.add(1, proposedValue);
3013: Object var = prepareVariant(vect);
3014:
3015: if (validateEvent("PreHandledSignalRemoved", var)) {
3016: IResultCell cell = prepareResultCell(payload);
3017: EventFunctor preHandledSignalRemoved = new EventFunctor(
3018: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
3019: "onPreHandledSignalRemoved");
3020:
3021: Object[] parms = new Object[2];
3022: parms[0] = var;
3023: parms[1] = cell;
3024: preHandledSignalRemoved.setParameters(parms);
3025: m_BehavFeatureSink
3026: .notifyListenersWithQualifiedProceed(preHandledSignalRemoved);
3027: if (cell != null) {
3028: proceed = cell.canContinue();
3029: }
3030: }
3031: return proceed;
3032: }
3033:
3034: /**
3035: * Fired whenever a signal was removed from the behavioral feature, indicating
3036: * that the feature can no longer 'catch' the specified signal.
3037: *
3038: * @param feature[in]
3039: * @param payload[in]
3040: */
3041: public void fireHandledSignalRemoved(IBehavioralFeature feature,
3042: IEventPayload payload) {
3043: if (validateEvent("HandledSignalRemoved", feature)) {
3044: IResultCell cell = prepareResultCell(payload);
3045: EventFunctor handledSignalRemoved = new EventFunctor(
3046: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
3047: "onHandledSignalRemoved");
3048:
3049: Object[] parms = new Object[2];
3050: parms[0] = feature;
3051: parms[1] = cell;
3052: handledSignalRemoved.setParameters(parms);
3053: m_BehavFeatureSink.notifyListeners(handledSignalRemoved);
3054: }
3055:
3056: }
3057:
3058: /**
3059: * Fired whenever a new parameter is about to be added to the behavioral
3060: * feature's list of parameters.
3061: *
3062: * @param feature[in]
3063: * @param parm[in]
3064: * @param payload[in]
3065: */
3066: public boolean firePreParameterAdded(IBehavioralFeature feature,
3067: IParameter parm, IEventPayload payload) {
3068: boolean proceed = true;
3069:
3070: Vector<Object> vect = new Vector<Object>();
3071: vect.add(0, feature);
3072: vect.add(1, parm);
3073: Object var = prepareVariant(vect);
3074:
3075: if (validateEvent("PreParameterAdded", var)) {
3076: IResultCell cell = prepareResultCell(payload);
3077: EventFunctor preParameterAdded = new EventFunctor(
3078: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
3079: "onPreParameterAdded");
3080:
3081: Object[] parms = new Object[2];
3082: parms[0] = var;
3083: parms[1] = cell;
3084: preParameterAdded.setParameters(parms);
3085: m_BehavFeatureSink
3086: .notifyListenersWithQualifiedProceed(preParameterAdded);
3087: if (cell != null) {
3088: proceed = cell.canContinue();
3089: }
3090: }
3091: return proceed;
3092: }
3093:
3094: /**
3095: * Fired whenever a new parameter was added to the behavioral feature's
3096: * list of parameters.
3097: *
3098: * @param feature[in]
3099: * @param parm[in]
3100: */
3101: public void fireParameterAdded(IBehavioralFeature feature,
3102: IParameter parm, IEventPayload payload) {
3103: if (validateEvent("ParameterAdded", feature)) {
3104: IResultCell cell = prepareResultCell(payload);
3105: EventFunctor parameterAdded = new EventFunctor(
3106: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IBehavioralFeatureEventsSink",
3107: "onParameterAdded");
3108:
3109: Object[] parms = new Object[] { feature, parm, cell };
3110: parameterAdded.setParameters(parms);
3111: m_BehavFeatureSink.notifyListeners(parameterAdded);
3112: }
3113: }
3114:
3115: public boolean firePreOperationPropertyModified(IOperation oper,
3116: int kind, boolean proposedValue, IEventPayload payload) {
3117: boolean proceed = true;
3118:
3119: Vector<Object> vect = new Vector<Object>();
3120: vect.add(0, oper);
3121: vect.add(1, new Integer(kind));
3122: vect.add(2, new Boolean(proposedValue));
3123: Object var = prepareVariant(vect);
3124:
3125: if (validateEvent("PreOperationPropertyModified", var)) {
3126: IResultCell cell = prepareResultCell(payload);
3127: EventFunctor preOperationPropertyModified = new EventFunctor(
3128: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
3129: "onPreOperationPropertyModified");
3130:
3131: Object[] parms = new Object[2];
3132: parms[0] = var;
3133: parms[1] = cell;
3134: preOperationPropertyModified.setParameters(parms);
3135: m_OperSink
3136: .notifyListenersWithQualifiedProceed(preOperationPropertyModified);
3137: if (cell != null) {
3138: proceed = cell.canContinue();
3139: }
3140: }
3141: return proceed;
3142: }
3143:
3144: public void fireOperationPropertyModified(IOperation oper,
3145: int kind, IEventPayload payload) {
3146: Vector<Object> vect = new Vector<Object>();
3147: vect.add(0, oper);
3148: vect.add(1, new Integer(kind));
3149: Object var = prepareVariant(vect);
3150:
3151: if (validateEvent("OperationPropertyModified", var)) {
3152: IResultCell cell = prepareResultCell(payload);
3153: EventFunctor operationPropertyModified = new EventFunctor(
3154: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IOperationEventsSink",
3155: "onOperationPropertyModified");
3156:
3157: Object[] parms = new Object[2];
3158: parms[0] = var;
3159: parms[1] = cell;
3160: operationPropertyModified.setParameters(parms);
3161: m_OperSink.notifyListeners(operationPropertyModified);
3162: }
3163: }
3164:
3165: public void fireEnumerationLiteralAdded(IClassifier classifier,
3166: IEnumerationLiteral enumLit, IEventPayload payload) {
3167: Vector<Object> vect = new Vector<Object>();
3168: vect.add(0, classifier);
3169: vect.add(1, enumLit);
3170: Object var = prepareVariant(vect);
3171:
3172: if (validateEvent("EnumerationLiteralAdded", var)) {
3173: IResultCell cell = prepareResultCell(payload);
3174: EventFunctor eventFunctor = new EventFunctor(
3175: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
3176: "onEnumerationLiteralAdded");
3177:
3178: Object[] parms = new Object[2];
3179: parms[0] = var;
3180: parms[1] = cell;
3181:
3182: eventFunctor.setParameters(parms);
3183: m_ClassifierSink.notifyListeners(eventFunctor);
3184: }
3185: }
3186:
3187: public boolean fireEnumerationLiteralPreAdded(
3188: IClassifier classifier, IEnumerationLiteral enumLit,
3189: IEventPayload payload) {
3190: boolean proceed = true;
3191:
3192: Vector<Object> vect = new Vector<Object>();
3193: vect.add(0, classifier);
3194: vect.add(1, enumLit);
3195: Object var = prepareVariant(vect);
3196:
3197: if (validateEvent("EnumerationLiteralPreAdded", var)) {
3198: IResultCell cell = prepareResultCell(payload);
3199: EventFunctor eventFunctor = new EventFunctor(
3200: "org.netbeans.modules.uml.core.metamodel.infrastructure.coreinfrastructure.IClassifierFeatureEventsSink",
3201: "onEnumerationLiteralPreAdded");
3202:
3203: Object[] parms = new Object[2];
3204: parms[0] = var;
3205: parms[1] = cell;
3206:
3207: eventFunctor.setParameters(parms);
3208: m_ClassifierSink
3209: .notifyListenersWithQualifiedProceed(eventFunctor);
3210:
3211: if (cell != null)
3212: proceed = cell.canContinue();
3213: }
3214:
3215: return proceed;
3216: }
3217:
3218: }
|