jextframe.java

java写的多功能文件编辑器

  private JextTextArea createTextArea()
  {
    JextTextArea textArea = new JextTextArea(this);
    new DropTarget(textArea.getPainter(), new DnDHandler());
    textArea.setDocument(new SyntaxDocument());
    loadTextArea(textArea);

    return textArea;
  }

  // internal use only: adds a text area in the tabbed pane
  // the area is added, then selected and finally an event
  // of kind TEXT_AREA_OPENED is fired

  private void addTextAreaInTabbedPane(JextTextArea textArea)
  {
    if (workspaces != null)
      workspaces.addFile(textArea);

    textAreasPane.add(textArea);
    fireJextEvent(textArea, JextEvent.TEXT_AREA_OPENED);
    textAreasPane.setSelectedComponent(textArea);
  }

// adds the specified ProjectManagement to the map...
  private void addProjectManagement(ProjectManagement projectMgmt)
  {
    projectMgmts = ((projectMgmts == null) ? new HashMap() : projectMgmts);
    projectMgmts.put(projectMgmt.getLabel(), projectMgmt);
  }//end addProjectManagement

  /**
   * Creates a new empty file.
   */

  public JextTextArea createFile()
  {
    JextTextArea textArea = createTextArea();
    addTextAreaInTabbedPane(textArea);
    return textArea;
  }

  /**
   * Change the name of specified text area.
   * @param textArea The area which name is to be changed
   * @param name The new title which will appear on the tab
   */

  public void setTextAreaName(JextTextArea textArea, String name)
  {
    textAreasPane.setTitleAt(textAreasPane.indexOfComponent(textArea), name);
  }

  /**
   * Updates splitted text area to make it edit the same thing as the
   * selected text area.
   * @param textArea The text area which has to be linked with
   */

  public void updateSplittedTextArea(JextTextArea textArea)
  {
    if (textAreaSplitter.getBottomComponent() == null || textArea == null)
      return;

    splittedTextArea.setDocument(textArea.getDocument());
    String mode = textArea.getColorizingMode();
    if (!mode.equals(splittedTextArea.getColorizingMode()))
      splittedTextArea.setColorizing(mode);
    splittedTextArea.discard();
    splittedTextArea.setEditable(textArea.isEditable());
    setLineTerm(textArea);
  }

  /**
   * If user selects a tab containing something different from a text area,
   * we disable 'splitted' one.
   */

  public void disableSplittedTextArea()
  {
    if (textAreaSplitter.getBottomComponent() == null)
      return;

    splittedTextArea.setDocument(new SyntaxDocument());
    splittedTextArea.setEditable(false);
  }

  /*friendly*/ void setLineTerm(JextTextArea jta) {
    setLineTerm(jta, jta.lineTermSelector.getSelectedIndex());
  }

  /** This method makes the two textareas show the same lineTerm in their ComboBoxes.
   * Needs to be called only when using one combobox to change the line end.
   */
  /*friendly*/ void setLineTerm(JextTextArea jta, int value) {
    JextTextArea toUpdate = null;
    if (splittedTextArea == null)
      return;
    if (jta == splittedTextArea) {
      toUpdate = getNSTextArea();
    } else if (jta == getNSTextArea()) {
      toUpdate = splittedTextArea;
    } else {
      return;
    }
    toUpdate.lineTermSelector.setSelectedIndex(value);
  }

  //////////////////////////////////////////////////////////////////////////////////////////////
  // THE GUI
  //////////////////////////////////////////////////////////////////////////////////////////////

  /**
   * Create a new GUI.
   */

  public JextFrame()
  {
    this(null, true);
  }

  /**
   * Create a new GUI.
   * @param args Arguments (to open a file directly)
   */

  public JextFrame(String args[])
  {
    this(args, true);
  }

  JextFrame(String args[], boolean toShow)
  {
    super("Jext - Java Text Editor");
    getContentPane().setLayout(new BorderLayout());

    Jext.setSplashProgress(10);
    Jext.setSplashText(Jext.getProperty("startup.gui"));

    defaultProjectMgmt = new DefaultProjectManagement(this);
    addProjectManagement(defaultProjectMgmt);
    registerPlugins();
    setIconImage(GUIUtilities.getJextIconImage());
    XMenuReader.read(this, Jext.class.getResourceAsStream("jext.menu.xml"), "jext.menu.xml");
    getJMenuBar().putClientProperty(Options.HEADER_STYLE_KEY, HeaderStyle.BOTH);

    inputHandler = new DefaultInputHandler(Jext.getInputHandler());

    Jext.setSplashProgress(20);
    Jext.setSplashText(Jext.getProperty("startup.toolbar.build"));
    XBarReader.read(this, Jext.class.getResourceAsStream("jext.toolbar.xml"), "jext.toolbar.xml");

    // create the text areas pane
    splittedTextArea = createTextArea();
    textAreasPane = new JextTabbedPane(this);
    textAreasPane.putClientProperty(Options.EMBEDDED_TABS_KEY, Boolean.TRUE);
    textAreasPane.putClientProperty(Options.NO_CONTENT_BORDER_KEY, Boolean.TRUE);

    Jext.setSplashProgress(30);
    Jext.setSplashText(Jext.getProperty("startup.files"));

    workspaces = new Workspaces(this);
    workspaces.load();

    textAreaSplitter.setContinuousLayout(true);
    textAreaSplitter.setTopComponent(textAreasPane);
    textAreaSplitter.setBottomComponent(splittedTextArea);
    textAreaSplitter.setBorder(null);
    // textAreaSplitter.setResizeWeight(1.0);

    Jext.setSplashProgress(50);
    Jext.setSplashText(Jext.getProperty("startup.xinsert"));

    Jext.setSplashText(Jext.getProperty("startup.xinsert.build"));

    rightFrame = new SimpleInternalFrame(null, null, textAreaSplitter);

    vTabbedPane = new JTabbedPane(JTabbedPane.BOTTOM);
    vTabbedPane.putClientProperty(Options.EMBEDDED_TABS_KEY, Boolean.TRUE);
    vTabbedPane.putClientProperty(Options.NO_CONTENT_BORDER_KEY, Boolean.TRUE);
    GUIUtilities.setScrollableTabbedPane(vTabbedPane);
    virtualFolders = new VirtualFolders(this);
    selectProjectManagement(Jext.getProperty("projectManagement.current",
     defaultProjectMgmt.getLabel()));
//    vTabbedPane.add(Jext.getProperty("vTabbedPane.project"), new ProjectPanel(this));

    if (Jext.getBooleanProperty("xtree.enabled"))
    {
      xtree = new XTree(this, "jext.insert.xml");
      vTabbedPane.add(Jext.getProperty("vTabbedPane.xinsert"), xtree);
    }
    //if (vTabbedPane.getTabCount() == 0)
    //  Jext.setProperty("leftPanel.show", "off");
    leftFrame = new SimpleInternalFrame("Tools");
    leftFrame.setContent(vTabbedPane);

    split = Factory.createStrippedSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftFrame, rightFrame, 0.00f);
    split.setContinuousLayout(true);
    _dividerSize = split.getDividerSize();

    Jext.setSplashProgress(60);

    hTabbedPane = new JTabbedPane(JTabbedPane.BOTTOM);
    hTabbedPane.putClientProperty(Options.EMBEDDED_TABS_KEY, Boolean.TRUE);
    hTabbedPane.putClientProperty(Options.NO_CONTENT_BORDER_KEY, Boolean.TRUE);
    GUIUtilities.setScrollableTabbedPane(hTabbedPane);
    if (Jext.getBooleanProperty("console.enabled"))
    {
      // creates console
      console = new Console(this);
      console.setPromptPattern(Jext.getProperty("console.prompt"));
      console.displayPrompt();

      hTabbedPane.add(Jext.getProperty("hTabbedPane.console"), console);
      hTabbedPane.setPreferredSize(console.getPreferredSize());
    }

    consolesFrame = new SimpleInternalFrame("Consoles");
    consolesFrame.setContent(hTabbedPane);
    splitter = Factory.createStrippedSplitPane(JSplitPane.VERTICAL_SPLIT, consolesFrame, split, 0.00f);
    splitter.setContinuousLayout(true);

    centerPane = new JPanel(new BorderLayout());
    centerPane.add(BorderLayout.CENTER, splitter);

    Jext.setSplashProgress(70);
    Jext.setSplashText(Jext.getProperty("startup.gui"));
    status.addMouseListener(new MouseAdapter() {
      public void mouseClicked(MouseEvent me) {
        //TODO: check if getNSTextArea() is the right thing.
        JextTextArea jta = getNSTextArea(), jtaSplitted = getTextArea();
        jta.rotateLineTerm();
        if (jtaSplitted != jta)
          jtaSplitted.rotateLineTerm();
        updateStatus(jta);//for the left status bar message
        //about isDirty: the JextFrame.setChanged/setSaved assume if the dirty flag
        //is in the wrong state(false for setChanged/true for setSaved), then the GUI hasn't been updated.
        //This is false here-rotateLineTerm changes actually the dirty flag but doesn't update the GUI.
        if (jta.isDirty())
          textAreasPane.setDirtyIcon(jta);
        else
          textAreasPane.setCleanIcon(jta);
        setStatus(jta);//for the right status bar message
      }
    });

    // we finally add the labels, used to display informations, and the toolbar
    JPanel pane = new JPanel(new BorderLayout());
    pane.add(BorderLayout.WEST, status);
    pane.add(BorderLayout.EAST, message);
    centerPane.add(BorderLayout.SOUTH, pane);
    centerPane.setBorder(new EmptyBorder(6, 0, 0, 0));
    getContentPane().add(BorderLayout.CENTER, centerPane);
    getContentPane().add(BorderLayout.NORTH, toolBar);

    // we load the user geometry
    Jext.setSplashProgress(80);
    Jext.setSplashText(Jext.getProperty("startup.props"));

    pack();
    GUIUtilities.loadGeometry(this, "jext");
    loadProperties(false);

    // here is the window listener which call exit on window closing
    addWindowListener(new WindowHandler());

    Jext.setSplashProgress(90);
    Jext.setSplashText(Jext.getProperty("startup.files"));

    if (args != null)
    {
      workspaces.selectWorkspaceOfNameOrCreate(Jext.getProperty("ws.default"));
      setBatchMode(true);

      for (int i = 0; i < args.length; i++)
      {
        if (args[i] != null)
          open(Utilities.constructPath(args[i]));
      }

      setBatchMode(false);
    }

    updateSplittedTextArea(getTextArea());
    Jext.setSplashProgress(95);
    Jext.setSplashText(Jext.getProperty("startup.plugins"));

    Jext.executeScripts(this);
    JARClassLoader.executeScripts(this);
    updatePluginsMenu();
    toolBar.addMisc(this);
    triggerTabbedPanes();

    Jext.setSplashProgress(100);

    setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
    addJextListener(new PluginHandler());
    addJextListener(new ModeHandler());
    // we notify listeners that a new Jext window is opened
    fireJextEvent(JextEvent.OPENING_WINDOW);

    getTextArea().setParentTitle();

    Jext.killSplashScreen();
    setVisible(toShow);

    getTextArea().grabFocus();
    getTextArea().requestFocus();
  }

  /**
   * Returns the input handler.
   */

  public final InputHandler getInputHandler()
  {
    return inputHandler;
  }

  /**
   * Sets the input handler.
   * @param inputHandler The new input handler
   */

  public void setInputHandler(InputHandler inputHandler)
  {
    this.inputHandler = inputHandler;
  }

  /**
   * Forwards key events directly to the input handler.
   * This is slightly faster than using a KeyListener
   * because some Swing overhead is avoided.
   */

  public void processKeyEvent(KeyEvent evt)
  {
    if (getFocusOwner() instanceof JComponent)
    {
      JComponent comp = (JComponent) getFocusOwner();
      InputMap map = comp.getInputMap();
      ActionMap am = comp.getActionMap();

      if (map != null && am != null && comp.isEnabled())
      {
        Object binding = map.get(KeyStroke.getKeyStrokeForEvent(evt));
        if (binding != null && am.get(binding) != null)
          return;
      }
    }

    if (getFocusOwner() instanceof JTextComponent)
    {
      if (evt.getID() == KeyEvent.KEY_PRESSED)
      {
        switch (evt.getKeyCode())
        {
          case KeyEvent.VK_BACK_SPACE:
          case KeyEvent.VK_TAB:
          case KeyEvent.VK_ENTER:
            return;
        }
      }

      Keymap keymap = ((JTextComponent) getFocusOwner()).getKeymap();
      if (keymap.getAction(KeyStroke.getKeyStrokeForEvent(evt)) != null)
        return;
    }

    if (evt.isConsumed())
      return;

    evt = KeyEventWorkaround.processKeyEvent(evt);
    if (evt == null)
      return;

    switch (evt.getID())
    {
      case KeyEvent.KEY_TYPED:
        // Handled in text area
        if (keyEventInterceptor != null)
          keyEventInterceptor.keyTyped(evt);
        else if (inputHandler.isRepeatEnabled())
          inputHandler.keyTyped(evt);
        break;
      case KeyEvent.KEY_PRESSED:
        if (keyEventInterceptor != null)
          keyEventInterceptor.keyPressed(evt);
        else
          inputHandler.keyPressed(evt);
        break;
      case KeyEvent.KEY_RELEASED:
        if (keyEventInterceptor != null)
          keyEventInterceptor.keyReleased(evt);
        else
          inputHandler.keyReleased(evt);
        break;
    }

    if (!evt.isConsumed())
      super.processKeyEvent(evt); 
  }

  //////////////////////////////////////////////////////////////////////////////////////////////
  // INTERNAL CLASSES
  //////////////////////////////////////////////////////////////////////////////////////////////

  class WindowHandler extends WindowAdapter
  {
    public void windowClosing(WindowEvent evt)
    {
      Jext.closeToQuit(JextFrame.this);
    }
  }

  class PluginHandler implements JextListener
  {
    public void jextEventFired(JextEvent evt)
    {
      int what = evt.getWhat();

      if (what == JextEvent.SYNTAX_MODE_CHANGED || what == JextEvent.TEXT_AREA_SELECTED ||
          what == JextEvent.OPENING_WINDOW)
      {
        reset();
        String modeName = evt.getTextArea().getColorizingMode();
        Mode mode = Jext.getMode(modeName);
        ArrayList plugins_ = mode.getPlugins();

        for (int i = 0; i < plugins_.size(); i++)
        {
          Plugin plugin = (Plugin) plugins_.get(i);
          if (plugin != null)
          {
            Vector pluginsMenus = new Vector();
            Vector pluginsMenuItems = new Vector();
            try
            {
              plugin.createMenuItems(JextFrame.this, pluginsMenus, pluginsMenuItems);
            } catch (Throwable t) {
              System.err.println("#--Exception while constructing menu items:");
              t.printStackTrace();
            }
          }
        }
      }
    }
  }

  class ModeHandler implements JextListener
  {
    public void jextEventFired(JextEvent evt)
    {
      if (evt.getWhat() == JextEvent.PROPERTIES_CHANGED)
      {
        for (int i = 0; i < Jext.modesFileFilters.size(); i++)
        {
          ((ModeFileFilter) Jext.modesFileFilters.get(i)).rebuildRegexp();
        }
      }
    }
  }

  class DnDHandler implements DropTargetListener
  {
    public void dragEnter(DropTargetDragEvent evt) { }
    public void dragOver(DropTargetDragEvent evt) { }
    public void dragExit(DropTargetEvent evt) { }
    public void dragScroll(DropTargetDragEvent evt) { }
    public void dropActionChanged(DropTargetDragEvent evt) { }

    public void drop(DropTargetDropEvent evt)
    {
      DataFlavor[] flavors = evt.getCurrentDataFlavors();
      if (flavors == null)
        return;

      boolean dropCompleted = false;
      for (int i = flavors.length - 1; i >= 0; i--)
      {
        if (flavors[i].isFlavorJavaFileListType())
        {
          evt.acceptDrop(DnDConstants.ACTION_COPY);
          Transferable transferable = evt.getTransferable();
          try
          {
            final Iterator iterator = ((List) transferable.getTransferData(flavors[i])).iterator();

            // what a fix !!!!! (JDK 1.4, JVM hanging on drag and drop if file was already opened)
            SwingUtilities.invokeLater(new Runnable()
            {
              public void run()
              {
                while (iterator.hasNext())
                  open(((File) iterator.next()).getPath());
              }
            });

            dropCompleted = true;

          } catch (Exception e) { }
        }
      }
      evt.dropComplete(dropCompleted);
    }
  }


}

// End of JextFrame.java