jawecontroller.java

来自「jawe的最新版本,基于Java的图形化工作流编辑器。图形化工作流编辑器 。使用」· Java 代码 · 共 1,644 行 · 第 1/5 页

         xpdlId = mainPackage.getId();
      }
      JaWEManager.getInstance()
         .getLoggingManager()
         .info("JaWEController -> closing package " + xpdlId);
      if (mainPackage != null && mainPackage.getId().equals(xpdlId)) {
         String filePath = JaWEManager.getInstance()
            .getXPDLHandler()
            .getAbsoluteFilePath(mainPackage);
         List allPackages = new ArrayList(xpdlhandler.getAllPackages());
         List notToClose = new ArrayList();
         for (int i = 0; i < allPackages.size(); i++) {
            Package pkg = (Package) allPackages.get(i);
            if (!pkg.isTransient() || closeTransient) {
               xpdlhandler.closePackageVersion(pkg.getId(), pkg.getInternalVersion());
            } else {
               notToClose.add(pkg);
            }
         }
         allPackages.removeAll(notToClose);
         setChanged();
         XPDLElementChangeInfo info = createInfo(mainPackage,
                                                 allPackages,
                                                 XMLElementChangeInfo.REMOVED);
         info.setOldValue(filePath);
         notifyObservers(info);
         clearXPDLListenerObservables(closeTransient);
      }
      JaWEManager.getInstance().getLoggingManager().info("JaWEController -> package "
                                                         + xpdlId + " closed");
      // xpdlhandler.printDebug();
      updateTitle();
      frame.repaint();
      adjustActions();
      System.gc();
   }

   public boolean isSaveEnabled(boolean isSaveAs) {
      if (getMainPackageId() != null) {
         if (isSaveAs)
            return true;

         return isPackageModified(getMainPackageId());
      }

      return false;
   }

   public void savePackage(String xpdlId, String filename) {
      XPDLHandler xpdlhandler = JaWEManager.getInstance().getXPDLHandler();
      Package pkg = xpdlhandler.getPackageById(xpdlId);
      String oldFilename = xpdlhandler.getAbsoluteFilePath(pkg);
      try {

         // if SaveAs was performed and the document was previously saved,
         // change ExternalPackage's relative paths
         boolean isNewFile = !filename.equals(oldFilename);
         if (oldFilename != null && isNewFile) {
            boolean crossRefs = JaWEManager.getInstance()
               .getXPDLUtils()
               .doesCrossreferenceExist(pkg);
            int r = JOptionPane.YES_OPTION;
            if (crossRefs) {
               r = JOptionPane.showConfirmDialog(getJaWEFrame(),
                                                 settings.getLanguageDependentString("MessageCrossReferenceExistDoYouWantToProceed"),
                                                 getJaWEFrame().getAppTitle(),
                                                 JOptionPane.YES_NO_OPTION);
            }
            if (r == JOptionPane.YES_OPTION) {
               updateExternalPackagesRelativePaths(pkg, filename);
            } else {
               // JaWEManager.getInstance().getJaWEController().setFilename(null);
               return;
            }
         }

         Document document = null;

         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
         DocumentBuilder dbuilder = dbf.newDocumentBuilder();
         document = dbuilder.newDocument();

         // retrieve the file writter
         RandomAccessFile raf = xpdlhandler.getRaf(pkg);

         // output stream will either be the FileOutputStream in the
         // case of save as, or the ByteArrayOutputStream if we are
         // saving an existing file
         OutputStream os;
         if (isNewFile) {
            // try to open random access file as rw, if it fails
            // the saving shouldn't occur
            try {
               File f = new File(filename);
               RandomAccessFile r = new RandomAccessFile(f, "rw");
               FileLock flck = r.getChannel().tryLock();
               flck.release();
               r.close(); // Harald Meister
               // this exception happens when using jdk1.4 under Linux
               // if it happens, just catch it and proceed with saving
               // because Linux with jdk1.4.0 doesn't support locking
            } catch (IOException ioe) {
               // ioe.printStackTrace();
               // this happens when the locking fails, and null is returned,
               // and after that release method is called on the null;
               // This means that the file we want to save the given
               // package as, is already locked, so we do not allow saving
            } catch (NullPointerException npe) {
               // npe.printStackTrace();
               throw new Exception();
            }
            // if we are at this point, this means either the locking
            // succeeded, or we use jdk1.4 under Linux that does not
            // support locking
            os = new FileOutputStream(filename);
         } else {
            os = new ByteArrayOutputStream();
         }

         // Here we get all document elements set
         JaWEManager.getInstance()
            .getXPDLHandler()
            .getXPDLRepositoryHandler()
            .toXML(document, pkg);

         // Use a Transformer for output
         TransformerFactory tFactory = TransformerFactory.newInstance();
         Transformer transformer = tFactory.newTransformer();
         transformer.setOutputProperty("indent", "yes");
         transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
         transformer.setOutputProperty("encoding", settings.getEncoding());
         DOMSource source = new DOMSource(document);
         StreamResult result = new StreamResult(os);
         transformer.transform(source, result);

         if (!isNewFile && raf != null && os instanceof ByteArrayOutputStream) {
            if (raf != null) {
               // must go to the beginning - otherwise, it will not
               // truncate the file correctly in some Java-OS combination
               raf.seek(0);
               raf.getChannel().truncate(0);
               raf.write(((ByteArrayOutputStream) os).toByteArray());
            }
         }

         os.close();

         XPDLListenerAndObservable xpdl = getXPDLListenerObservable(pkg);
         if (xpdl != null) {
            xpdl.setModified(false);
         }

         if (isNewFile) {
            xpdlhandler.registerPackageFilename(filename, pkg);
         }
         try {
            System.setProperty("user.dir", xpdlhandler.getParentDirectory(pkg));
         } catch (Exception ex) {
            ex.printStackTrace();
         }

         // try {
         // JaWE.getInstance().addToRecentFiles(filename);
         // } catch (Exception ex) {}
      } catch (NonWritableChannelException nwcex) {
         nwcex.printStackTrace();
         getJaWEFrame().message(settings.getLanguageDependentString("ErrorCannotSaveReadOnlyFile"),
                                JOptionPane.ERROR_MESSAGE);
      } catch (Exception ex) {
         ex.printStackTrace();
         getJaWEFrame().message(settings.getLanguageDependentString("ErrorCannotSaveDocument"),
                                JOptionPane.ERROR_MESSAGE);
         // ex.printStackTrace();
      }
      // xpdlhandler.printDebug();
      // XPDLElementChangeInfo info = createInfo(pkg, XPDLElementChangeInfo.SELECTED);
      // sendEvent(info);
      updateTitle();
      adjustActions();
   }

   /*
    * Method for closing document. Returns true if the user really wants to close. Gives
    * chance to save work.
    */
   public boolean tryToClosePackage(String xpdlId, boolean closeTransient) {
      if (xpdlId == null)
         xpdlId = getMainPackageId();
      if (xpdlId == null)
         return true;
      int r = JOptionPane.NO_OPTION;
      boolean modified = isPackageModified(xpdlId);
      String filename = getPackageFilename(xpdlId);
      if (modified || filename == null) {
         r = JOptionPane.showConfirmDialog(getJaWEFrame(),
                                           settings.getLanguageDependentString("DialogSaveChanges"),
                                           getJaWEFrame().getAppTitle(),
                                           JOptionPane.YES_NO_CANCEL_OPTION);
      }
      if (r == JOptionPane.YES_OPTION) {
         String dialogTitle = settings.getLanguageDependentString("Save"
                                                                  + BarFactory.LABEL_POSTFIX);
         if (filename == null) {
            dialogTitle = settings.getLanguageDependentString("SaveAs"
                                                              + BarFactory.LABEL_POSTFIX);
         }

         if (filename == null) {
            filename = getJaWEFrame().saveDialog(dialogTitle, 0, xpdlId);
         }

         savePackage(xpdlId, filename);
         if (isPackageModified(xpdlId)) {
            r = JOptionPane.CANCEL_OPTION;
         }
      }
      if (r == JOptionPane.CANCEL_OPTION) {
         // getWindow().dispose();
         return false;
      }
      closePackage(xpdlId, closeTransient);
      return true;
   }

   protected XPDLListenerAndObservable createNewXPDLListenerObservable(Package pkg,
                                                                       boolean receiveEvents,
                                                                       boolean modified) {
      XPDLListenerAndObservable xpdl = new XPDLListenerAndObservable(pkg, receiveEvents);
      xpdl.setModified(modified);
      xpdlListenerObservables.add(xpdl);
      xpdl.addObserver(this);
      return xpdl;
   }

   protected XPDLListenerAndObservable getXPDLListenerObservable(Package pkg) {
      Iterator it = xpdlListenerObservables.iterator();
      while (it.hasNext()) {
         XPDLListenerAndObservable xpdl = (XPDLListenerAndObservable) it.next();
         if (xpdl.getPackage() == pkg) {
            return xpdl;
         }
      }
      return null;
   }

   protected XPDLListenerAndObservable getWorkingXPDLListenerObservable() {
      Iterator it = xpdlListenerObservables.iterator();
      while (it.hasNext()) {
         XPDLListenerAndObservable xpdl = (XPDLListenerAndObservable) it.next();
         if (xpdl.getPackage() == selectionMng.getWorkingPKG()) {
            return xpdl;
         }
      }
      return null;
   }

   protected void changePackageId(Package pkg, String oldId, String newId) {
      XPDLHandler xpdlhandler = JaWEManager.getInstance().getXPDLHandler();
      xpdlhandler.changePackageId(pkg, oldId, newId);
   }

   protected void updateExternalPackagesRelativePaths(Package pkg, String newFilename) {
      XPDLHandler xpdlhandler = JaWEManager.getInstance().getXPDLHandler();
      File f = new File(newFilename);
      String parentF = f.getParent();
      Path newPath = new Path(parentF);

      Iterator eps = pkg.getExternalPackages().toElements().iterator();
      while (eps.hasNext()) {
         ExternalPackage ep = (ExternalPackage) eps.next();
         String oldRelativePath = ep.getHref();
         try {
            Package extP = xpdlhandler.getExternalPackageByRelativeFilePath(oldRelativePath,
                                                                            pkg);
            String oldFullPath = xpdlhandler.getAbsoluteFilePath(extP);
            String relativePath = Path.getRelativePath(new Path(oldFullPath), newPath);
            // System.out.println("RP="+relativePath);
            ep.setHref(XMLUtil.replaceBackslashesWithSlashes(relativePath));
         } catch (Exception ex) {
            System.err.println("Failed to update old external package's relative path "
                               + oldRelativePath + " for main package " + pkg.getId()
                               + " with a new filename " + newFilename);
            // ex.printStackTrace();
         }
      }
   }

   // ////////////////////////// END Of XPDL File Handling /////////////////////

   public XPDLElementChangeInfo createInfo(XMLElement el, int action) {
      XPDLElementChangeInfo info = new XPDLElementChangeInfo();
      info.setChangedElement(el);
      info.setAction(action);
      info.setSource(this);
      return info;
   }

   public XPDLElementChangeInfo createInfo(XMLElement main, List elements, int action) {
      XPDLElementChangeInfo info = new XPDLElementChangeInfo();
      info.setChangedElement(main);
      info.setChangedSubElements(elements);
      info.setAction(action);
      info.setSource(this);
      return info;
   }

   public boolean canCreateElement(XMLCollection col, boolean checkReadOnly) {
      if (checkReadOnly && col.isReadOnly()) {
         return false;
      }
      if (col instanceof TransitionRestrictions
          || col instanceof TransitionRefs || col instanceof ExternalPackages) {
         return false;
      }

      if (col instanceof Responsibles) {
         Map m = JaWEManager.getInstance()
            .getXPDLUtils()
            .getPossibleResponsibles((Responsibles) col, null);
         if (m.size() == 0) {
            return false;
         }
      }

      if (col instanceof Tools) {
         Map m = XMLUtil.getPossibleApplications(XMLUtil.getWorkflowProcess(col),
                                                 JaWEManager.getInstance()