001: /*
002: * The contents of this file are subject to the terms of the Common Development
003: * and Distribution License (the License). You may not use this file except in
004: * compliance with the License.
005: *
006: * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
007: * or http://www.netbeans.org/cddl.txt.
008: *
009: * When distributing Covered Code, include this CDDL Header Notice in each file
010: * and include the License file at http://www.netbeans.org/cddl.txt.
011: * If applicable, add the following below the CDDL Header, with the fields
012: * enclosed by brackets [] replaced by your own identifying information:
013: * "Portions Copyrighted [year] [name of copyright owner]"
014: *
015: * The Original Software is NetBeans. The Initial Developer of the Original
016: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
017: * Microsystems, Inc. All Rights Reserved.
018: */
019: package org.netbeans.modules.xslt.core.context;
020:
021: import java.beans.PropertyChangeEvent;
022: import java.beans.PropertyChangeListener;
023: import java.util.EventObject;
024: import org.netbeans.api.project.FileOwnerQuery;
025: import org.netbeans.api.project.Project;
026: import org.netbeans.modules.xml.axi.AXIComponent;
027: import org.netbeans.modules.xml.axi.AXIModel;
028: import org.netbeans.modules.xml.schema.model.SchemaModel;
029: import org.netbeans.modules.xml.wsdl.model.Part;
030: import org.netbeans.modules.xml.wsdl.model.WSDLModel;
031: import org.netbeans.modules.xml.xam.ComponentEvent;
032: import org.netbeans.modules.xml.xam.ComponentListener;
033: import org.netbeans.modules.xslt.tmap.util.Util;
034: import org.netbeans.modules.xslt.tmap.model.api.TMapModel;
035: import org.netbeans.modules.xslt.mapper.model.MapperContext;
036: import org.netbeans.modules.xslt.mapper.model.MapperContextChangeListener;
037: import org.netbeans.modules.xslt.mapper.model.MapperContextChangeSupport;
038: import org.netbeans.modules.xslt.model.XslModel;
039: import org.netbeans.modules.xslt.project.spi.ProjectsFilesChangeHandler;
040: import org.netbeans.modules.xslt.project.spi.ProjectsFilesChangeListener;
041: import org.netbeans.modules.xslt.tmap.model.api.Transform;
042: import org.netbeans.modules.xslt.tmap.model.api.VariableReference;
043: import org.netbeans.modules.xslt.tmap.model.api.WSDLReference;
044: import org.netbeans.modules.xslt.tmap.model.validation.TransformmapValidator;
045: import org.netbeans.modules.xslt.tmap.model.validation.TransformmapValidatorImpl;
046: import org.openide.filesystems.FileAttributeEvent;
047: import org.openide.filesystems.FileChangeListener;
048: import org.openide.filesystems.FileEvent;
049: import org.openide.filesystems.FileObject;
050: import org.openide.filesystems.FileRenameEvent;
051: import org.openide.util.RequestProcessor;
052:
053: /**
054: *
055: * @author Vitaly Bychkov
056: * @version 1.0
057: */
058: public class MapperContextImpl implements MapperContext {
059:
060: private static final int CONTEXT_CHANGE_TASK_DELAY = 500;
061: private transient RequestProcessor.Task myPreviousChangeTask;
062:
063: private Transform myTransformContextComponent;
064: private XslModel myXslModel;
065: private AXIComponent mySourceComponent;
066: // private SchemaModel mySourceSchemaModel;
067: private AXIModel mySourceAxiModel;
068:
069: private WSDLReference<Part> mySourcePart;
070: private WSDLModel mySourceModel;
071:
072: private AXIComponent myTargetComponent;
073: // private SchemaModel myTargetSchemaModel;
074: private AXIModel myTargetAxiModel;
075:
076: private WSDLReference<Part> myTargetPart;
077: private WSDLModel myTargetModel;
078:
079: private MapperContextChangeSupport myChangeSupport = new MapperContextChangeSupport();
080: private TMapModel myTMapModel;
081:
082: private ContextPropertyChangeListener myContextChangeListener = new ContextPropertyChangeListener();
083: private FileChangeListener myFileChangeListener = new FileChangeListenerImpl();
084:
085: private ProjectsFilesChangeHandler myProjectsFilesChangeHandler;
086: private ProjectsFilesChangeListener myProjectsFilesChangeListener = new ProjectsFilesChangeListenerImpl();
087:
088: private FileObject myTMapFo;
089: private FileObject myXslFo;
090:
091: public MapperContextImpl(XslModel xslModel, TMapModel model) {
092: init(model, xslModel);
093: addContextChangeListeners();
094: }
095:
096: // TODO m
097: public MapperContextImpl(Transform transform, XslModel xslModel,
098: AXIComponent sourceComponent, AXIComponent targetComponent) {
099: init(transform, xslModel, sourceComponent, targetComponent);
100: addContextChangeListeners();
101: }
102:
103: private void init(TMapModel tMapModel, Transform transform,
104: XslModel xslModel, AXIComponent sourceComponent,
105: AXIComponent targetComponent) {
106: this .myXslModel = xslModel;
107: this .myTransformContextComponent = transform;
108: this .myTMapModel = tMapModel;
109:
110: this .mySourceComponent = sourceComponent;
111: mySourceAxiModel = mySourceComponent != null ? mySourceComponent
112: .getModel()
113: : null;
114: // this.mySourceSchemaModel = sourceModel != null
115: // ? sourceModel.getSchemaModel() : null;
116:
117: // this.mySourceAxiDocument = sourceModel != null
118: // ? sourceModel.getRoot() : null;
119:
120: mySourcePart = getSourcePart(myTransformContextComponent);
121: mySourceModel = getWsdlModel(mySourcePart);
122:
123: this .myTargetComponent = targetComponent;
124: myTargetAxiModel = myTargetComponent != null ? myTargetComponent
125: .getModel()
126: : null;
127: // this.myTargetSchemaModel = targetModel != null
128: // ? targetModel.getSchemaModel() : null;
129: // this.myTargetAxiDocument = targetModel != null
130: // ? targetModel.getRoot() : null;
131:
132: myTargetPart = getTargetPart(myTransformContextComponent);
133: myTargetModel = getWsdlModel(myTargetPart);
134:
135: myTMapFo = org.netbeans.modules.xslt.core.util.Util
136: .getFileObjectByModel(myTMapModel);
137: myXslFo = myXslModel == null ? null
138: : org.netbeans.modules.xslt.core.util.Util
139: .getFileObjectByModel(myXslModel);
140: }
141:
142: private void init(Transform transform, XslModel xslModel,
143: AXIComponent sourceComponent, AXIComponent targetComponent) {
144: init(transform == null ? null : transform.getModel(),
145: transform, xslModel, sourceComponent, targetComponent);
146: }
147:
148: private void init(TMapModel tMapModel, XslModel xslModel) {
149: init(tMapModel, null, xslModel, null, null);
150: }
151:
152: public void reinit(TMapModel tMapModel, Transform transform,
153: XslModel xslModel, AXIComponent sourceComponent,
154: AXIComponent targetComponent, EventObject evt) {
155: // XslModel oldXslModel = myXslModel;
156: // Transform oldTransform = myTransformContextComponent;
157: // TMapModel oldTMapModel = myTMapModel;
158: // AXIComponent oldSourceComponent = mySourceComponent;
159: // AXIComponent oldTargetComponent = myTargetComponent;
160:
161: setXslModel(xslModel, false);
162: setTransformContextComponent(tMapModel, transform, false);
163: setSourceType(sourceComponent, false);
164: setTargetType(targetComponent, false);
165:
166: // fireChanges(oldXslModel, oldTransform, oldTMapModel,
167: // oldSourceComponent, oldTargetComponent);
168: fireChanges(evt);
169: }
170:
171: private void fireChanges(EventObject evt) {
172: myChangeSupport.fireMapperContextChanged(null, evt);
173: }
174:
175: // private void fireChanges(XslModel oldXslModel,
176: // Transform oldTransform,
177: // TMapModel oldTMapModel,
178: // AXIComponent oldSourceComponent,
179: // AXIComponent oldTargetComponent)
180: // {
181: //
182: //// myChangeSupport.fireMapperContextChanged(oldSourceComponent, mySourceComponent);
183: //// System.out.println("mappercontext changed ...");
184: //
185: // if (myXslModel == null || !myXslModel.equals(oldXslModel) ) {
186: // myChangeSupport.fireMapperContextChanged(oldXslModel, myXslModel);
187: // return;
188: // }
189: //
190: // if (myTransformContextComponent == null || !myTransformContextComponent.equals(oldTransform) ) {
191: // myChangeSupport.fireMapperContextChanged(oldTransform, myTransformContextComponent);
192: // return;
193: // }
194: //
195: // if (myTMapModel == null || !myTMapModel.equals(oldTMapModel) ) {
196: // myChangeSupport.fireMapperContextChanged(oldTMapModel, myTMapModel);
197: // return;
198: // }
199: //
200: // if (mySourceComponent == null || !mySourceComponent.equals(oldSourceComponent) ) {
201: // myChangeSupport.fireMapperContextChanged(oldSourceComponent, mySourceComponent);
202: // return;
203: // }
204: //
205: // if (myTargetComponent == null || !myTargetComponent.equals(oldTargetComponent) ) {
206: // myChangeSupport.fireMapperContextChanged(oldTargetComponent, myTargetComponent);
207: // return;
208: // }
209: // }
210:
211: private void setTransformContextComponent(TMapModel tMapModel,
212: Transform context, boolean fireChanges) {
213: TMapModel oldTMapModel = myTMapModel;
214: myTMapModel = tMapModel;
215: if ((myTMapModel != null && !myTMapModel.equals(oldTMapModel))
216: || (oldTMapModel != null && !oldTMapModel
217: .equals(myTMapModel))) {
218: if (oldTMapModel != null) {
219: myTMapModel
220: .removePropertyChangeListener(myContextChangeListener);
221: }
222:
223: if (myTMapModel != null) {
224: myTMapModel
225: .addPropertyChangeListener(myContextChangeListener);
226: }
227: }
228:
229: Transform oldTransform = myTransformContextComponent;
230: this .myTransformContextComponent = context;
231:
232: if ((myTransformContextComponent != null && !myTransformContextComponent
233: .equals(oldTransform))
234: || (oldTransform != null && !oldTransform
235: .equals(myTransformContextComponent))) {
236: if (myTMapFo != null) {
237: myTMapFo.removeFileChangeListener(myFileChangeListener);
238: }
239:
240: myTMapFo = org.netbeans.modules.xslt.core.util.Util
241: .getFileObjectByModel(myTMapModel);
242: if (myTMapFo != null) {
243: myTMapFo.addFileChangeListener(myFileChangeListener);
244: }
245: }
246:
247: setSourcePart(getSourcePart(myTransformContextComponent));
248: setTargetPart(getTargetPart(myTransformContextComponent));
249: }
250:
251: public TMapModel getTMapModel() {
252: return myTMapModel;
253: }
254:
255: private void setXslModel(XslModel xslModel, boolean fireChanges) {
256: XslModel oldXslModel = myXslModel;
257: this .myXslModel = xslModel;
258:
259: if ((myXslModel != null && !myXslModel.equals(oldXslModel))
260: || (oldXslModel != null && !oldXslModel
261: .equals(myXslModel))) {
262: if (myXslFo != null) {
263: myXslFo.removeFileChangeListener(myFileChangeListener);
264: }
265:
266: myXslFo = myXslModel == null ? null
267: : org.netbeans.modules.xslt.core.util.Util
268: .getFileObjectByModel(myXslModel);
269: if (myXslFo != null) {
270: myXslFo.addFileChangeListener(myFileChangeListener);
271: }
272: }
273: }
274:
275: public XslModel getXSLModel() {
276: return myXslModel;
277: }
278:
279: public AXIComponent getTargetType() {
280: return myTargetComponent;
281: }
282:
283: private void setTargetType(AXIComponent axiComp, boolean fireChanges) {
284: AXIComponent oldValue = myTargetComponent;
285: // SchemaModel oldModel = myTargetSchemaModel;
286: AXIModel oldAxiModel = myTargetAxiModel;
287: // AXIDocument oldDocument = mySourceAxiDocument;
288: this .myTargetComponent = axiComp;
289:
290: this .myTargetAxiModel = myTargetComponent != null ? myTargetComponent
291: .getModel()
292: : null;
293: // this.myTargetSchemaModel = myTargetAxiModel != null
294: // ? myTargetAxiModel.getSchemaModel() : null;
295: // myTargetAxiDocument = targetModel != null ? targetModel.getRoot() : null;
296:
297: // if ((myTargetSchemaModel != null && !myTargetSchemaModel.equals(oldModel)) || (oldModel != null && !oldModel.equals(myTargetSchemaModel))) {
298: // if (oldModel != null) {
299: // oldModel.removePropertyChangeListener(myContextChangeListener);
300: // }
301: //
302: // if (myTargetSchemaModel != null) {
303: // myTargetSchemaModel.addPropertyChangeListener(myContextChangeListener);
304: // }
305: //// myChangeSupport.fireMapperContextChanged(oldModel, myTargetSchemaModel);
306: // }
307:
308: if ((myTargetAxiModel != null && !myTargetAxiModel
309: .equals(oldAxiModel))
310: || (oldAxiModel != null && !oldAxiModel
311: .equals(myTargetAxiModel))
312: || (oldAxiModel == null && myTargetAxiModel == null)) {
313: if (oldAxiModel != null) {
314: oldAxiModel
315: .removePropertyChangeListener(myContextChangeListener);
316: oldAxiModel
317: .removeComponentListener(myContextChangeListener);
318: }
319:
320: if (myTargetAxiModel != null) {
321: myTargetAxiModel
322: .addPropertyChangeListener(myContextChangeListener);
323: myTargetAxiModel
324: .addComponentListener(myContextChangeListener);
325: }
326:
327: if (fireChanges) {
328: myChangeSupport.fireMapperContextChanged(oldAxiModel,
329: myTargetAxiModel);
330: }
331: }
332:
333: if ((myTargetComponent != null && !myTargetComponent
334: .equals(oldValue))
335: || (oldValue != null && !oldValue
336: .equals(myTargetComponent))) {
337: // if (oldValue != null) {
338: // oldValue.removePropertyChangeListener(myContextChangeListener);
339: // }
340: //
341: // if (myTargetComponent != null) {
342: // myTargetComponent.addPropertyChangeListener(myContextChangeListener);
343: // }
344: if (fireChanges) {
345: myChangeSupport.fireTargetTypeChanged(oldValue,
346: myTargetComponent);
347: }
348: }
349: }
350:
351: public AXIComponent getSourceType() {
352: return mySourceComponent;
353: }
354:
355: private void setSourceType(AXIComponent axiComp, boolean fireChanges) {
356: AXIComponent oldValue = mySourceComponent;
357: // SchemaModel oldModel = mySourceSchemaModel;
358: AXIModel oldAxiModel = mySourceAxiModel;
359:
360: this .mySourceComponent = axiComp;
361:
362: mySourceAxiModel = mySourceComponent != null ? mySourceComponent
363: .getModel()
364: : null;
365: // this.mySourceSchemaModel = mySourceAxiModel != null
366: // ? mySourceAxiModel.getSchemaModel() : null;
367:
368: // if ((mySourceSchemaModel != null && !mySourceSchemaModel.equals(oldModel)) || (oldModel != null && !oldModel.equals(mySourceSchemaModel))) {
369: // if (oldModel != null) {
370: // oldModel.removePropertyChangeListener(myContextChangeListener);
371: // }
372: //
373: // if (mySourceSchemaModel != null) {
374: // mySourceSchemaModel.addPropertyChangeListener(myContextChangeListener);
375: // }
376: //// myChangeSupport.fireMapperContextChanged(oldModel, mySourceSchemaModel);
377: // }
378:
379: if ((mySourceAxiModel != null && !mySourceAxiModel
380: .equals(oldAxiModel))
381: || (oldAxiModel != null && !oldAxiModel
382: .equals(mySourceAxiModel))
383: || (oldAxiModel == null && mySourceAxiModel == null)) {
384: if (oldAxiModel != null) {
385: oldAxiModel
386: .removePropertyChangeListener(myContextChangeListener);
387: oldAxiModel
388: .removeComponentListener(myContextChangeListener);
389: }
390:
391: if (mySourceAxiModel != null) {
392: mySourceAxiModel
393: .addPropertyChangeListener(myContextChangeListener);
394: mySourceAxiModel
395: .addComponentListener(myContextChangeListener);
396: }
397:
398: if (fireChanges) {
399: myChangeSupport.fireMapperContextChanged(oldAxiModel,
400: mySourceAxiModel);
401: }
402: }
403:
404: if ((mySourceComponent != null && !mySourceComponent
405: .equals(oldValue))
406: || (oldValue != null && !oldValue
407: .equals(mySourceComponent))
408: || (oldValue == null && mySourceComponent == null)) {
409: // if (oldValue != null) {
410: // oldValue.removePropertyChangeListener(myContextChangeListener);
411: // }
412: //
413: // if (mySourceComponent != null) {
414: // mySourceComponent.addPropertyChangeListener(myContextChangeListener);
415: // }
416:
417: if (fireChanges) {
418: myChangeSupport.fireSourceTypeChanged(oldValue,
419: mySourceComponent);
420: }
421: }
422: }
423:
424: public void addMapperContextChangeListener(
425: MapperContextChangeListener listener) {
426: myChangeSupport.addPropertyChangeListener(listener);
427: }
428:
429: public void removeMapperContextChangeListener(
430: MapperContextChangeListener listener) {
431: myChangeSupport.removePropertyChangeListener(listener);
432: }
433:
434: private void setSourcePart(WSDLReference<Part> sourcePart) {
435: mySourcePart = sourcePart;
436: WSDLModel oldSourceModel = mySourceModel;
437: mySourceModel = getWsdlModel(mySourcePart);
438:
439: if ((mySourceModel != null && !mySourceModel
440: .equals(oldSourceModel))
441: || (oldSourceModel != null && !oldSourceModel
442: .equals(mySourcePart))) {
443: if (oldSourceModel != null) {
444: oldSourceModel
445: .removePropertyChangeListener(myContextChangeListener);
446: }
447:
448: if (mySourceModel != null) {
449: mySourceModel
450: .addPropertyChangeListener(myContextChangeListener);
451: }
452: }
453: }
454:
455: private WSDLReference<Part> getSourcePart(Transform transform) {
456: VariableReference varRef = transform == null ? null : transform
457: .getSource();
458: return varRef == null ? null : varRef.getPart();
459: }
460:
461: private void setTargetPart(WSDLReference<Part> targetPart) {
462: myTargetPart = targetPart;
463: WSDLModel oldTargetModel = myTargetModel;
464: myTargetModel = getWsdlModel(myTargetPart);
465:
466: if ((myTargetModel != null && !myTargetModel
467: .equals(oldTargetModel))
468: || (oldTargetModel != null && !oldTargetModel
469: .equals(myTargetPart))) {
470: if (oldTargetModel != null) {
471: oldTargetModel
472: .removePropertyChangeListener(myContextChangeListener);
473: }
474:
475: if (myTargetModel != null) {
476: myTargetModel
477: .addPropertyChangeListener(myContextChangeListener);
478: }
479: }
480: }
481:
482: private WSDLReference<Part> getTargetPart(Transform transform) {
483: VariableReference varRef = transform == null ? null : transform
484: .getResult();
485: return varRef == null ? null : varRef.getPart();
486: }
487:
488: private WSDLModel getWsdlModel(WSDLReference<Part> partRef) {
489: WSDLModel model = null;
490: if (partRef != null) {
491: Part resultPart = partRef.get();
492: model = resultPart == null ? null : resultPart.getModel();
493: }
494: return model;
495: }
496:
497: private void addContextChangeListeners() {
498: if (myTMapModel != null) {
499: myTMapModel
500: .addPropertyChangeListener(myContextChangeListener);
501: // myTMapModel.addComponentListener(myContextComponentListener);
502: }
503: if (myTMapFo != null) {
504: myTMapFo.addFileChangeListener(myFileChangeListener);
505: }
506:
507: if (myXslFo != null) {
508: myXslFo.addFileChangeListener(myFileChangeListener);
509:
510: Project xsltProject = FileOwnerQuery.getOwner(myXslFo);
511: myProjectsFilesChangeHandler = xsltProject.getLookup()
512: .lookup(ProjectsFilesChangeHandler.class);
513: if (myProjectsFilesChangeHandler != null) {
514: myProjectsFilesChangeHandler
515: .addProjectsFilesChangeListener(myProjectsFilesChangeListener);
516: }
517: }
518:
519: // if (mySourceComponent != null) {
520: //// mySourceComponent.addPropertyChangeListener(myContextChangeListener);
521: // mySoaxiModel = mySourceComponent.getModel();
522: // }
523: if (mySourceAxiModel != null) {
524: mySourceAxiModel
525: .addPropertyChangeListener(myContextChangeListener);
526: mySourceAxiModel
527: .addComponentListener(myContextChangeListener);
528: }
529: // if (mySourceSchemaModel != null) {
530: // mySourceSchemaModel.addPropertyChangeListener(myContextChangeListener);
531: // }
532:
533: // if (myTargetComponent != null) {
534: //// myTargetComponent.addPropertyChangeListener(myContextChangeListener);
535: // AXIModel axiModel = myTargetComponent.getModel();
536: // if (axiModel != null) {
537: // myTargetAxiDocument = axiModel.getRoot();
538: // myTargetAxiDocument.addPropertyChangeListener(myContextChangeListener);
539: // }
540: // }
541: if (myTargetAxiModel != null) {
542: myTargetAxiModel
543: .addPropertyChangeListener(myContextChangeListener);
544: myTargetAxiModel
545: .addComponentListener(myContextChangeListener);
546: }
547: // if (myTargetSchemaModel != null) {
548: // myTargetSchemaModel.addPropertyChangeListener(myContextChangeListener);
549: // }
550:
551: if (mySourceModel != null) {
552: mySourceModel
553: .addPropertyChangeListener(myContextChangeListener);
554: }
555:
556: if (myTargetModel != null) {
557: myTargetModel
558: .addPropertyChangeListener(myContextChangeListener);
559: }
560:
561: }
562:
563: public void removeContextChangeListeners() {
564: if (myTMapModel != null) {
565: myTMapModel
566: .removePropertyChangeListener(myContextChangeListener);
567: // myTMapModel.removeComponentListener(myContextComponentListener);
568: }
569: if (myTMapFo != null) {
570: myTMapFo.removeFileChangeListener(myFileChangeListener);
571: }
572:
573: if (myXslFo != null) {
574: myXslFo.removeFileChangeListener(myFileChangeListener);
575: }
576:
577: if (myProjectsFilesChangeHandler != null) {
578: myProjectsFilesChangeHandler
579: .removeProjectsFilesChangeListener(myProjectsFilesChangeListener);
580: }
581:
582: // if (mySourceComponent != null ) {
583: // mySourceComponent.removePropertyChangeListener(myContextChangeListener);
584: // AXIModel axiModel = mySourceComponent.getModel();
585: // if (axiModel != null) {
586: // mySourceAxiDocument = axiModel.getRoot();
587: // mySourceAxiDocument.addPropertyChangeListener(myContextChangeListener);
588: // }
589: // }
590: if (mySourceAxiModel != null) {
591: mySourceAxiModel
592: .removePropertyChangeListener(myContextChangeListener);
593: mySourceAxiModel
594: .removeComponentListener(myContextChangeListener);
595: }
596: // if (mySourceSchemaModel != null) {
597: // mySourceSchemaModel.removePropertyChangeListener(myContextChangeListener);
598: // }
599:
600: // if (myTargetComponent != null ) {
601: // myTargetComponent.removePropertyChangeListener(myContextChangeListener);
602: // AXIModel axiModel = myTargetComponent.getModel();
603: // if (axiModel != null) {
604: // myTargetAxiDocument = axiModel.getRoot();
605: // myTargetAxiDocument.addPropertyChangeListener(myContextChangeListener);
606: // }
607: // }
608: if (myTargetAxiModel != null) {
609: myTargetAxiModel
610: .removePropertyChangeListener(myContextChangeListener);
611: myTargetAxiModel
612: .removeComponentListener(myContextChangeListener);
613: }
614: // if (myTargetSchemaModel != null) {
615: // myTargetSchemaModel.removePropertyChangeListener(myContextChangeListener);
616: // }
617: }
618:
619: private void reinitContext() {
620: reinitContext(null);
621: }
622:
623: private void reinitContext(final EventObject evt) {
624: if (myPreviousChangeTask != null) {
625: myPreviousChangeTask.cancel();
626: }
627: if (myPreviousChangeTask != null
628: && !myPreviousChangeTask.isFinished()) {
629: myPreviousChangeTask.waitFinished();
630: myPreviousChangeTask = null;
631: }
632:
633: myPreviousChangeTask = RequestProcessor.getDefault().post(
634: new Runnable() {
635: public void run() {
636: // setActivatedNodes(curEditorPane.getCaret().getDot());
637: MapperContextFactory.getInstance()
638: .reinitMapperContext(
639: MapperContextImpl.this ,
640: myXslFo,
641: Util.getProject(myTMapFo), evt);
642: }
643: }, CONTEXT_CHANGE_TASK_DELAY);
644:
645: // MapperContextFactory.getInstance().reinitMapperContext(this, myXslFo, Util.getProject(myTMapFo));
646: }
647:
648: private class ContextPropertyChangeListener implements
649: PropertyChangeListener, ComponentListener {
650:
651: public void propertyChange(PropertyChangeEvent evt) {
652: //System.out.println("ContextPropertyChangeListener: source: "+evt.getSource()+"; propName: "+evt.getPropertyName());
653: reinitContext(evt);
654: }
655:
656: public void valueChanged(ComponentEvent arg0) {
657: reinitContext(arg0);
658: }
659:
660: public void childrenAdded(ComponentEvent arg0) {
661: reinitContext(arg0);
662: }
663:
664: public void childrenDeleted(ComponentEvent arg0) {
665: reinitContext(arg0);
666: }
667:
668: // private void attributeAdded(Object sourceObj, String property, Object oldValue) {
669: //System.out.println("attributeAdded: ContextPropertyChangeListener: source: "+sourceObj+"; propName: "+property);
670: // reinitContext();
671: //
672: // }
673: //
674: // private void attributeChanged(Object sourceObj, String property, Object oldValue, Object newValue) {
675: //System.out.println("attributeChanged: ContextPropertyChangeListener: source: "+sourceObj+"; propName: "+property);
676: // reinitContext();
677: //
678: // }
679: //
680: // private void attributeRemoved(Object sourceObj, String property, Object oldValue) {
681: //System.out.println("attributeRemoved: ContextPropertyChangeListener: source: "+sourceObj+"; propName: "+property);
682: // reinitContext();
683: // }
684: //
685: // private void childrenAdded(Object sourceObj, String property, Object oldValue) {
686: //System.out.println("childrenAdded: ContextPropertyChangeListener: source: "+sourceObj+"; propName: "+property);
687: // reinitContext();
688: // }
689: //
690: // private void childrenRemoved(Object sourceObj, String property, Object oldValue) {
691: //System.out.println("childrenRemoved: ContextPropertyChangeListener: source: "+sourceObj+"; propName: "+property);
692: // reinitContext();
693: // }
694: }
695:
696: // private class ComponentChangeListenerImpl implements ComponentListener {
697: //
698: // public void valueChanged(ComponentEvent evt) {
699: // Object changedValue = evt.getSource();
700: // System.out.println("value changed: "+changedValue);
701: // if (changedValue instanceof Part) {
702: // reinitContext();
703: // }
704: //
705: //// if (changedValue instanceof TMapComponent
706: //// && ((TMapComponent)changedValue).) {
707: //// }
708: //
709: //// throw new UnsupportedOperationException("Not supported yet.");
710: // }
711: //
712: // public void childrenAdded(ComponentEvent evt) {
713: // Object childrenAdded = evt.getSource();
714: // System.out.println("children added: "+childrenAdded);
715: // if ((mySourcePart == null || myTargetPart == null)
716: // && childrenAdded instanceof Part )
717: // {
718: // reinitContext();
719: // }
720: //
721: //// if (myTransformContextComponent == null && childrenAdded instanceof Operation) {
722: //// reinitContext();
723: //// } else if (myTransformContextComponent != null
724: //// && myTransformContextComponent.equals(childrenAdded)
725: //// && TMapComponents.PARAM.equals(((TMapComponent)childrenAdded).getComponentType()))
726: //// {
727: //// // todo m add new param into source
728: //// setSourceType(myTargetComponent);
729: ////// reinitContext();
730: //// }
731: ////// throw new UnsupportedOperationException("Not supported yet.");
732: // }
733: //
734: // public void childrenDeleted(ComponentEvent evt) {
735: // Object childrenDeleted = evt.getSource();
736: // System.out.println("children deleted: "+childrenDeleted);
737: //// if (myTransformContextComponent != null
738: //// && childrenDeleted instanceof Operation
739: //// && childrenDeleted.equals(myTransformContextComponent.getParent()))
740: //// {
741: //// reinitContext();
742: //// } else if (myTransformContextComponent != null
743: //// && myTransformContextComponent.equals(childrenDeleted))
744: //// {
745: //// // todo m deleted params
746: //// setSourceType(myTargetComponent);
747: //// }
748: //// throw new UnsupportedOperationException("Not supported yet.");
749: // }
750: // }
751:
752: private class FileChangeListenerImpl implements FileChangeListener {
753:
754: public void fileFolderCreated(FileEvent fe) {
755: // throw new UnsupportedOperationException("Not supported yet.");
756: }
757:
758: public void fileDataCreated(FileEvent fe) {
759: FileObject fo = fe.getFile();
760: if (fo != null
761: && myTMapFo == null
762: && fo
763: .equals(org.netbeans.modules.xslt.tmap.util.Util
764: .getTMapFo(Util.getProject(fo)))) {
765: reinitContext();
766: myTMapFo.addFileChangeListener(myFileChangeListener);
767: if (myTMapModel != null) {
768: myTMapModel
769: .addPropertyChangeListener(myContextChangeListener);
770: }
771: }
772: }
773:
774: public void fileChanged(FileEvent fe) {
775: }
776:
777: public void fileDeleted(FileEvent fe) {
778: FileObject fo = fe.getFile();
779: if (fo != null) {
780: fo.removeFileChangeListener(myFileChangeListener);
781: }
782: }
783:
784: public void fileRenamed(FileRenameEvent fe) {
785: FileObject fo = fe.getFile();
786:
787: // TODO m
788: if (fo.equals(myXslFo)) {
789: reinitContext();
790: }
791:
792: if (fo.equals(myTMapFo)) {
793: reinitContext();
794: }
795: }
796:
797: public void fileAttributeChanged(FileAttributeEvent fe) {
798: }
799: }
800:
801: private class ProjectsFilesChangeListenerImpl implements
802: ProjectsFilesChangeListener {
803:
804: public void fileAdded(FileObject fo) {
805: if (mySourceComponent == null || myTargetComponent == null) {
806: reinitContext();
807: }
808: }
809:
810: public void fileRenamed(FileRenameEvent fe) {
811: reinitContext();
812: }
813:
814: public void fileDeleted(FileObject fo) {
815: reinitContext();
816: }
817: }
818:
819: public String getValidationMessage() {
820: String result = null;
821:
822: TransformmapValidator validator = TransformmapValidatorImpl
823: .getInstance();
824: if (myXslFo != null) {
825: result = validator.validate(Util
826: .getTransformationDescriptor(Util
827: .getProject(myXslFo)));
828:
829: if (result == null) {
830: result = validator.validate(myTMapModel, myXslFo);
831: }
832:
833: if (result == null) {
834: AXIComponent typeIn = getSourceType();
835: result = validator.validate(typeIn, "source"); // NOI18N
836:
837: }
838:
839: if (result == null) {
840: AXIComponent typeOut = getTargetType();
841: result = validator.validate(typeOut, "target"); // NOI18N
842: }
843: }
844:
845: return result;
846: }
847: }
|