0001: /*
0002: * ChainBuilder ESB
0003: * Visual Enterprise Integration
0004: *
0005: * Copyright (C) 2006 Bostech Corporation
0006: *
0007: * This program is free software; you can redistribute it and/or modify it
0008: * under the terms of the GNU General Public License as published by the
0009: * Free Software Foundation; either version 2 of the License, or (at your option)
0010: * any later version.
0011: *
0012: * This program is distributed in the hope that it will be useful,
0013: * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
0014: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
0015: * for more details.
0016: *
0017: * You should have received a copy of the GNU General Public License along with
0018: * this program; if not, write to the Free Software Foundation, Inc.,
0019: * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0020: *
0021: *
0022: * $Id$
0023: */
0024: package com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.part;
0025:
0026: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.componentflowFactory;
0027:
0028: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.CBREditPart;
0029: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.CommentEditPart;
0030: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.CustomEditPart;
0031: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.EmailEditPart;
0032: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.ExternalSystemEditPart;
0033: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.FTPEditPart;
0034: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.FileEditPart;
0035: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.HTTPEditPart;
0036: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.JDBCEditPart;
0037: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.JMSEditPart;
0038: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.MessageExchangeEditPart;
0039: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.ParserEditPart;
0040: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.ScriptEditPart;
0041: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.SequencerEditPart;
0042: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.TCPIPEditPart;
0043: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.TransformerEditPart;
0044: import com.bostechcorp.cbesb.ui.componentflow.componentFlowEditor.diagram.edit.parts.XSLTEditPart;
0045:
0046: import org.eclipse.emf.common.notify.AdapterFactory;
0047:
0048: import org.eclipse.emf.edit.provider.IItemLabelProvider;
0049:
0050: import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
0051:
0052: import org.eclipse.gef.EditPart;
0053: import org.eclipse.gef.Request;
0054: import org.eclipse.gef.RequestConstants;
0055: import org.eclipse.gef.Tool;
0056:
0057: import org.eclipse.gef.palette.CombinedTemplateCreationEntry;
0058: import org.eclipse.gef.palette.ConnectionCreationToolEntry;
0059: import org.eclipse.gef.palette.MarqueeToolEntry;
0060: import org.eclipse.gef.palette.PaletteContainer;
0061: import org.eclipse.gef.palette.PaletteDrawer;
0062: import org.eclipse.gef.palette.PaletteGroup;
0063: import org.eclipse.gef.palette.PaletteRoot;
0064: import org.eclipse.gef.palette.SelectionToolEntry;
0065: import org.eclipse.gef.palette.ToolEntry;
0066:
0067: import org.eclipse.gef.requests.CreateConnectionRequest;
0068: import org.eclipse.gef.requests.CreateRequest;
0069: import org.eclipse.gef.requests.CreationFactory;
0070:
0071: import org.eclipse.gef.tools.ConnectionCreationTool;
0072: import org.eclipse.gef.tools.CreationTool;
0073:
0074: import org.eclipse.gmf.runtime.notation.Edge;
0075: import org.eclipse.gmf.runtime.notation.Node;
0076:
0077: import org.eclipse.jface.resource.ImageDescriptor;
0078:
0079: /**
0080: * @generated
0081: */
0082: public class ComponentFlowEditorPaletteFactory {
0083: /**
0084: * @generated
0085: */
0086: private final AdapterFactory domainAdapterFactory;
0087:
0088: /**
0089: * @generated
0090: */
0091: public ComponentFlowEditorPaletteFactory(
0092: AdapterFactory domainAdapterFactory) {
0093: this .domainAdapterFactory = domainAdapterFactory;
0094: }
0095:
0096: /**
0097: * @generated
0098: */
0099: public void contributeToPalette(PaletteRoot paletteRoot) {
0100: PaletteGroup controls = new PaletteGroup("Controls");
0101: paletteRoot.add(controls);
0102:
0103: ToolEntry tool = new SelectionToolEntry();
0104: controls.add(tool);
0105: paletteRoot.setDefaultEntry(tool);
0106:
0107: controls.add(new MarqueeToolEntry());
0108: paletteRoot.add(createBindingComponents1Group());
0109: paletteRoot.add(createServiceEngines2Group());
0110: paletteRoot.add(createExternal3Group());
0111: paletteRoot.add(createMessageFlows4Group());
0112: }
0113:
0114: /**
0115: * @generated
0116: */
0117: private PaletteContainer createBindingComponents1Group() {
0118: PaletteContainer paletteContainer = createContainer("Binding Components");
0119: paletteContainer.add(createHTTP1CreationTool());
0120: paletteContainer.add(createFile2CreationTool());
0121: paletteContainer.add(createFTP3CreationTool());
0122: paletteContainer.add(createJMS4CreationTool());
0123: paletteContainer.add(createTCPIP5CreationTool());
0124: paletteContainer.add(createScript6CreationTool());
0125: paletteContainer.add(createCustom7CreationTool());
0126: paletteContainer.add(createEmail8CreationTool());
0127: return paletteContainer;
0128: }
0129:
0130: /**
0131: * @generated
0132: */
0133: private PaletteContainer createServiceEngines2Group() {
0134: PaletteContainer paletteContainer = createContainer("Service Engines");
0135: paletteContainer.add(createTransformer1CreationTool());
0136: paletteContainer.add(createParser2CreationTool());
0137: paletteContainer.add(createXSLT3CreationTool());
0138: paletteContainer.add(createSequencer4CreationTool());
0139: paletteContainer.add(createCBR5CreationTool());
0140: paletteContainer.add(createJDBC6CreationTool());
0141: return paletteContainer;
0142: }
0143:
0144: /**
0145: * @generated
0146: */
0147: private PaletteContainer createExternal3Group() {
0148: PaletteContainer paletteContainer = createContainer("External");
0149: paletteContainer.add(createExternalSystem1CreationTool());
0150: paletteContainer.add(createComment2CreationTool());
0151: return paletteContainer;
0152: }
0153:
0154: /**
0155: * @generated
0156: */
0157: private PaletteContainer createMessageFlows4Group() {
0158: PaletteContainer paletteContainer = createContainer("Message Flows");
0159: paletteContainer.add(createMessageExchange1CreationTool());
0160: return paletteContainer;
0161: }
0162:
0163: /**
0164: * @generated
0165: */
0166: private ToolEntry createHTTP1CreationTool() {
0167:
0168: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0169: .createHTTP());
0170:
0171: ImageDescriptor largeImage = smallImage;
0172:
0173: final int[] visualIds = new int[] { HTTPEditPart.VISUAL_ID };
0174: return new CombinedTemplateCreationEntry("HTTP",
0175: "Create new HTTP",
0176: new ModelCreationFactory(Node.class), smallImage,
0177: largeImage) {
0178: public Tool createTool() {
0179: Tool result = new CreationTool() {
0180: protected Request createTargetRequest() {
0181: CreateRequestEx request = new CreateRequestEx(
0182: visualIds);
0183: request.setFactory(getFactory());
0184: return request;
0185: }
0186:
0187: protected void performCreation(int button) {
0188: super .performCreation(button);
0189: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0190: .getEditPartRegistry().get(
0191: getCreateRequest()
0192: .getNewObject());
0193: if (createdEditPart != null) {
0194: getCurrentViewer().getControl()
0195: .getDisplay().asyncExec(
0196: new Runnable() {
0197: public void run() {
0198: if (createdEditPart
0199: .isActive()) {
0200: createdEditPart
0201: .performRequest(new Request(
0202: RequestConstants.REQ_DIRECT_EDIT));
0203: }
0204: }
0205: });
0206: }
0207: }
0208: };
0209: result.setProperties(getToolProperties());
0210: return result;
0211: }
0212: };
0213: }
0214:
0215: /**
0216: * @generated
0217: */
0218: private ToolEntry createFile2CreationTool() {
0219:
0220: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0221: .createFile());
0222:
0223: ImageDescriptor largeImage = smallImage;
0224:
0225: final int[] visualIds = new int[] { FileEditPart.VISUAL_ID };
0226: return new CombinedTemplateCreationEntry("File",
0227: "Create new File",
0228: new ModelCreationFactory(Node.class), smallImage,
0229: largeImage) {
0230: public Tool createTool() {
0231: Tool result = new CreationTool() {
0232: protected Request createTargetRequest() {
0233: CreateRequestEx request = new CreateRequestEx(
0234: visualIds);
0235: request.setFactory(getFactory());
0236: return request;
0237: }
0238:
0239: protected void performCreation(int button) {
0240: super .performCreation(button);
0241: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0242: .getEditPartRegistry().get(
0243: getCreateRequest()
0244: .getNewObject());
0245: if (createdEditPart != null) {
0246: getCurrentViewer().getControl()
0247: .getDisplay().asyncExec(
0248: new Runnable() {
0249: public void run() {
0250: if (createdEditPart
0251: .isActive()) {
0252: createdEditPart
0253: .performRequest(new Request(
0254: RequestConstants.REQ_DIRECT_EDIT));
0255: }
0256: }
0257: });
0258: }
0259: }
0260: };
0261: result.setProperties(getToolProperties());
0262: return result;
0263: }
0264: };
0265: }
0266:
0267: /**
0268: * @generated
0269: */
0270: private ToolEntry createFTP3CreationTool() {
0271:
0272: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0273: .createFTP());
0274:
0275: ImageDescriptor largeImage = smallImage;
0276:
0277: final int[] visualIds = new int[] { FTPEditPart.VISUAL_ID };
0278: return new CombinedTemplateCreationEntry("FTP",
0279: "Create new FTP", new ModelCreationFactory(Node.class),
0280: smallImage, largeImage) {
0281: public Tool createTool() {
0282: Tool result = new CreationTool() {
0283: protected Request createTargetRequest() {
0284: CreateRequestEx request = new CreateRequestEx(
0285: visualIds);
0286: request.setFactory(getFactory());
0287: return request;
0288: }
0289:
0290: protected void performCreation(int button) {
0291: super .performCreation(button);
0292: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0293: .getEditPartRegistry().get(
0294: getCreateRequest()
0295: .getNewObject());
0296: if (createdEditPart != null) {
0297: getCurrentViewer().getControl()
0298: .getDisplay().asyncExec(
0299: new Runnable() {
0300: public void run() {
0301: if (createdEditPart
0302: .isActive()) {
0303: createdEditPart
0304: .performRequest(new Request(
0305: RequestConstants.REQ_DIRECT_EDIT));
0306: }
0307: }
0308: });
0309: }
0310: }
0311: };
0312: result.setProperties(getToolProperties());
0313: return result;
0314: }
0315: };
0316: }
0317:
0318: /**
0319: * @generated
0320: */
0321: private ToolEntry createJMS4CreationTool() {
0322:
0323: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0324: .createJMS());
0325:
0326: ImageDescriptor largeImage = smallImage;
0327:
0328: final int[] visualIds = new int[] { JMSEditPart.VISUAL_ID };
0329: return new CombinedTemplateCreationEntry("JMS",
0330: "Create new JMS", new ModelCreationFactory(Node.class),
0331: smallImage, largeImage) {
0332: public Tool createTool() {
0333: Tool result = new CreationTool() {
0334: protected Request createTargetRequest() {
0335: CreateRequestEx request = new CreateRequestEx(
0336: visualIds);
0337: request.setFactory(getFactory());
0338: return request;
0339: }
0340:
0341: protected void performCreation(int button) {
0342: super .performCreation(button);
0343: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0344: .getEditPartRegistry().get(
0345: getCreateRequest()
0346: .getNewObject());
0347: if (createdEditPart != null) {
0348: getCurrentViewer().getControl()
0349: .getDisplay().asyncExec(
0350: new Runnable() {
0351: public void run() {
0352: if (createdEditPart
0353: .isActive()) {
0354: createdEditPart
0355: .performRequest(new Request(
0356: RequestConstants.REQ_DIRECT_EDIT));
0357: }
0358: }
0359: });
0360: }
0361: }
0362: };
0363: result.setProperties(getToolProperties());
0364: return result;
0365: }
0366: };
0367: }
0368:
0369: /**
0370: * @generated
0371: */
0372: private ToolEntry createTCPIP5CreationTool() {
0373:
0374: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0375: .createTCPIP());
0376:
0377: ImageDescriptor largeImage = smallImage;
0378:
0379: final int[] visualIds = new int[] { TCPIPEditPart.VISUAL_ID };
0380: return new CombinedTemplateCreationEntry("TCPIP",
0381: "Create new TCPIP",
0382: new ModelCreationFactory(Node.class), smallImage,
0383: largeImage) {
0384: public Tool createTool() {
0385: Tool result = new CreationTool() {
0386: protected Request createTargetRequest() {
0387: CreateRequestEx request = new CreateRequestEx(
0388: visualIds);
0389: request.setFactory(getFactory());
0390: return request;
0391: }
0392:
0393: protected void performCreation(int button) {
0394: super .performCreation(button);
0395: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0396: .getEditPartRegistry().get(
0397: getCreateRequest()
0398: .getNewObject());
0399: if (createdEditPart != null) {
0400: getCurrentViewer().getControl()
0401: .getDisplay().asyncExec(
0402: new Runnable() {
0403: public void run() {
0404: if (createdEditPart
0405: .isActive()) {
0406: createdEditPart
0407: .performRequest(new Request(
0408: RequestConstants.REQ_DIRECT_EDIT));
0409: }
0410: }
0411: });
0412: }
0413: }
0414: };
0415: result.setProperties(getToolProperties());
0416: return result;
0417: }
0418: };
0419: }
0420:
0421: /**
0422: * @generated
0423: */
0424: private ToolEntry createScript6CreationTool() {
0425:
0426: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0427: .createScript());
0428:
0429: ImageDescriptor largeImage = smallImage;
0430:
0431: final int[] visualIds = new int[] { ScriptEditPart.VISUAL_ID };
0432: return new CombinedTemplateCreationEntry("Script",
0433: "Cerate new Script", new ModelCreationFactory(
0434: Node.class), smallImage, largeImage) {
0435: public Tool createTool() {
0436: Tool result = new CreationTool() {
0437: protected Request createTargetRequest() {
0438: CreateRequestEx request = new CreateRequestEx(
0439: visualIds);
0440: request.setFactory(getFactory());
0441: return request;
0442: }
0443:
0444: protected void performCreation(int button) {
0445: super .performCreation(button);
0446: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0447: .getEditPartRegistry().get(
0448: getCreateRequest()
0449: .getNewObject());
0450: if (createdEditPart != null) {
0451: getCurrentViewer().getControl()
0452: .getDisplay().asyncExec(
0453: new Runnable() {
0454: public void run() {
0455: if (createdEditPart
0456: .isActive()) {
0457: createdEditPart
0458: .performRequest(new Request(
0459: RequestConstants.REQ_DIRECT_EDIT));
0460: }
0461: }
0462: });
0463: }
0464: }
0465: };
0466: result.setProperties(getToolProperties());
0467: return result;
0468: }
0469: };
0470: }
0471:
0472: /**
0473: * @generated
0474: */
0475: private ToolEntry createCustom7CreationTool() {
0476:
0477: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0478: .createCustom());
0479:
0480: ImageDescriptor largeImage = smallImage;
0481:
0482: final int[] visualIds = new int[] { CustomEditPart.VISUAL_ID };
0483: return new CombinedTemplateCreationEntry("Custom",
0484: "Cerate new Custom", new ModelCreationFactory(
0485: Node.class), smallImage, largeImage) {
0486: public Tool createTool() {
0487: Tool result = new CreationTool() {
0488: protected Request createTargetRequest() {
0489: CreateRequestEx request = new CreateRequestEx(
0490: visualIds);
0491: request.setFactory(getFactory());
0492: return request;
0493: }
0494:
0495: protected void performCreation(int button) {
0496: super .performCreation(button);
0497: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0498: .getEditPartRegistry().get(
0499: getCreateRequest()
0500: .getNewObject());
0501: if (createdEditPart != null) {
0502: getCurrentViewer().getControl()
0503: .getDisplay().asyncExec(
0504: new Runnable() {
0505: public void run() {
0506: if (createdEditPart
0507: .isActive()) {
0508: createdEditPart
0509: .performRequest(new Request(
0510: RequestConstants.REQ_DIRECT_EDIT));
0511: }
0512: }
0513: });
0514: }
0515: }
0516: };
0517: result.setProperties(getToolProperties());
0518: return result;
0519: }
0520: };
0521: }
0522:
0523: /**
0524: * @generated
0525: */
0526: private ToolEntry createEmail8CreationTool() {
0527:
0528: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0529: .createEmail());
0530:
0531: ImageDescriptor largeImage = smallImage;
0532:
0533: final int[] visualIds = new int[] { EmailEditPart.VISUAL_ID };
0534: return new CombinedTemplateCreationEntry("Email",
0535: "Create new Email",
0536: new ModelCreationFactory(Node.class), smallImage,
0537: largeImage) {
0538: public Tool createTool() {
0539: Tool result = new CreationTool() {
0540: protected Request createTargetRequest() {
0541: CreateRequestEx request = new CreateRequestEx(
0542: visualIds);
0543: request.setFactory(getFactory());
0544: return request;
0545: }
0546:
0547: protected void performCreation(int button) {
0548: super .performCreation(button);
0549: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0550: .getEditPartRegistry().get(
0551: getCreateRequest()
0552: .getNewObject());
0553: if (createdEditPart != null) {
0554: getCurrentViewer().getControl()
0555: .getDisplay().asyncExec(
0556: new Runnable() {
0557: public void run() {
0558: if (createdEditPart
0559: .isActive()) {
0560: createdEditPart
0561: .performRequest(new Request(
0562: RequestConstants.REQ_DIRECT_EDIT));
0563: }
0564: }
0565: });
0566: }
0567: }
0568: };
0569: result.setProperties(getToolProperties());
0570: return result;
0571: }
0572: };
0573: }
0574:
0575: /**
0576: * @generated
0577: */
0578: private ToolEntry createTransformer1CreationTool() {
0579:
0580: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0581: .createTransformer());
0582:
0583: ImageDescriptor largeImage = smallImage;
0584:
0585: final int[] visualIds = new int[] { TransformerEditPart.VISUAL_ID };
0586: return new CombinedTemplateCreationEntry("Transformer",
0587: "Create new Transformer", new ModelCreationFactory(
0588: Node.class), smallImage, largeImage) {
0589: public Tool createTool() {
0590: Tool result = new CreationTool() {
0591: protected Request createTargetRequest() {
0592: CreateRequestEx request = new CreateRequestEx(
0593: visualIds);
0594: request.setFactory(getFactory());
0595: return request;
0596: }
0597:
0598: protected void performCreation(int button) {
0599: super .performCreation(button);
0600: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0601: .getEditPartRegistry().get(
0602: getCreateRequest()
0603: .getNewObject());
0604: if (createdEditPart != null) {
0605: getCurrentViewer().getControl()
0606: .getDisplay().asyncExec(
0607: new Runnable() {
0608: public void run() {
0609: if (createdEditPart
0610: .isActive()) {
0611: createdEditPart
0612: .performRequest(new Request(
0613: RequestConstants.REQ_DIRECT_EDIT));
0614: }
0615: }
0616: });
0617: }
0618: }
0619: };
0620: result.setProperties(getToolProperties());
0621: return result;
0622: }
0623: };
0624: }
0625:
0626: /**
0627: * @generated
0628: */
0629: private ToolEntry createParser2CreationTool() {
0630:
0631: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0632: .createParser());
0633:
0634: ImageDescriptor largeImage = smallImage;
0635:
0636: final int[] visualIds = new int[] { ParserEditPart.VISUAL_ID };
0637: return new CombinedTemplateCreationEntry("Parser",
0638: "Create new Parser", new ModelCreationFactory(
0639: Node.class), smallImage, largeImage) {
0640: public Tool createTool() {
0641: Tool result = new CreationTool() {
0642: protected Request createTargetRequest() {
0643: CreateRequestEx request = new CreateRequestEx(
0644: visualIds);
0645: request.setFactory(getFactory());
0646: return request;
0647: }
0648:
0649: protected void performCreation(int button) {
0650: super .performCreation(button);
0651: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0652: .getEditPartRegistry().get(
0653: getCreateRequest()
0654: .getNewObject());
0655: if (createdEditPart != null) {
0656: getCurrentViewer().getControl()
0657: .getDisplay().asyncExec(
0658: new Runnable() {
0659: public void run() {
0660: if (createdEditPart
0661: .isActive()) {
0662: createdEditPart
0663: .performRequest(new Request(
0664: RequestConstants.REQ_DIRECT_EDIT));
0665: }
0666: }
0667: });
0668: }
0669: }
0670: };
0671: result.setProperties(getToolProperties());
0672: return result;
0673: }
0674: };
0675: }
0676:
0677: /**
0678: * @generated
0679: */
0680: private ToolEntry createXSLT3CreationTool() {
0681:
0682: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0683: .createXSLT());
0684:
0685: ImageDescriptor largeImage = smallImage;
0686:
0687: final int[] visualIds = new int[] { XSLTEditPart.VISUAL_ID };
0688: return new CombinedTemplateCreationEntry("XSLT",
0689: "Create new XSLT",
0690: new ModelCreationFactory(Node.class), smallImage,
0691: largeImage) {
0692: public Tool createTool() {
0693: Tool result = new CreationTool() {
0694: protected Request createTargetRequest() {
0695: CreateRequestEx request = new CreateRequestEx(
0696: visualIds);
0697: request.setFactory(getFactory());
0698: return request;
0699: }
0700:
0701: protected void performCreation(int button) {
0702: super .performCreation(button);
0703: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0704: .getEditPartRegistry().get(
0705: getCreateRequest()
0706: .getNewObject());
0707: if (createdEditPart != null) {
0708: getCurrentViewer().getControl()
0709: .getDisplay().asyncExec(
0710: new Runnable() {
0711: public void run() {
0712: if (createdEditPart
0713: .isActive()) {
0714: createdEditPart
0715: .performRequest(new Request(
0716: RequestConstants.REQ_DIRECT_EDIT));
0717: }
0718: }
0719: });
0720: }
0721: }
0722: };
0723: result.setProperties(getToolProperties());
0724: return result;
0725: }
0726: };
0727: }
0728:
0729: /**
0730: * @generated
0731: */
0732: private ToolEntry createSequencer4CreationTool() {
0733:
0734: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0735: .createSequencer());
0736:
0737: ImageDescriptor largeImage = smallImage;
0738:
0739: final int[] visualIds = new int[] { SequencerEditPart.VISUAL_ID };
0740: return new CombinedTemplateCreationEntry("Sequencer",
0741: "Create new Sequencer", new ModelCreationFactory(
0742: Node.class), smallImage, largeImage) {
0743: public Tool createTool() {
0744: Tool result = new CreationTool() {
0745: protected Request createTargetRequest() {
0746: CreateRequestEx request = new CreateRequestEx(
0747: visualIds);
0748: request.setFactory(getFactory());
0749: return request;
0750: }
0751:
0752: protected void performCreation(int button) {
0753: super .performCreation(button);
0754: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0755: .getEditPartRegistry().get(
0756: getCreateRequest()
0757: .getNewObject());
0758: if (createdEditPart != null) {
0759: getCurrentViewer().getControl()
0760: .getDisplay().asyncExec(
0761: new Runnable() {
0762: public void run() {
0763: if (createdEditPart
0764: .isActive()) {
0765: createdEditPart
0766: .performRequest(new Request(
0767: RequestConstants.REQ_DIRECT_EDIT));
0768: }
0769: }
0770: });
0771: }
0772: }
0773: };
0774: result.setProperties(getToolProperties());
0775: return result;
0776: }
0777: };
0778: }
0779:
0780: /**
0781: * @generated
0782: */
0783: private ToolEntry createCBR5CreationTool() {
0784:
0785: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0786: .createCBR());
0787:
0788: ImageDescriptor largeImage = smallImage;
0789:
0790: final int[] visualIds = new int[] { CBREditPart.VISUAL_ID };
0791: return new CombinedTemplateCreationEntry("CBR",
0792: "Create new CBR", new ModelCreationFactory(Node.class),
0793: smallImage, largeImage) {
0794: public Tool createTool() {
0795: Tool result = new CreationTool() {
0796: protected Request createTargetRequest() {
0797: CreateRequestEx request = new CreateRequestEx(
0798: visualIds);
0799: request.setFactory(getFactory());
0800: return request;
0801: }
0802:
0803: protected void performCreation(int button) {
0804: super .performCreation(button);
0805: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0806: .getEditPartRegistry().get(
0807: getCreateRequest()
0808: .getNewObject());
0809: if (createdEditPart != null) {
0810: getCurrentViewer().getControl()
0811: .getDisplay().asyncExec(
0812: new Runnable() {
0813: public void run() {
0814: if (createdEditPart
0815: .isActive()) {
0816: createdEditPart
0817: .performRequest(new Request(
0818: RequestConstants.REQ_DIRECT_EDIT));
0819: }
0820: }
0821: });
0822: }
0823: }
0824: };
0825: result.setProperties(getToolProperties());
0826: return result;
0827: }
0828: };
0829: }
0830:
0831: /**
0832: * @generated
0833: */
0834: private ToolEntry createJDBC6CreationTool() {
0835:
0836: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0837: .createJDBC());
0838:
0839: ImageDescriptor largeImage = smallImage;
0840:
0841: final int[] visualIds = new int[] { JDBCEditPart.VISUAL_ID };
0842: return new CombinedTemplateCreationEntry("JDBC",
0843: "Create new JDBC",
0844: new ModelCreationFactory(Node.class), smallImage,
0845: largeImage) {
0846: public Tool createTool() {
0847: Tool result = new CreationTool() {
0848: protected Request createTargetRequest() {
0849: CreateRequestEx request = new CreateRequestEx(
0850: visualIds);
0851: request.setFactory(getFactory());
0852: return request;
0853: }
0854:
0855: protected void performCreation(int button) {
0856: super .performCreation(button);
0857: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0858: .getEditPartRegistry().get(
0859: getCreateRequest()
0860: .getNewObject());
0861: if (createdEditPart != null) {
0862: getCurrentViewer().getControl()
0863: .getDisplay().asyncExec(
0864: new Runnable() {
0865: public void run() {
0866: if (createdEditPart
0867: .isActive()) {
0868: createdEditPart
0869: .performRequest(new Request(
0870: RequestConstants.REQ_DIRECT_EDIT));
0871: }
0872: }
0873: });
0874: }
0875: }
0876: };
0877: result.setProperties(getToolProperties());
0878: return result;
0879: }
0880: };
0881: }
0882:
0883: /**
0884: * @generated
0885: */
0886: private ToolEntry createExternalSystem1CreationTool() {
0887:
0888: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0889: .createExternalSystem());
0890:
0891: ImageDescriptor largeImage = smallImage;
0892:
0893: final int[] visualIds = new int[] { ExternalSystemEditPart.VISUAL_ID };
0894: return new CombinedTemplateCreationEntry("ExternalSystem",
0895: "Create new ExternalSystem", new ModelCreationFactory(
0896: Node.class), smallImage, largeImage) {
0897: public Tool createTool() {
0898: Tool result = new CreationTool() {
0899: protected Request createTargetRequest() {
0900: CreateRequestEx request = new CreateRequestEx(
0901: visualIds);
0902: request.setFactory(getFactory());
0903: return request;
0904: }
0905:
0906: protected void performCreation(int button) {
0907: super .performCreation(button);
0908: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0909: .getEditPartRegistry().get(
0910: getCreateRequest()
0911: .getNewObject());
0912: if (createdEditPart != null) {
0913: getCurrentViewer().getControl()
0914: .getDisplay().asyncExec(
0915: new Runnable() {
0916: public void run() {
0917: if (createdEditPart
0918: .isActive()) {
0919: createdEditPart
0920: .performRequest(new Request(
0921: RequestConstants.REQ_DIRECT_EDIT));
0922: }
0923: }
0924: });
0925: }
0926: }
0927: };
0928: result.setProperties(getToolProperties());
0929: return result;
0930: }
0931: };
0932: }
0933:
0934: /**
0935: * @generated
0936: */
0937: private ToolEntry createComment2CreationTool() {
0938:
0939: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0940: .createComment());
0941:
0942: ImageDescriptor largeImage = smallImage;
0943:
0944: final int[] visualIds = new int[] { CommentEditPart.VISUAL_ID };
0945: return new CombinedTemplateCreationEntry("Comment",
0946: "Create new comment component",
0947: new ModelCreationFactory(Node.class), smallImage,
0948: largeImage) {
0949: public Tool createTool() {
0950: Tool result = new CreationTool() {
0951: protected Request createTargetRequest() {
0952: CreateRequestEx request = new CreateRequestEx(
0953: visualIds);
0954: request.setFactory(getFactory());
0955: return request;
0956: }
0957:
0958: protected void performCreation(int button) {
0959: super .performCreation(button);
0960: final EditPart createdEditPart = (EditPart) getCurrentViewer()
0961: .getEditPartRegistry().get(
0962: getCreateRequest()
0963: .getNewObject());
0964: if (createdEditPart != null) {
0965: getCurrentViewer().getControl()
0966: .getDisplay().asyncExec(
0967: new Runnable() {
0968: public void run() {
0969: if (createdEditPart
0970: .isActive()) {
0971: createdEditPart
0972: .performRequest(new Request(
0973: RequestConstants.REQ_DIRECT_EDIT));
0974: }
0975: }
0976: });
0977: }
0978: }
0979: };
0980: result.setProperties(getToolProperties());
0981: return result;
0982: }
0983: };
0984: }
0985:
0986: /**
0987: * @generated
0988: */
0989: private ToolEntry createMessageExchange1CreationTool() {
0990:
0991: ImageDescriptor smallImage = getImage(componentflowFactory.eINSTANCE
0992: .createMessageExchange());
0993:
0994: ImageDescriptor largeImage = smallImage;
0995:
0996: final int[] visualIds = new int[] { MessageExchangeEditPart.VISUAL_ID };
0997: return new ConnectionCreationToolEntry("MessageExchange",
0998: "Create new MessageExchange", new ModelCreationFactory(
0999: Edge.class), smallImage, largeImage) {
1000: public Tool createTool() {
1001: Tool result = new ConnectionCreationTool() {
1002: {
1003: setUnloadWhenFinished(true);
1004: }
1005:
1006: protected Request createTargetRequest() {
1007: CreateConnectionRequestEx request = new CreateConnectionRequestEx(
1008: visualIds);
1009: request.setFactory(getFactory());
1010: return request;
1011: }
1012: };
1013: result.setProperties(getToolProperties());
1014: return result;
1015: }
1016: };
1017: }
1018:
1019: /**
1020: * @generated
1021: */
1022: private PaletteContainer createContainer(String title) {
1023: return new PaletteDrawer(title);
1024: }
1025:
1026: /**
1027: * @generated
1028: */
1029: private ImageDescriptor getImage(Object o) {
1030: IItemLabelProvider labelProvider = (IItemLabelProvider) domainAdapterFactory
1031: .adapt(o, IItemLabelProvider.class);
1032: if (labelProvider != null) {
1033: return ExtendedImageRegistry.getInstance()
1034: .getImageDescriptor(labelProvider.getImage(o));
1035: }
1036: return null;
1037: }
1038:
1039: /**
1040: * @generated
1041: */
1042: public static class CreateRequestEx extends CreateRequest {
1043: /**
1044: * @generated
1045: */
1046: private final int[] visualIds;
1047:
1048: /**
1049: * @generated
1050: */
1051: public CreateRequestEx(int[] visualIds) {
1052: this .visualIds = visualIds;
1053: }
1054:
1055: /**
1056: * @generated
1057: */
1058: public int[] getVisualIds() {
1059: return visualIds;
1060: }
1061:
1062: /**
1063: * @generated
1064: */
1065: public void setCreatedObject(Object createdObject) {
1066: ((ModelCreationFactory) getFactory())
1067: .setCreatedObject(createdObject);
1068: }
1069: }
1070:
1071: /**
1072: * @generated
1073: */
1074: public static class CreateConnectionRequestEx extends
1075: CreateConnectionRequest {
1076: /**
1077: * @generated
1078: */
1079: private final int[] visualIds;
1080:
1081: /**
1082: * @generated
1083: */
1084: public CreateConnectionRequestEx(int[] visualIds) {
1085: this .visualIds = visualIds;
1086: }
1087:
1088: /**
1089: * @generated
1090: */
1091: public int[] getVisualIds() {
1092: return visualIds;
1093: }
1094:
1095: /**
1096: * @generated
1097: */
1098: public void setCreatedObject(Object createdObject) {
1099: ((ModelCreationFactory) getFactory())
1100: .setCreatedObject(createdObject);
1101: }
1102: }
1103:
1104: /**
1105: * @generated
1106: */
1107: public static class ModelCreationFactory implements CreationFactory {
1108: /**
1109: * @generated
1110: */
1111: private Object createdObject;
1112:
1113: /**
1114: * @generated
1115: */
1116: private final Class createdObjectType;
1117:
1118: /**
1119: * @generated
1120: */
1121: public ModelCreationFactory(Class objectType) {
1122: createdObjectType = objectType;
1123: }
1124:
1125: /**
1126: * @generated
1127: */
1128: public Object getNewObject() {
1129: return createdObject;
1130: }
1131:
1132: /**
1133: * @generated
1134: */
1135: public Object getObjectType() {
1136: return createdObjectType;
1137: }
1138:
1139: /**
1140: * @generated
1141: */
1142: public void setCreatedObject(Object createdObject) {
1143: this.createdObject = createdObject;
1144: }
1145: }
1146: }
|