jfreereportdesigner.java

报表设计软件,很好的

    globalActions.put(SAVE_AS_ACTION_KEY, new SaveAsReportAction());
    globalActions.put(SAVE_ACTION_KEY, new SaveReportAction());

    reopenAction = new ReopenReportAction();
  }

  public final int getSelectedEditor ()
  {
    return selectedRootEditor;
  }

  public final void setSelectedEditor (final int selectedEditor)
  {
    final int oldEditor = this.selectedRootEditor;
    if (oldEditor == selectedEditor)
    {
      // no change - so nothing to do!
      return;
    }
    this.selectedRootEditor = selectedEditor;
    // make sure that only the selected editor is active.
    // all other editors will be disabled, if needed and
    // not touched if they are already in the correct state

    for (int i = 0; i < rootEditors.length; i++)
    {
      final boolean shouldBeActive = (i == selectedEditor);
      final RootEditorContainer container = rootEditors[i];
      if (container.getEditor().isActive() &&
              (shouldBeActive == false))
      {
        container.getEditor().setActive(false);
      }
    }

    if (currentToolbar != null)
    {
      closeToolbar();
      toolbarContainer.removeAll();
      currentToolbar = null;
    }

    for (int i = 0; i < rootEditors.length; i++)
    {
      final boolean shouldBeActive = (i == selectedEditor);
      final RootEditorContainer container = rootEditors[i];
      if ((container.getEditor().isActive() == false) &&
              (shouldBeActive == true))
      {
        container.getEditor().setActive(true);
        setJMenuBar(container.getEditorMenuBar());
        currentToolbar = container.getEditorToolbar();
        if (currentToolbar != null)
        {
          toolbarContainer.add
                  (currentToolbar, BorderLayout.CENTER);
          currentToolbar.setVisible(true);
        }
      }
    }
  }

  private void closeToolbar ()
  {
    if (currentToolbar != null)
    {
      if (currentToolbar.getParent() != toolbarContainer)
      {
        // ha!, the toolbar is floating ...
        // Log.debug (currentToolbar.getParent());
        final Window w = SwingUtilities.windowForComponent(currentToolbar);
        if (w != null)
        {
          w.setVisible(false);
          w.dispose();
        }
      }
      currentToolbar.setVisible(false);
    }
  }

  private JMenu createFileMenu ()
  {
    menuReopen = new JMenu(resources.getString("designer.menu.File.Reopen"));
    menuReopen.setIcon(ImageUtils.createTransparentIcon(16, 16));
    menuReopen.setEnabled(false);

    reopenAction.setEnabled(false);

    final JMenu mFile = new JMenu(resources.getString("designer.menu.File"));
    mFile.setMnemonic(KeyEvent.VK_F);
    mFile.add(new NewReportAction());
    mFile.add(new OpenReportAction());
    mFile.add(reopenAction);
    mFile.add(new SaveReportAction());
    mFile.add(new SaveAsReportAction());
    mFile.addSeparator();
    mFile.add(new DatabaseAction());
    mFile.add(new PreferencesAction());
    mFile.addSeparator();
    mFile.add(menuReopen);
    mFile.addSeparator();
    mFile.add(new ExitAction());

    loadFilesForReopen();

    return mFile;
  }

  private JMenu createHelpMenu ()
  {
    final JMenu mHelp = new JMenu(resources.getString("designer.menu.Help"));
    mHelp.setMnemonic(KeyEvent.VK_H);
    mHelp.add(new AboutAction());
    return mHelp;
  }

  private JMenuBar createCustomMenu (final JMenu[] customMenus)
  {
    final JMenuBar menuBar = new JMenuBar();
    menuBar.add(createFileMenu());
    for (int i = 0; i < customMenus.length; i++)
    {
      menuBar.add(customMenus[i]);
    }
    menuBar.add(createHelpMenu());
    return menuBar;
  }

  private RootEditorContainer createPreviewEditor ()
  {
    final RootEditor ed = new VisualEditPanel(reportDefinitionManager);
    final JMenuBar menuBar = createCustomMenu(ed.getEditorMenus());
    return new RootEditorContainer(ed, menuBar);
  }

  private RootEditorContainer createXmlEditor ()
  {
    final RootEditor ed = new TextEditPanel(reportDefinitionManager);
    final JMenuBar menuBar = createCustomMenu(ed.getEditorMenus());
    return new RootEditorContainer(ed, menuBar);
  }

  private RootEditorContainer createDataEditor ()
  {
    final RootEditor ed = new DataPanel(reportDefinitionManager);
    final JMenuBar menuBar = createCustomMenu(ed.getEditorMenus());
    return new RootEditorContainer(ed, menuBar);
  }

  private void initialize ()
  {
    toolbarContainer = new JPanel();
    toolbarContainer.setLayout(new BorderLayout());

    rootEditors = new RootEditorContainer[3];
    rootEditors[0] = createXmlEditor();
    rootEditors[1] = createPreviewEditor();
    rootEditors[2] = createDataEditor();

    tabbedPane = new JTabbedPane(JTabbedPane.BOTTOM);
    tabbedPane.addChangeListener(new TabChangeHandler(tabbedPane));

    for (int i = 0; i < rootEditors.length; i++)
    {
      final String name = rootEditors[i].getEditor().getEditorName();
      final Component c = rootEditors[i].getEditor().getEditorComponent();
      tabbedPane.add(name, c);
    }

    getContentPane().setLayout(new BorderLayout());
    getContentPane().add(toolbarContainer, BorderLayout.NORTH);
    getContentPane().add(tabbedPane, BorderLayout.CENTER);
  }

  public static void main (final String[] args)
  {
    try
    {
      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    }
    catch (Exception e)
    {
    }

    Boot.start();
    PropertyEditorManager.registerEditor(Boolean.class, BooleanPropertyEditor.class);
    final JFreeReportDesigner reportDesigner = new JFreeReportDesigner();

    try
    {
      final Configuration config =
              reportDesigner.reportDefinitionManager.getEditorConfiguration();
      final int left = Integer.parseInt
              (config.getConfigProperty("window.left", "100"));
      final int top = Integer.parseInt
              (config.getConfigProperty("window.top", "100"));
      final int width = Integer.parseInt
              (config.getConfigProperty("window.width", "700"));
      final int height = Integer.parseInt
              (config.getConfigProperty("window.height", "500"));
      reportDesigner.setBounds(left, top, width, height);
    }
    catch (Exception ex)
    {
      Log.debug("invalid debug", ex);
    }

    RefineryUtilities.centerFrameOnScreen(reportDesigner);
    reportDesigner.setVisible(true);
  }

  private void windowExit ()
  {
    final DefaultConfiguration config =
            reportDefinitionManager.getEditorConfiguration();
    config.setProperty
            ("window.left", String.valueOf(getX()));
    config.setProperty
            ("window.top", String.valueOf(getY()));
    config.setProperty
            ("window.width", String.valueOf(getWidth()));
    config.setProperty
            ("window.height", String.valueOf(getHeight()));
    reportDefinitionManager.storeConfiguration();
    System.exit(0);
  }

  public final void setWaitCursor ()
  {
    setCursor(new Cursor(Cursor.WAIT_CURSOR));
  }

  public final void setDefaultCursor ()
  {
    setCursor(Cursor.getDefaultCursor());
  }

  // aus dem Editor hierher 黚ernommen
  private boolean saveReport ()
  {
    final int selectedEditor = getSelectedEditor();
    setSelectedEditor(-1);
    if (currentFile == null)
    {
      fileChooser.showSaveDialog(this);
      final File file = fileChooser.getSelectedFile();
      if (file == null)
      {
        return false;
      }

      currentFile = file;
      //JFreeReportDesigner.setFile(file.toString());
    }

    try
    {
      final String xml = reportDefinitionManager.getReportDefinitionText();
      final BufferedWriter bw = new BufferedWriter(new FileWriter(currentFile));
      bw.write(xml);
      bw.flush();
      bw.close();
      return true;
    }
    catch (Exception ex)
    {
      JFreeReportDesigner.showMessageDialog(ex.toString(),
              JOptionPane.ERROR_MESSAGE);
      return false;
    }
    finally
    {
      setSelectedEditor(selectedEditor);
    }
  }

  private void loadReport (final File file)
  {
    if (file != null)
    {
      try
      {
        final FileReader fr = new FileReader(file);
        final BufferedReader br = new BufferedReader(fr);
        final StringBuffer sb = new StringBuffer();
        String line;

        while ((line = br.readLine()) != null)
        {
          sb.append(line + "\n");
        }
        fr.close();

        final int selectedEditor = getSelectedEditor();
        setSelectedEditor(-1);
        reportDefinitionManager.setReportDefinitionText(sb.toString());
        reportDefinitionManager.setReportData(null);
        setSelectedEditor(selectedEditor);
        setCurrentFile(file);
        addFileForReopen(file.toString());
      }
      catch (Exception ex)
      {
        ex.printStackTrace();
        JFreeReportDesigner.showMessageDialog(ex.toString(),
                JOptionPane.ERROR_MESSAGE);
      }
    }
  }

  private void addFileForReopen (final String fileName)
  {
    if (fileName == null)
    {
      throw new NullPointerException("FileName must not be null.");
    }
    // for now only check to see if opening same file
    if ((fileNames.isEmpty() == false) && (fileNames.get(0).equals(fileName)))
    {
      return;
    }

    // if file is already in list, then move it to the front
    if (fileNames.contains(fileName))
    {
      fileNames.remove(fileName);
    }
    // move all files down one position .. the last file is discarded
    fileNames.add(0, fileName);
    // if there are too much files now, remove the last one ...
    if (fileNames.size() > MAX_RECENT_FILES)
    {
      fileNames.remove(fileNames.size() - 1);
    }
    saveFilesForReopen();
  }

  private void loadFilesForReopen ()
  {
    for (int i = 0; i < MAX_RECENT_FILES; i++)
    {
      final String newFile =
              reportDefinitionManager.getEditorConfiguration().getProperty("file." + i);
      if (newFile != null)
      {
        fileNames.add(newFile);
      }
    }

    rebuildRecentFilesMenu();
  }

  private void saveFilesForReopen ()
  {
    for (int i = 0; i < fileNames.size(); i++)
    {
      if (fileNames.get(i) != null)
      {
        reportDefinitionManager.getEditorConfiguration().setProperty
                ("file." + i, String.valueOf(fileNames.get(i)));
      }
    }
    rebuildRecentFilesMenu();
  }

  private void rebuildRecentFilesMenu ()
  {
    menuReopen.removeAll();
    if (fileNames.size() > 0)
    {
      for (int i = 0; i < fileNames.size(); i++)
      {
        final String fileName = (String) fileNames.get(i);
        if (fileName != null)
        {
          final RecentFileAction action = new RecentFileAction(fileName);
          menuReopen.add(action);
          menuReopen.setEnabled(true);
        }
      }
    }
    else
    {
      menuReopen.setEnabled(true);
    }
  }

  private void reopenReport ()
  {
    if (currentFile == null)
    {
      return;
    }
    loadReport(currentFile);
  }

  private void openReport ()
  {
    final int returnVal = fileChooser.showOpenDialog(this);
    if (returnVal == JFileChooser.APPROVE_OPTION)
    {
      loadReport(fileChooser.getSelectedFile());
    }
  }

  private void newReport ()
  {
    reportDefinitionManager.setReport(new JFreeReport());
    reportDefinitionManager.setReportData(null);
    setCurrentFile(null);
  }

  public final File getCurrentFile ()
  {
    return currentFile;
  }

  public final void setCurrentFile (final File currentFile)
  {
    if (currentFile == null)
    {
      setTitle(resources.getString("designer.Title"));
      reopenAction.setEnabled(false);
    }
    else
    {
      setTitle
              (MessageFormat.format(resources.getString("designer.Title-with-file"),
                      new Object[]{currentFile}));
      reopenAction.setEnabled(true);
    }
    this.currentFile = currentFile;
  }

  public static void showMessageDialog (final String message, final int type)
  {
    JOptionPane.showMessageDialog(null,
            message,
            "JFreeReport Designer",
            type);
  }

  public static int showConfirmDialog (final String message, final int type)
  {
    return JOptionPane.showConfirmDialog(null,
            message,
            "JFreeReport Designer",
            type);
  }

}