| package com.atlassian.uwc.ui; |
| |
| import java.awt.BorderLayout; |
| import java.awt.Color; |
| import java.awt.Component; |
| import java.awt.Dimension; |
| import java.awt.FlowLayout; |
| import java.awt.GridBagConstraints; |
| import java.awt.GridBagLayout; |
| import java.awt.Insets; |
| import java.awt.Toolkit; |
| import java.awt.dnd.DnDConstants; |
| import java.awt.dnd.DropTarget; |
| import java.awt.event.ActionEvent; |
| import java.awt.event.ActionListener; |
| import java.awt.event.InputEvent; |
| import java.awt.event.KeyEvent; |
| import java.io.File; |
| import java.util.HashMap; |
| import java.util.Observable; |
| import java.util.Observer; |
| import java.util.Vector; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import javax.swing.AbstractButton; |
| import javax.swing.ComboBoxModel; |
| import javax.swing.DefaultComboBoxModel; |
| import javax.swing.JButton; |
| import javax.swing.JCheckBox; |
| import javax.swing.JCheckBoxMenuItem; |
| import javax.swing.JComboBox; |
| import javax.swing.JComponent; |
| import javax.swing.JFileChooser; |
| import javax.swing.JFrame; |
| import javax.swing.JLabel; |
| import javax.swing.JList; |
| import javax.swing.JMenu; |
| import javax.swing.JMenuBar; |
| import javax.swing.JMenuItem; |
| import javax.swing.JPanel; |
| import javax.swing.JPasswordField; |
| import javax.swing.JScrollPane; |
| import javax.swing.JSeparator; |
| import javax.swing.JTabbedPane; |
| import javax.swing.JTextField; |
| import javax.swing.KeyStroke; |
| import javax.swing.SwingConstants; |
| import javax.swing.SwingUtilities; |
| import javax.swing.border.LineBorder; |
| import javax.swing.event.ChangeEvent; |
| import javax.swing.event.ChangeListener; |
| |
| import org.apache.log4j.Logger; |
| import org.apache.log4j.PropertyConfigurator; |
| |
| import regexdemo.AppRegexDemo; |
| import regexdemo.FrameRegexDemo; |
| |
| import com.atlassian.uwc.ui.UWCUserSettings.Setting; |
| import com.atlassian.uwc.ui.listeners.AddPagesListener; |
| import com.atlassian.uwc.ui.listeners.ChangeAttachmentCheckboxListener; |
| import com.atlassian.uwc.ui.listeners.ChangeCheckboxListener; |
| import com.atlassian.uwc.ui.listeners.CheckboxObserver; |
| import com.atlassian.uwc.ui.listeners.ConvertListener; |
| import com.atlassian.uwc.ui.listeners.EnableTextFieldObserver; |
| import com.atlassian.uwc.ui.listeners.ExportWikiListener; |
| import com.atlassian.uwc.ui.listeners.GuiDisablingListener; |
| import com.atlassian.uwc.ui.listeners.HasAllConvertSettingsListener; |
| import com.atlassian.uwc.ui.listeners.IgnoreAltListener; |
| import com.atlassian.uwc.ui.listeners.LaunchFeedbackListener; |
| import com.atlassian.uwc.ui.listeners.PageHandler; |
| import com.atlassian.uwc.ui.listeners.RemovePagesListener; |
| import com.atlassian.uwc.ui.listeners.SaveListener; |
| import com.atlassian.uwc.ui.listeners.SelectFileDropTargetListener; |
| import com.atlassian.uwc.ui.listeners.TestSettingsListener; |
| import com.atlassian.uwc.ui.listeners.UrlLauncher; |
| import com.atlassian.uwc.ui.listeners.WikiIsExportableListener; |
| |
| /** |
| * Improved GUI for the UWC |
| */ |
| public class UWCForm3 { |
| |
| //CONSTANTS |
| protected static final String UWC_DOC_URL = "https://studio.plugins.atlassian.com/wiki/display/UWC/"; |
| private static final String DEFAULT_DIR_LABEL = "Attachments"; |
| public static final String UWC_DOC_WEBSITE = UWC_DOC_URL + "Universal+Wiki+Converter"; |
| private static final String PASSWORD_TOOLTIP = "The password to the Confluence user account being used in the Login field."; |
| private static final String SPACE_TOOLTIP = "This is the spacekey of the Confluence space you will be importing files to."; |
| private static final String ATTACHMENTS_TOOLTIP = "This is the directory where attachments are kept for your particular wiki. This setting will be wiki dependent, so check the appropriate Help docs for more info."; |
| private static final String LOGIN_TOOLTIP = "This is the username of an account on the Confluence server with write privileges to the space where you\'re adding content."; |
| private static final String ADDRESS_TOOLTIP = "This is the url to Confluence. Example: 'localhost:8080'"; |
| private static final String VERSION_INDICATOR = ""; |
| public static final String VERSION_NUMBER = "4.0-SNAPSHOT"; |
| private static final Dimension TABBEDPANE_SIZE = new Dimension(420, 475); |
| public static final String APP_NAME = "Universal Wiki Converter"; |
| private static final int BASIC_RIGHT_MARGIN = 35; |
| private static final int MED_WIDTH = 185; |
| private static final int MED_HEIGHT = 18; |
| private static final Dimension MED_SIZE = new Dimension(MED_WIDTH, MED_HEIGHT); |
| private static final int BASE_INSET = 5; |
| private static final int LABEL_RIGHT_MARGIN = 5; |
| private static final int LABEL_LEFT_MARGIN = 55; |
| /** |
| * default directory where properies are located |
| */ |
| private static final String PROPS_DIR = "conf"; |
| |
| //Swing objects |
| private JFrame jFrame = null; |
| private JPanel jContentPane = null; |
| private JFrame aboutDialog = null; // @jve:decl-index=0:visual-constraint="510,12" |
| private JPanel aboutContentPane = null; |
| private UWCLabel aboutVersionLabel = null; |
| private JTabbedPane jTabbedPane = null; |
| private JPanel jPanelBasic = null; |
| private JPanel jPanelAdvanced = null; |
| private UWCLabel jLabelType = null; |
| private JComboBox jComboBox_WikiType = null; |
| private JButton jButtonExport = null; |
| private JPanel jPanelFromLabel = null; |
| private UWCGuiLine line1 = null; |
| private UWCGuiLine line2 = null; |
| private JLabel jLabelDirectory = null; |
| protected JTextField jTextFieldAttachments = null; |
| private JButton jButtonDirectory = null; |
| private JLabel jLabelPages = null; |
| private JScrollPane jScrollPanePages = null; |
| private JList jListPages = null; |
| private JButton jButtonAddPages = null; |
| private JButton jButtonRemovePages = null; |
| private JPanel jPanelToLabel = null; |
| private UWCGuiLine line3 = null; |
| private UWCGuiLine line4 = null; |
| private UWCLabel jLabelAddress = null; |
| private JTextField jTextFieldAddress = null; |
| private UWCLabel jLabelLogin = null; |
| private JTextField jTextFieldLogin = null; |
| private UWCLabel jLabelPass = null; |
| private JPasswordField jPasswordField = null; |
| private UWCLabel jLabelSpace = null; |
| private JTextField jTextFieldSpace = null; |
| private JPanel jPanelMain = null; |
| private JButton jButtonConvert = null; |
| private JButton jButtonClose = null; |
| private JCheckBox jCheckBoxSendToConfluence = null; |
| private JButton jButtonTestConnection = null; |
| private TestSettingsListener testSettingsListener; |
| private JButton jButtonLaunchRegexTester = null; |
| private UWCLabel jLabelSendToConfluence = null; |
| private JPanel jPanel_OptSettings; |
| private UWCGuiLine line5; |
| private UWCGuiLine line6; |
| private JPanel jPanel_Tools; |
| private UWCGuiLine line7; |
| private UWCGuiLine line8; |
| private UWCLabel jLabelTestConnection; |
| private UWCLabel jLabelLaunchRegexTester; |
| private FrameRegexDemo regexFrame; |
| private JCheckBox jCheckBoxFeedbackOption; |
| private UWCLabel jLabelFeedbackOption; |
| private JButton jButtonLaunchFeedback; |
| private UWCLabel jLabelLaunchFeedback; |
| private FeedbackWindow feedbackWindow; |
| private JCheckBox jCheckBoxAttachmentSize = null; |
| private JLabel jLabelAttachmentSize = null; |
| private JTextField jTextFieldAttachmentSize = null; |
| |
| /* Menu objects */ |
| |
| private JMenuBar jJMenuBar = null; |
| private JMenu fileMenu = null; |
| private JMenu helpMenu = null; |
| private JMenuItem exitMenuItem = null; |
| private JMenuItem aboutMenuItem = null; |
| private JMenuItem saveMenuItem = null; |
| private JMenu converterMenu = null; |
| private JMenu viewMenu = null; |
| private JMenu toolsMenu = null; |
| private JMenuItem convertMenuItem = null; |
| private JMenuItem exportMenuItem = null; |
| private JMenuItem addMenuItem = null; |
| private JMenuItem removeMenuItem = null; |
| private JMenuItem conversionTabMenuItem = null; |
| private JMenuItem otherToolsTabMenuItem = null; |
| private JCheckBoxMenuItem sendPagesCheckboxMenuItem = null; |
| private JCheckBoxMenuItem launchFeedbackCheckboxMenuItem = null; |
| private JCheckBoxMenuItem attachmentSizeCheckboxMenuItem = null; |
| private JMenuItem testConnectionMenuItem = null; |
| private JMenuItem regexTesterMenuItem = null; |
| private JMenuItem launchFeedbackMenuItem = null; |
| private JMenu whenConvertingMenu = null; |
| private JMenu onlineDocMenu = null; |
| private JMenuItem uwcMainDoc = null; |
| private JMenuItem quickDoc = null; |
| private JMenuItem sslDoc = null; |
| private JMenuItem guiDoc = null; |
| |
| /* Listeners */ |
| private ChangeCheckboxListener sendPagesCheckboxListener; |
| private ChangeCheckboxListener launchFeedbackCheckboxListener; |
| private ChangeCheckboxListener attachmentSizeCheckboxListener; |
| private ActionListener regexLauncher; |
| private LaunchFeedbackListener launchFeedbackListener; |
| private Vector<Integer> availableWikiHelpDocMnemonics; |
| private HasAllConvertSettingsListener hasAllConvertSettingsListener; |
| private AddPagesListener addPagesListener; |
| private RemovePagesListener removePagesListener; |
| private ChangeCheckboxListener attachmentSizeMenuItemListener; |
| private SelectFileDropTargetListener dragnDropListener; |
| |
| /* General Objects*/ |
| Logger log = Logger.getLogger(this.getClass()); |
| private HashMap<String, JMenuItem> wikiHelpMenuItems; |
| /** |
| * contains access to all the necessary state, underlying data, settings |
| */ |
| UWCGuiModel model = null; |
| /** |
| * overriding properties directory. If this is null, then |
| * PROPS_DIR will be used. |
| */ |
| private static String commandLineArgDir; |
| |
| /* Methods */ |
| |
| /** |
| * autosaves settings, and shuts down the UWC |
| */ |
| void shutdownUWC() { |
| // preShutdownCleanup(); //XXX This should get called by the shutdown hook. See ShutDownController |
| System.exit(0); |
| } |
| |
| /** |
| * handles all the UWC cleanup needed before exiting the program. |
| * called from ShutDownController |
| */ |
| protected void preShutdownCleanup() { |
| log.debug("Shutting Down..."); |
| save(); |
| } |
| |
| /** |
| * saves all the settings to the file system as properties |
| */ |
| private void save() { |
| Setting unsavedKey = this.model.getUnsaved(); |
| if (unsavedKey != null) { |
| String value = getFormValue(unsavedKey); |
| if (SaveListener.valid(unsavedKey, value)) { |
| //log it but hide passwords |
| String printVal = getPrintablePassword(unsavedKey, value); |
| log.debug("Saving last form element: '" + unsavedKey + "' = '" + printVal +"'"); |
| this.model.saveSetting(unsavedKey, value); |
| } |
| else { |
| log.warn("Unsaved form element: " + unsavedKey + " is invalid. Not saving."); |
| } |
| } |
| this.model.saveAllSettings(); |
| } |
| |
| /** |
| * gets the value allowed to be shown to anyone, based on the given setting and value |
| * @param setting |
| * @param value |
| * @return masks the value, if appropriate. Example, if the setting is |
| * <table> |
| * <tr><td>setting</td><td>value</td><td>returns</td></tr> |
| * <tr><td>PASSWORD</td><td>1234</td><td>*******</td></tr> |
| * <tr><td>SPACE</td><td>key</td><td>key</td></tr> |
| * </table> |
| */ |
| private String getPrintablePassword(Setting setting, String value) { |
| String printVal = value; |
| if (setting == Setting.PASSWORD) { |
| printVal = "*******"; |
| } |
| return printVal; |
| } |
| |
| /** |
| * gets the value for the given key. only enabled for |
| * URL, LOGIN, PASSWORD, SPACE, and ATTACHMENT_SIZE. |
| * |
| * @param setting given key |
| * @return the value or null, if this method is not supported with the |
| * given key |
| * @throws IllegalArgumentException if the given setting is null |
| */ |
| public String getFormValue(Setting setting) { |
| if (setting == null) throw new IllegalArgumentException("unsavedKey parameter may not be null"); |
| switch (setting) { |
| case URL: |
| return getJTextfieldAddress().getText(); |
| case LOGIN: |
| return getJTextFieldLogin().getText(); |
| case PASSWORD: |
| return SaveListener.getPasswordData(getJPasswordField()); |
| case SPACE: |
| return getJTextFieldSpace().getText(); |
| case ATTACHMENT_SIZE: |
| return getJTextFieldAttachmentSize().getText(); |
| case ATTACHMENTS: |
| return getJTextFieldAttachments().getText(); |
| default: |
| log.warn("Not handling element: " + setting); |
| } |
| return null; |
| } |
| |
| /* Swing Object Getters/Creators */ |
| |
| /** |
| * creates or gets the container which handles the |
| * tabs. |
| */ |
| private JTabbedPane getJTabbedPane() { |
| if (jTabbedPane == null) { |
| jTabbedPane = new JTabbedPane(); |
| jTabbedPane.setFont(UWCLabel.getUWCFont()); |
| //title, icon, component, tip |
| jTabbedPane.addTab("Conversion Settings", null, getJPanelBasic(), null); |
| jTabbedPane.addTab("Other Tools", null, getJPanelAdvanced(), null); |
| //set the current tab from settings |
| jTabbedPane.setSelectedIndex( |
| Integer.parseInt( |
| model.getSetting( |
| UWCUserSettings.Setting.CURRENT_TAB))); |
| //create listener to save current tab as a setting |
| jTabbedPane.addChangeListener(new ChangeListener() { |
| public void stateChanged(ChangeEvent event) { |
| JTabbedPane pane = (JTabbedPane) event.getSource(); |
| int index = pane.getSelectedIndex(); |
| log.debug("Saving Current Tab = " + index); |
| model.saveSetting(UWCUserSettings.Setting.CURRENT_TAB, index + ""); |
| } |
| }); |
| } |
| return jTabbedPane; |
| } |
| |
| /** |
| * creates or gets the panel reflecting |
| * the main UI elements contained in the |
| * Conversion Settings tab |
| */ |
| private JPanel getJPanelBasic() { |
| if (jPanelBasic == null) { |
| |
| jPanelBasic = new JPanel(); |
| jPanelBasic.setLayout(new GridBagLayout()); |
| jPanelBasic.setPreferredSize(TABBEDPANE_SIZE); |
| |
| //convert from wiki label |
| GridBagConstraints gridBagConstraints_jPanelFromLabel = getHeaderLabelConstraints(0); |
| gridBagConstraints_jPanelFromLabel.weightx = 0.1; |
| getJPanelFromLabel(); |
| |
| //type label |
| jLabelType = new UWCLabel(); |
| jLabelType.setText("Type:"); |
| GridBagConstraints gridBagConstraints_jLabelType = getBaseLabelConstraints(1); |
| |
| //wikitypes combobox |
| GridBagConstraints gridBagConstraints_jComboBoxWikiType = getBaseConstraints(); |
| gridBagConstraints_jComboBoxWikiType.gridx = 1; |
| gridBagConstraints_jComboBoxWikiType.gridy = 1; |
| gridBagConstraints_jComboBoxWikiType.gridwidth = 2; |
| gridBagConstraints_jComboBoxWikiType.fill = GridBagConstraints.BOTH; |
| |
| |
| //export button |
| GridBagConstraints gridBagConstraints_jButtonExport = getBaseConstraints(); |
| gridBagConstraints_jButtonExport.gridx = 3; |
| gridBagConstraints_jButtonExport.gridy = 1; |
| gridBagConstraints_jButtonExport.insets = new Insets(BASE_INSET,BASE_INSET,BASE_INSET, BASIC_RIGHT_MARGIN); |
| |
| //directory label |
| jLabelDirectory = new UWCLabel(); |
| jLabelDirectory.setText(getDirectoryLabel()+":"); |
| jLabelDirectory.setToolTipText(ATTACHMENTS_TOOLTIP); |
| |
| //browse for dir button |
| GridBagConstraints gridBagConstraints_jButtonDirectory = getBaseConstraints(); |
| gridBagConstraints_jButtonDirectory.gridx = 3; |
| gridBagConstraints_jButtonDirectory.gridy = 3; |
| gridBagConstraints_jButtonDirectory.insets = new Insets(BASE_INSET,BASE_INSET,BASE_INSET, BASIC_RIGHT_MARGIN); |
| |
| //pages label |
| jLabelPages = new UWCLabel(); |
| jLabelPages.setText("Pages:"); |
| |
| //pages list (in a scroll pane) |
| GridBagConstraints gridBagConstraints_jScrollPages = getBaseConstraints(); |
| gridBagConstraints_jScrollPages.gridx = 1; |
| gridBagConstraints_jScrollPages.gridy = 4; |
| gridBagConstraints_jScrollPages.gridwidth = 3; |
| gridBagConstraints_jScrollPages.gridheight = 7; |
| gridBagConstraints_jScrollPages.fill = GridBagConstraints.BOTH; |
| gridBagConstraints_jScrollPages.weighty = 0.75; |
| gridBagConstraints_jScrollPages.insets = new Insets(BASE_INSET,BASE_INSET,BASE_INSET, BASIC_RIGHT_MARGIN); |
| |
| //add page button |
| GridBagConstraints gridBagConstraints_jButtonAdd = getBaseConstraints(); |
| gridBagConstraints_jButtonAdd.gridx = 1; |
| gridBagConstraints_jButtonAdd.gridy = GridBagConstraints.RELATIVE; |
| gridBagConstraints_jButtonAdd.anchor = GridBagConstraints.FIRST_LINE_START; |
| |
| //remove page button |
| GridBagConstraints gridBagConstraints_jButtonRemove = getBaseConstraints(); |
| gridBagConstraints_jButtonRemove.gridx = 2; |
| gridBagConstraints_jButtonRemove.gridy = GridBagConstraints.RELATIVE; |
| gridBagConstraints_jButtonRemove.anchor = GridBagConstraints.FIRST_LINE_START; |
| |
| //to label |
| GridBagConstraints gridBagConstraints_jPanelToLabel = getHeaderLabelConstraints(GridBagConstraints.RELATIVE); |
| |
| //add components to jPanelBasic |
| jPanelBasic.add(getJPanelFromLabel(), gridBagConstraints_jPanelFromLabel); |
| jPanelBasic.add(jLabelType, gridBagConstraints_jLabelType); |
| jPanelBasic.add(getJComboBox_WikiType(), gridBagConstraints_jComboBoxWikiType); |
| jPanelBasic.add(getJButtonExport(), gridBagConstraints_jButtonExport); |
| jPanelBasic.add(jLabelDirectory, getBaseLabelConstraints(3)); |
| jPanelBasic.add(getJTextFieldAttachments(), getBaseSettingsConstraints(3)); |
| jPanelBasic.add(getJButtonAttachments(), gridBagConstraints_jButtonDirectory); |
| jPanelBasic.add(jLabelPages, getBaseLabelConstraints(4)); |
| jPanelBasic.add(getJScrollPanePages(), gridBagConstraints_jScrollPages); |
| jPanelBasic.add(getJButtonAdd(), gridBagConstraints_jButtonAdd); |
| jPanelBasic.add(getJButtonRemovePages(), gridBagConstraints_jButtonRemove); |
| jPanelBasic.add(getJPanelToLabel(), gridBagConstraints_jPanelToLabel); |
| jPanelBasic.add(getJLabelAddress(), getBaseLabelConstraints(GridBagConstraints.RELATIVE)); |
| jPanelBasic.add(getJTextfieldAddress(), getToConfluenceTextfieldContraints(13)); |
| jPanelBasic.add(getJLabelLogin(), getBaseLabelConstraints(14)); |
| jPanelBasic.add(getJTextFieldLogin(), getToConfluenceTextfieldContraints(14)); |
| jPanelBasic.add(getJLabelPass(), getBaseLabelConstraints(15)); |
| jPanelBasic.add(getJPasswordField(), getToConfluenceTextfieldContraints(15)); |
| jPanelBasic.add(getJLabelSpace(), getBaseLabelConstraints(16)); |
| jPanelBasic.add(getJTextFieldSpace(), getToConfluenceTextfieldContraints(16)); |
| } |
| return jPanelBasic; |
| } |
| |
| /** |
| * @return the contents of the label for the directory field. |
| * Note: this was encapuslated in a field to provide a spot for |
| * a possible new feature: extracting an optional non-converter property |
| * which would provide the wiki specific label, using the default label when |
| * the property is not supplied |
| */ |
| private String getDirectoryLabel() { |
| //XXX Possibly use a non-converter property to extract a wiki specific label? |
| return DEFAULT_DIR_LABEL; |
| } |
| |
| /** |
| * creates or gets the label for the space field |
| */ |
| private UWCLabel getJLabelSpace() { |
| if (jLabelSpace == null) { |
| jLabelSpace = new UWCLabel(); |
| jLabelSpace.setText("Space Key:"); |
| jLabelSpace.setToolTipText(SPACE_TOOLTIP); |
| } |
| return jLabelSpace; |
| } |
| |
| /** |
| * creates or gets the label for the password field |
| */ |
| private UWCLabel getJLabelPass() { |
| if (jLabelPass == null) { |
| jLabelPass = new UWCLabel(); |
| jLabelPass.setText("Password:"); |
| jLabelPass.setToolTipText(PASSWORD_TOOLTIP); |
| } |
| return jLabelPass; |
| } |
| |
| /** |
| * creates or gets the label for the login field |
| */ |
| private UWCLabel getJLabelLogin() { |
| if (jLabelLogin == null) { |
| jLabelLogin = new UWCLabel(); |
| jLabelLogin.setText("Login:"); |
| jLabelLogin.setToolTipText(LOGIN_TOOLTIP); |
| } |
| return jLabelLogin; |
| } |
| |
| /** |
| * creates or gets the address textfield |
| */ |
| private JTextField getJTextfieldAddress() { |
| if (jTextFieldAddress == null) { |
| jTextFieldAddress = new JTextField(); |
| jTextFieldAddress.setFont(UWCLabel.getUWCFont()); |
| jTextFieldAddress.setToolTipText(ADDRESS_TOOLTIP); |
| |
| SaveListener saveListener = new SaveListener( |
| this.jTextFieldAddress, |
| this.model, |
| Setting.URL, |
| this.feedbackWindow |
| ); |
| jTextFieldAddress.addActionListener(saveListener); |
| jTextFieldAddress.addFocusListener(saveListener); |
| jTextFieldAddress.addFocusListener(getHasAllListener()); |
| jTextFieldAddress.addKeyListener(new IgnoreAltListener(jTextFieldAddress)); |
| jTextFieldAddress.getDocument().addDocumentListener(getHasAllListener()); |
| |
| jTextFieldAddress.setText(this.model.getSetting(Setting.URL)); |
| |
| } |
| return jTextFieldAddress; |
| } |
| |
| /** |
| * creates or gets the label for the address field |
| */ |
| private UWCLabel getJLabelAddress() { |
| if (jLabelAddress == null) { |
| jLabelAddress = new UWCLabel(); |
| jLabelAddress.setText("Address:"); |
| jLabelAddress.setToolTipText(ADDRESS_TOOLTIP); |
| } |
| return jLabelAddress; |
| } |
| |
| /** |
| * creates or gets the wikitype dropdown menu |
| */ |
| private JComboBox getJComboBox_WikiType() { |
| if (jComboBox_WikiType == null) { |
| jComboBox_WikiType = new JComboBox(); |
| jComboBox_WikiType.setFont(UWCLabel.getUWCFont()); |
| jComboBox_WikiType.setPreferredSize(MED_SIZE); |
| jComboBox_WikiType.setModel(getWikiTypes()); |
| |
| jComboBox_WikiType.addActionListener( |
| new WikiIsExportableListener( |
| jComboBox_WikiType, |
| getJButtonExport(), |
| this.model, |
| getPropsDir() |
| )); |
| jComboBox_WikiType.addActionListener( |
| new WikiIsExportableListener( |
| jComboBox_WikiType, |
| getExportMenuItem(), |
| this.model, |
| getPropsDir() |
| )); |
| jComboBox_WikiType.addActionListener( |
| new SaveListener( |
| this.jComboBox_WikiType, |
| this.model, |
| Setting.WIKITYPE, |
| this.feedbackWindow |
| )); |
| jComboBox_WikiType.addActionListener( |
| new GuiDisablingListener( |
| this.jComboBox_WikiType, |
| getPropsDir(), |
| this.feedbackWindow, |
| this |
| )); |
| jComboBox_WikiType.addActionListener(getHasAllListener()); |
| jComboBox_WikiType.setSelectedItem(this.model.getSetting(Setting.WIKITYPE)); |
| } |
| return jComboBox_WikiType; |
| } |
| |
| /** |
| * @return the directory where properties are located. |
| * The default value is PROPS_DIR. |
| */ |
| private String getPropsDir() { |
| return (commandLineArgDir == null)?PROPS_DIR:commandLineArgDir; |
| } |
| |
| /** |
| * @return a model that will provide the available wiki types, |
| * based on the existing converter.xxx.properties files in existence |
| */ |
| protected ComboBoxModel getWikiTypes() { |
| Vector wikitypes = model.getWikiTypesList(getPropsDir()); |
| ComboBoxModel cbModel = new DefaultComboBoxModel(wikitypes); |
| cbModel.setSelectedItem(null); |
| return cbModel; |
| } |
| |
| /** |
| * creates or gets the Export button |
| */ |
| private JButton getJButtonExport() { |
| if (jButtonExport == null) { |
| jButtonExport = new JButton(); |
| jButtonExport.setText("Export"); |
| jButtonExport.setFont(UWCLabel.getUWCFont()); |
| // this gets set as a result of an event triggered by the wikitypes combobox |
| jButtonExport.setEnabled(false); |
| jButtonExport.addActionListener(new ExportWikiListener( |
| jComboBox_WikiType, |
| this.model, |
| getPropsDir(), |
| getFeedbackWindow())); |
| } |
| return jButtonExport; |
| } |
| |
| /** |
| * creates or gets the From Confluence header label |
| */ |
| private JPanel getJPanelFromLabel() { |
| if (jPanelFromLabel == null) { |
| jPanelFromLabel = createLineLabel( |
| jPanelFromLabel, |
| line1, |
| line2, |
| "Convert From Wiki", 50); |
| } |
| return jPanelFromLabel; |
| } |
| |
| /** |
| * creates or gets the To Confluence header label |
| */ |
| private JPanel getJPanelToLabel() { |
| if (jPanelToLabel == null) { |
| |
| jPanelToLabel = createLineLabel( |
| jPanelToLabel, |
| line3, |
| line4, |
| "To Confluence", 50); |
| } |
| return jPanelToLabel; |
| } |
| |
| /** |
| * creates a panel which visibly represents |
| * an app wide label with headers and decorative lines |
| * @param panel We pass this in because we want to use fields for these objects, |
| * <i>and</i> we might want them to be different for different usages of this method. |
| * @param line1 see panel |
| * @param line2 see panel |
| * @param text Label's visible text |
| * @param leftMargin left column's left margin |
| * @return |
| */ |
| private JPanel createLineLabel( |
| JPanel panel, |
| UWCGuiLine line1, |
| UWCGuiLine line2, |
| String text, |
| int leftMargin) { |
| |
| panel = new JPanel(); |
| |
| int width = 107; |
| |
| line1 = new UWCGuiLine(0, 5, width, 5); |
| line2 = new UWCGuiLine(0, 5, width, 5); |
| |
| UWCLabel label = new UWCLabel(); |
| label.setText(text); |
| label.setHorizontalAlignment(SwingConstants.CENTER); |
| Dimension size = label.getPreferredSize(); |
| size.width -= 40; |
| label.setPreferredSize(size); |
| |
| panel.setLayout(new GridBagLayout()); |
| |
| |
| /* |
| * NOTE: The layout for these panels is |
| * a delicate balancing act between the |
| * weightx, anchors, and margins. |
| * The anchor for each object is CENTER, |
| * set in the getHeaderConstraintsByColumn method. |
| * |
| * As far as I can tell, a decent English translation of these |
| * constraint instructions would go something like: |
| * First: give the left line a left margin of 50px. |
| * Second: Divide the remaining space into 3 chunks, such that: |
| * - label's chunk is half of line2's, and |
| * - line1's chunk is 7/10 of line2's |
| * Last: Center the objects into their particular chunk of space |
| * |
| * The purpose is to place line1 close to the left edge of label |
| * and line2 close to the right edge of label |
| */ |
| |
| /* |
| * line 1 contraints need different insets |
| * so that the first line is placed correctly. |
| */ |
| GridBagConstraints line1Constraints = getHeaderConstraintsByColumn(0, 0.7); |
| line1Constraints.insets = new Insets(BASE_INSET, leftMargin, BASE_INSET, BASE_INSET); |
| |
| panel.add(line1, line1Constraints); |
| panel.add(label, getHeaderConstraintsByColumn(1, 0.5)); |
| panel.add(line2, getHeaderConstraintsByColumn(2, 1.0)); |
| |
| return panel; |
| } |
| |
| /** |
| * creates or gets attachment directory component |
| */ |
| private JTextField getJTextFieldAttachments() { |
| if (jTextFieldAttachments == null) { |
| jTextFieldAttachments = new JTextField(); |
| jTextFieldAttachments.setFont(UWCLabel.getUWCFont()); |
| jTextFieldAttachments.setToolTipText(ATTACHMENTS_TOOLTIP); |
| |
| //saving events |
| SaveListener saveListener = new SaveListener( |
| this.jTextFieldAttachments, |
| this.model, |
| Setting.ATTACHMENTS, |
| this.feedbackWindow |
| ); |
| jTextFieldAttachments.addActionListener(saveListener); |
| jTextFieldAttachments.addFocusListener(saveListener); |
| jTextFieldAttachments.addKeyListener(new IgnoreAltListener(jTextFieldAttachments)); |
| //loading setting |
| jTextFieldAttachments.setText(this.model.getSetting(Setting.ATTACHMENTS)); |
| } |
| return jTextFieldAttachments; |
| } |
| |
| /** |
| * creates or gets the browse button for the attachment's textfield |
| */ |
| private JButton getJButtonAttachments() { |
| if (jButtonDirectory == null) { |
| jButtonDirectory = new JButton(); |
| jButtonDirectory.setText("Browse"); |
| jButtonDirectory.setFont(UWCLabel.getUWCFont()); |
| jButtonDirectory.addActionListener(new java.awt.event.ActionListener() { |
| public void actionPerformed(java.awt.event.ActionEvent event) { |
| //code grabbed from http://www.exampledepot.com/egs/javax.swing.filechooser/CreateDlg.html |
| JFileChooser dialog = new JFileChooser(); |
| dialog.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY); |
| // Show open dialog; this method does not return until the dialog is closed |
| int result = dialog.showOpenDialog(new JFrame()); |
| if (result == JFileChooser.APPROVE_OPTION) { |
| File dirFile = dialog.getSelectedFile(); |
| jTextFieldAttachments.setText(dirFile.getPath()); |
| //save the field |
| jTextFieldAttachments.getActionListeners()[0].actionPerformed( |
| new ActionEvent(event.getSource(), event.getID(), SaveListener.DEFAULT_COMMAND)); |
| } |
| |
| } |
| }); |
| |
| } |
| return jButtonDirectory; |
| } |
| |
| /** |
| * creates or gets the pages panel which displays the chosen pages to be converted |
| */ |
| private JScrollPane getJScrollPanePages() { |
| if (jScrollPanePages == null) { |
| jScrollPanePages = new JScrollPane(getJListPages()); |
| jScrollPanePages.setFont(UWCLabel.getUWCFont()); |
| |
| |
| jScrollPanePages.addMouseListener(getAddPagesListener()); |
| jScrollPanePages.setDropTarget(new DropTarget( |
| jScrollPanePages, |
| DnDConstants.ACTION_COPY, //allowed actions |
| getDragnDropListener(), //listener that handles drag-n-drop events |
| true //pane is accepting drops |
| )); |
| getJListPages().setDropTarget(new DropTarget( |
| jListPages, |
| DnDConstants.ACTION_COPY, |
| getDragnDropListener(), |
| true |
| )); |
| } |
| return jScrollPanePages; |
| } |
| |
| private JList getJListPages() { |
| if (this.jListPages == null) { |
| //pages are from confluenceSetting.properties |
| Vector<String> filenames = this.model.getPageNames(); |
| if (filenames == null || filenames.isEmpty()) |
| this.jListPages = new JList(); |
| else |
| this.jListPages = new JList(filenames); |
| this.jListPages.setFont(UWCLabel.getUWCFont()); |
| } |
| return this.jListPages; |
| } |
| |
| |
| private SelectFileDropTargetListener getDragnDropListener() { |
| if (this.dragnDropListener == null) { |
| dragnDropListener = new SelectFileDropTargetListener(jScrollPanePages, this.model); |
| //observers |
| dragnDropListener.addObserver(getRemoveButtonEnabledListener()); |
| dragnDropListener.addObserver(getHasAllListener()); |
| dragnDropListener.addObserver(new SaveListener( |
| getJListPages(), |
| this.model, |
| Setting.PAGES, |
| this.feedbackWindow |
| )); |
| } |
| return dragnDropListener; |
| } |
| |
| /** |
| * creates or gets the add pages button |
| */ |
| private JButton getJButtonAdd() { |
| if (jButtonAddPages == null) { |
| jButtonAddPages = new JButton(); |
| jButtonAddPages.setText("Add"); |
| jButtonAddPages.setFont(UWCLabel.getUWCFont()); |
| AddPagesListener addPagesListener = getAddPagesListener(); |
| jButtonAddPages.addActionListener(addPagesListener); |
| |
| } |
| return jButtonAddPages; |
| } |
| |
| /** |
| * @return this form's model |
| */ |
| UWCGuiModel getModel() { |
| return this.model; |
| } |
| |
| /** |
| * creates or gets the remove button |
| */ |
| JButton getJButtonRemovePages() { |
| if (jButtonRemovePages == null) { |
| jButtonRemovePages = new JButton(); |
| jButtonRemovePages.setText("Remove"); |
| jButtonRemovePages.setFont(UWCLabel.getUWCFont()); |
| RemovePagesListener removePagesListener = getRemovePagesListener(); |
| jButtonRemovePages.addActionListener(removePagesListener); |
| |
| jButtonRemovePages.setEnabled(!model.getPageFiles().isEmpty()); |
| } |
| return jButtonRemovePages; |
| } |
| |
| /** |
| * creates or gets the login textfield |
| */ |
| private JTextField getJTextFieldLogin() { |
| if (jTextFieldLogin == null) { |
| jTextFieldLogin = new JTextField(); |
| jTextFieldLogin.setFont(UWCLabel.getUWCFont()); |
| jTextFieldLogin.setToolTipText(LOGIN_TOOLTIP); |
| |
| SaveListener saveListener = new SaveListener( |
| this.jTextFieldLogin, |
| this.model, |
| Setting.LOGIN, |
| this.feedbackWindow |
| ); |
| jTextFieldLogin.addActionListener(saveListener); |
| jTextFieldLogin.addFocusListener(saveListener); |
| jTextFieldLogin.addFocusListener(getHasAllListener()); |
| jTextFieldLogin.addKeyListener(new IgnoreAltListener(jTextFieldLogin)); |
| jTextFieldLogin.getDocument().addDocumentListener(getHasAllListener()); |
| |
| jTextFieldLogin.setText(this.model.getSetting(Setting.LOGIN)); |
| } |
| return jTextFieldLogin; |
| } |
| |
| /** |
| * creates or gets the password field |
| */ |
| private JPasswordField getJPasswordField() { |
| if (jPasswordField == null) { |
| jPasswordField = new JPasswordField(); |
| jPasswordField.setFont(UWCLabel.getUWCFont()); |
| jPasswordField.setToolTipText(PASSWORD_TOOLTIP); |
| |
| SaveListener saveListener = new SaveListener( |
| this.jPasswordField, |
| this.model, |
| Setting.PASSWORD, |
| this.feedbackWindow |
| ); |
| jPasswordField.addActionListener(saveListener); |
| jPasswordField.addFocusListener(saveListener); |
| jPasswordField.addKeyListener(new IgnoreAltListener(jPasswordField)); |
| jPasswordField.getDocument().addDocumentListener(getHasAllListener()); |
| |
| jPasswordField.setText(this.model.getSetting(Setting.PASSWORD)); |
| } |
| return jPasswordField; |
| } |
| |
| /** |
| * creates or gets the space textfield |
| */ |
| private JTextField getJTextFieldSpace() { |
| if (jTextFieldSpace == null) { |
| jTextFieldSpace = new JTextField(); |
| jTextFieldSpace.setFont(UWCLabel.getUWCFont()); |
| jTextFieldSpace.setToolTipText(SPACE_TOOLTIP); |
| |
| //saving events |
| SaveListener saveListener = new SaveListener( |
| this.jTextFieldSpace, |
| this.model, |
| Setting.SPACE, |
| this.feedbackWindow |
| ); |
| jTextFieldSpace.addActionListener(saveListener); |
| jTextFieldSpace.addFocusListener(saveListener); |
| jTextFieldSpace.addFocusListener(getHasAllListener()); |
| jTextFieldSpace.addKeyListener(new IgnoreAltListener(jTextFieldSpace)); |
| jTextFieldSpace.getDocument().addDocumentListener(getHasAllListener()); |
| |
| //loading from settings |
| jTextFieldSpace.setText(this.model.getSetting(Setting.SPACE)); |
| } |
| return jTextFieldSpace; |
| } |
| |
| /** |
| * creates or gets the advanced settings panel. |
| */ |
| private JPanel getJPanelAdvanced() { |
| if (jPanelAdvanced == null) { |
| |
| jPanelAdvanced = new JPanel(); |
| jPanelAdvanced.setLayout(new GridBagLayout()); |
| jPanelAdvanced.setPreferredSize(TABBEDPANE_SIZE); |
| |
| GridBagConstraints constraints_OptSettings = getHeaderLabelConstraints(0); |
| constraints_OptSettings.weightx = 0.1; |
| constraints_OptSettings.gridwidth = 2; |
| constraints_OptSettings.insets = new Insets(BASE_INSET, BASE_INSET, BASE_INSET, BASIC_RIGHT_MARGIN); |
| |
| GridBagConstraints constraints_Tools = getHeaderLabelConstraints(5); |
| constraints_Tools.weightx = 0.1; |
| constraints_Tools.gridwidth = 2; |
| int moreVerticalSpace = 30; |
| constraints_Tools.insets = new Insets(moreVerticalSpace, BASE_INSET, BASE_INSET, BASIC_RIGHT_MARGIN); |
| |
| int row = 0; |
| jPanelAdvanced.add(getJPanelOptSettings(), constraints_OptSettings); |
| row++; |
| jPanelAdvanced.add(getJCheckBoxSendToConfluence(), getAdvancedButtonConstraints(row)); |
| jPanelAdvanced.add(getJLabelSendToConf(), getAdvancedLabelConstraints(row++)); |
| jPanelAdvanced.add(getJCheckBoxFeedbackOption(), getAdvancedButtonConstraints(row)); |
| jPanelAdvanced.add(getJLabelFeedbackOption(), getAdvancedLabelConstraints(row++)); |
| jPanelAdvanced.add(getJCheckBoxAttachmentSize(), getAdvancedButtonConstraints(row)); |
| jPanelAdvanced.add(getJLabelAttachmentSize(), getAttachSizeLabelConstraints(row++)); |
| jPanelAdvanced.add(getJTextFieldAttachmentSize(), getAttachSizeTextFieldConstraints(row++)); |
| jPanelAdvanced.add(getJPanelTools(), constraints_Tools); |
| row++; |
| jPanelAdvanced.add(getJButtonTestConnection(), getAdvancedButtonConstraints(row)); |
| jPanelAdvanced.add(getJLabelTestConnection(), getAdvancedLabelConstraints(row++)); |
| jPanelAdvanced.add(getJButtonLaunchRegexTester(), getAdvancedButtonConstraints(row)); |
| jPanelAdvanced.add(getJLabelLaunchRegexTester(), getAdvancedLabelConstraints(row++)); |
| jPanelAdvanced.add(getJButtonLaunchFeedback(), getAdvancedButtonConstraints(row)); |
| jPanelAdvanced.add(getJLabelLaunchFeedback(), getAdvancedLabelConstraints(row++)); |
| } |
| return jPanelAdvanced; |
| } |
| |
| /** |
| * creates or gets the label for the attachment size setting |
| */ |
| private JLabel getJLabelAttachmentSize() { |
| if (jLabelAttachmentSize == null) { |
| jLabelAttachmentSize = new UWCLabel(); |
| String text = |
| "<html>" + |
| "Restrict Uploaded Attachment Size." + |
| "<br>" + |
| "Max File Size:" + |
| "</html>"; |
| jLabelAttachmentSize.setText(text); |
| jLabelAttachmentSize.setPreferredSize(new Dimension(200, 40)); |
| } |
| return jLabelAttachmentSize; |
| } |
| |
| /** |
| * creates or gets the Optional Settings header label |
| */ |
| private JPanel getJPanelOptSettings() { |
| if (jPanel_OptSettings == null) { |
| jPanel_OptSettings = createLineLabel( |
| jPanel_OptSettings, |
| line5, |
| line6, |
| "Optional Settings", 40); |
| } |
| return jPanel_OptSettings; |
| } |
| |
| /** |
| * creates or gets the Developer Tools header label |
| */ |
| private JPanel getJPanelTools() { |
| if (jPanel_Tools == null) { |
| jPanel_Tools = createLineLabel( |
| jPanel_Tools, |
| line7, |
| line8, |
| "Developer Tools", 40); |
| } |
| return jPanel_Tools; |
| } |
| |
| /** |
| * creates or gets the label for the Send Pages To Confluence setting |
| */ |
| private UWCLabel getJLabelSendToConf() { |
| if (jLabelSendToConfluence == null) { |
| jLabelSendToConfluence = new UWCLabel(); |
| String text = "<html>" + |
| "Pages will be sent to Confluence" + |
| "<br>" + |
| "at the end of the conversion, if this is checked." + |
| "</html>"; |
| jLabelSendToConfluence.setText(text); |
| jLabelSendToConfluence.setPreferredSize(new Dimension(200, 50)); |
| } |
| return jLabelSendToConfluence; |
| } |
| |
| /** |
| * creates or gets the label for the Launch Feedback After Convert or Export option |
| */ |
| private UWCLabel getJLabelFeedbackOption() { |
| if (jLabelFeedbackOption == null) { |
| jLabelFeedbackOption = new UWCLabel(); |
| String text = |
| "<html>" + |
| "Launch Feedback Window" + |
| "<br>" + |
| "after convert or export" |
| + "</html>"; |
| jLabelFeedbackOption.setText(text); |
| jLabelFeedbackOption.setPreferredSize(new Dimension(200, 50)); |
| } |
| return jLabelFeedbackOption; |
| } |
| |
| /** |
| * creates or gets the label for the test connection button |
| */ |
| private UWCLabel getJLabelTestConnection() { |
| if (jLabelTestConnection == null) { |
| jLabelTestConnection = new UWCLabel(); |
| String text = "Test the Confluence Server Settings"; |
| jLabelTestConnection.setText(text); |
| } |
| return jLabelTestConnection; |
| } |
| |
| /** |
| * creates or gets the label for the regex tester button |
| */ |
| private UWCLabel getJLabelLaunchRegexTester() { |
| if (jLabelLaunchRegexTester == null) { |
| jLabelLaunchRegexTester = new UWCLabel(); |
| String text = "Launch the Regex Tester"; |
| jLabelLaunchRegexTester.setText(text); |
| } |
| return jLabelLaunchRegexTester; |
| } |
| |
| /** |
| * creates or gets the label for the launch feedback button |
| */ |
| private UWCLabel getJLabelLaunchFeedback() { |
| if (jLabelLaunchFeedback == null) { |
| jLabelLaunchFeedback = new UWCLabel(); |
| String text = "Launch the Feedback Window"; |
| jLabelLaunchFeedback.setText(text); |
| } |
| return jLabelLaunchFeedback; |
| } |
| |
| /** |
| * creates or gets the Send to Confluence checkbox |
| */ |
| private JCheckBox getJCheckBoxSendToConfluence() { |
| if (jCheckBoxSendToConfluence == null) { |
| jCheckBoxSendToConfluence = new JCheckBox(); |
| jCheckBoxSendToConfluence.setFont(UWCLabel.getUWCFont()); |
| |
| jCheckBoxSendToConfluence.setText(""); //No label - we'll add one somewhere else |
| loadSetting(jCheckBoxSendToConfluence, Setting.SEND_TO_CONFLUENCE); |
| jCheckBoxSendToConfluence.addItemListener(getSendPagesCheckboxListener()); |
| |
| AbstractButton otherUiElement = getSendPagesCheckboxMenuItem(); |
| CheckboxObserver observer = new CheckboxObserver( |
| this, otherUiElement, Setting.SEND_TO_CONFLUENCE); |
| getSendPagesCheckboxListener().addObserver(observer); |
| |
| |
| } |
| return jCheckBoxSendToConfluence; |
| } |
| |
| /** |
| * creates or gets the get feedback option checkbox |
| */ |
| private JCheckBox getJCheckBoxFeedbackOption() { |
| if (jCheckBoxFeedbackOption == null) { |
| jCheckBoxFeedbackOption = new JCheckBox(); |
| jCheckBoxFeedbackOption.setFont(UWCLabel.getUWCFont()); |
| |
| jCheckBoxFeedbackOption.setText(""); //No label - we'll add one somewhere else |
| loadSetting(jCheckBoxFeedbackOption, Setting.FEEDBACK_OPTION); |
| jCheckBoxFeedbackOption.addItemListener(getLaunchFeedbackCheckboxListener()); |
| |
| AbstractButton otherUiElement = getLaunchFeedbackCheckBoxMenuItem(); |
| CheckboxObserver observer = new CheckboxObserver( |
| this, otherUiElement, Setting.FEEDBACK_OPTION); |
| getLaunchFeedbackCheckboxListener().addObserver(observer); |
| |
| } |
| return jCheckBoxFeedbackOption; |
| } |
| /** |
| * creates or gets the test connection button |
| */ |
| private JButton getJButtonTestConnection() { |
| if (jButtonTestConnection == null) { |
| jButtonTestConnection = new JButton(); |
| jButtonTestConnection.setFont(UWCLabel.getUWCFont()); |
| jButtonTestConnection.setText("Test Connection"); |
| //use this listener to get feedback about the test |
| Vector<JTextField> testableSettingsObjects = getTestableSettingsObjects(); |
| testSettingsListener = new TestSettingsListener(testableSettingsObjects, this.model, this.getFeedbackWindow()); |
| jButtonTestConnection.addActionListener(testSettingsListener); |
| } |
| return jButtonTestConnection; |
| } |
| |
| /** |
| * @return a vector of To Confluence textfields (address, login, pass, space) |
| */ |
| private Vector<JTextField> getTestableSettingsObjects() { |
| Vector<JTextField> testables = new Vector<JTextField>(); |
| testables.add(getJTextfieldAddress()); |
| testables.add(getJTextFieldLogin()); |
| testables.add(getJPasswordField()); |
| testables.add(getJTextFieldSpace()); |
| return testables; |
| } |
| |
| /** |
| * creates or gets the launch regex tester button |
| */ |
| private JButton getJButtonLaunchRegexTester() { |
| if (jButtonLaunchRegexTester == null) { |
| jButtonLaunchRegexTester = new JButton(); |
| jButtonLaunchRegexTester.setFont(UWCLabel.getUWCFont()); |
| jButtonLaunchRegexTester.setText("Regex Tester"); |
| jButtonLaunchRegexTester.addActionListener(getRegexLauncher()); |
| |
| } |
| return jButtonLaunchRegexTester; |
| } |
| |
| /** |
| * creates or gets the launch feedback button |
| */ |
| private JButton getJButtonLaunchFeedback() { |
| if (jButtonLaunchFeedback == null) { |
| jButtonLaunchFeedback = new JButton(); |
| jButtonLaunchFeedback.setFont(UWCLabel.getUWCFont()); |
| jButtonLaunchFeedback.setText("Launch Feedback"); |
| jButtonLaunchFeedback.addActionListener(getLaunchFeedbackListener()); |
| } |
| return jButtonLaunchFeedback; |
| } |
| |
| /** |
| * creates or gets the feedback window. |
| */ |
| private FeedbackWindow getFeedbackWindow() { |
| if (feedbackWindow == null) { |
| feedbackWindow = new FeedbackWindow(); |
| } |
| return feedbackWindow; |
| } |
| |
| /** |
| * creates or gets the panel containing the convert and close buttons |
| */ |
| private JPanel getJPanelMain() { |
| if (jPanelMain == null) { |
| jPanelMain = new JPanel(); |
| jPanelMain.setLayout(new FlowLayout(FlowLayout.RIGHT, 15, 5)); |
| jPanelMain.add(getJButtonConvert()); |
| jPanelMain.add(getJButtonClose()); |
| } |
| return jPanelMain; |
| } |
| |
| /** |
| * creates or gets the convert button |
| */ |
| private JButton getJButtonConvert() { |
| if (jButtonConvert == null) { |
| jButtonConvert = new JButton(); |
| jButtonConvert.setFont(UWCLabel.getUWCFont()); |
| jButtonConvert.setText("Convert"); |
| jButtonConvert.addActionListener( |
| new ConvertListener(jComboBox_WikiType, model, getPropsDir(), getFeedbackWindow())); |
| jButtonConvert.setEnabled(hasSetAllConverterSettings()); |
| } |
| return jButtonConvert; |
| } |
| |
| /** |
| * @return true if all the conditions necessary to attempt conversion exist. |
| * Which wikitype, at least one page chosen, and all the To Confluence settings aren't empty |
| */ |
| public boolean hasSetAllConverterSettings() { |
| boolean hasWikitype = hasItem((String) getJComboBox_WikiType().getSelectedItem()); |
| boolean hasAddress = hasItem(getJTextfieldAddress().getText()); |
| boolean hasLogin = hasItem(getJTextFieldLogin().getText()); |
| boolean hasPass = getJPasswordField().getDocument().getLength() > 0; //doesn't respond to hasItem like textfield |
| boolean hasSpace = hasItem(getJTextFieldSpace().getText()); |
| boolean hasOnePage = !model.getPageFiles().isEmpty(); |
| |
| boolean hasSettings = hasWikitype && hasAddress && hasLogin && hasPass && hasSpace && hasOnePage; |
| return hasSettings; |
| } |
| |
| /** |
| * @param item |
| * @return true if given item represent an existing value |
| */ |
| private boolean hasItem(String item) { |
| return (item != null && !"".equals(item)); |
| } |
| |
| /** |
| * creates or gets the close button |
| */ |
| private JButton getJButtonClose() { |
| if (jButtonClose == null) { |
| jButtonClose = new JButton(); |
| jButtonClose.setFont(UWCLabel.getUWCFont()); |
| jButtonClose.setText("Close"); |
| jButtonClose.addActionListener(new java.awt.event.ActionListener() { |
| public void actionPerformed(java.awt.event.ActionEvent e) { |
| shutdownUWC(); |
| } |
| }); |
| |
| } |
| return jButtonClose; |
| } |
| |
| |
| /* Listeners */ |
| |
| /** |
| * creates or gets the listener which controls the add button's behavior. |
| * - handles launching the file dialog and choosing a page |
| * - handles notifying the remove button that it needs to check for enabled/disabled status |
| * - handles notifying the convert button that it needs to check for enabled/disabled status |
| */ |
| private AddPagesListener getAddPagesListener() { |
| if (this.addPagesListener == null ) { |
| this.addPagesListener = new AddPagesListener(jScrollPanePages, model); |
| //remove button's enabled state is dependant on whether there are currently pages or not |
| this.addPagesListener.addObserver(getRemoveButtonEnabledListener()); |
| //convert button's enabled state is dependant on whether there are currently pages or not |
| this.addPagesListener.addObserver(getHasAllListener()); |
| this.addPagesListener.addObserver(new SaveListener( |
| getJListPages(), |
| this.model, |
| Setting.PAGES, |
| this.feedbackWindow |
| )); |
| } |
| return this.addPagesListener; |
| } |
| |
| /** |
| * @return Observer which will check to see if the remove button should be enabled/disabled |
| */ |
| private Observer getRemoveButtonEnabledListener() { |
| return (new Observer() { |
| public void update(Observable o, Object arg) { |
| UWCGuiModel model = getModel(); |
| boolean removeIsEnabled = !model.getPageFiles().isEmpty(); |
| getJButtonRemovePages().setEnabled(removeIsEnabled); |
| } |
| }); |
| } |
| |
| /** |
| * creates or gets the listener which controls the remove button's behavior. |
| * - handles remove chosen pages from the pages scrollpane |
| * - handles notifying the remove button that it needs to check for enabled/disabled status |
| * - handles notifying the convert button that it needs to check for enabled/disabled status |
| */ |
| private RemovePagesListener getRemovePagesListener() { |
| if (this.removePagesListener == null) { |
| this.removePagesListener = new RemovePagesListener(jScrollPanePages, model); |
| this.removePagesListener.addObserver(getHasAllListener()); |
| this.removePagesListener.addObserver(getRemoveButtonEnabledListener()); |
| this.removePagesListener.addObserver(new SaveListener( |
| getJListPages(), |
| this.model, |
| Setting.PAGES, |
| this.feedbackWindow |
| )); |
| } |
| return this.removePagesListener; |
| } |
| |
| /** |
| * @return the listener that will enable/disable the given component based on |
| * the settings provided by the user |
| */ |
| private HasAllConvertSettingsListener getHasAllListener() { |
| if (this.hasAllConvertSettingsListener == null) { |
| this.hasAllConvertSettingsListener = new HasAllConvertSettingsListener(this); |
| this.hasAllConvertSettingsListener.registerComponent(getJButtonConvert()); |
| this.hasAllConvertSettingsListener.registerComponent(getConvertMenuItem()); |
| } |
| return this.hasAllConvertSettingsListener; |
| } |
| |
| /** |
| * creates or gets the regex launcher listener. |
| * Calling the listener |
| * - launches the regex app |
| */ |
| private ActionListener getRegexLauncher() { |
| if (this.regexLauncher == null) { |
| regexLauncher = new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| jButtonLaunchRegexTester.setEnabled(false); |
| AppRegexDemo demo = new AppRegexDemo(); |
| regexFrame = demo.getFrame(); |
| //so we can handle enabling it when the frame is closed |
| regexFrame.setLaunchPoint(jButtonLaunchRegexTester); |
| } |
| }; |
| } |
| return this.regexLauncher; |
| } |
| |
| /** |
| * creates or gets the launch feedback listener. When called it: |
| * - launches the feedback window. |
| */ |
| private LaunchFeedbackListener getLaunchFeedbackListener() { |
| if (this.launchFeedbackListener == null) { |
| this.launchFeedbackListener = new LaunchFeedbackListener(getFeedbackWindow()); |
| } |
| return this.launchFeedbackListener; |
| } |
| |
| /* Layout Controls */ |
| |
| /** |
| * creates a set of basic layout constraints used by |
| * practically all the swing objects |
| */ |
| private GridBagConstraints getBaseConstraints() { |
| GridBagConstraints constraints = new GridBagConstraints(); |
| constraints.insets = new Insets(BASE_INSET, BASE_INSET, BASE_INSET, BASE_INSET); |
| return constraints; |
| } |
| |
| /** |
| * creates a set of basic layout constraints used by |
| * textfields |
| * Used in conjunction with GridBagLayout |
| * @param row |
| * @return constraints for the given row |
| */ |
| private GridBagConstraints getBaseSettingsConstraints(int row) { |
| GridBagConstraints constraints = getBaseConstraints(); |
| constraints.gridx = 1; |
| constraints.gridy = row; |
| constraints.gridwidth = 2; |
| constraints.fill = GridBagConstraints.HORIZONTAL; |
| return constraints; |
| } |
| |
| /** |
| * creates a set of layout constraints used by the connection settings textfields |
| * using the given row |
| * @param row |
| * @return |
| */ |
| private GridBagConstraints getToConfluenceTextfieldContraints(int row) { |
| GridBagConstraints constraints = getBaseSettingsConstraints(row); |
| constraints.gridwidth = 3; |
| constraints.insets = new Insets(BASE_INSET, BASE_INSET, BASE_INSET, BASIC_RIGHT_MARGIN); |
| return constraints; |
| } |
| |
| /** |
| * creates a set of layout constraints with the given row, |
| * for the Header Labels like |
| * 'Convert From Wiki'. |
| * @param row |
| */ |
| private GridBagConstraints getHeaderLabelConstraints(int row) { |
| GridBagConstraints constraints = getBaseConstraints(); |
| constraints.gridx = 0; |
| constraints.gridy = row; |
| constraints.gridwidth = 4; |
| constraints.fill = GridBagConstraints.HORIZONTAL; |
| constraints.anchor = GridBagConstraints.PAGE_START; |
| return constraints; |
| } |
| |
| /** |
| * creates a set of layout constraints for the labels |
| * @param row |
| */ |
| private GridBagConstraints getBaseLabelConstraints(int row) { |
| GridBagConstraints constraints = getBaseConstraints(); |
| constraints.gridx = 0; |
| constraints.gridy = row; |
| constraints.gridwidth = 1; |
| constraints.anchor = GridBagConstraints.LINE_END; //right align |
| constraints.insets = new Insets(BASE_INSET, LABEL_LEFT_MARGIN, BASE_INSET, LABEL_RIGHT_MARGIN); |
| return constraints; |
| } |
| |
| /** |
| * creates constraints for the ui on the advanced tab and |
| * on the given row |
| * @param row |
| * @return |
| */ |
| private GridBagConstraints getAdvancedButtonConstraints(int row) { |
| GridBagConstraints constraints = getBaseConstraints(); |
| constraints.gridx = 0; |
| constraints.gridy = row; |
| constraints.anchor = GridBagConstraints.LINE_START; //left align |
| int leftMargin = LABEL_LEFT_MARGIN - 10; |
| int bottomMargin = BASE_INSET + 5; |
| constraints.insets = new Insets(BASE_INSET, leftMargin, bottomMargin, LABEL_RIGHT_MARGIN); |
| |
| return constraints; |
| } |
| |
| /** |
| * creates constraints for the labels on the advanced tab and on |
| * the given row |
| * @param row |
| * @return |
| */ |
| private GridBagConstraints getAdvancedLabelConstraints(int row) { |
| GridBagConstraints constraints = getBaseConstraints(); |
| constraints.gridx = 1; |
| constraints.gridy = row; |
| constraints.anchor = GridBagConstraints.LINE_START; //left align |
| return constraints; |
| } |
| |
| /** |
| * creates a specialty constraint that should be used with the |
| * Attachment Size restriction label. The constraints will use the given row. |
| * @param row which row on the grid this label will be located |
| * @return |
| */ |
| private GridBagConstraints getAttachSizeLabelConstraints(int row) { |
| GridBagConstraints constraints = getAdvancedLabelConstraints(row); |
| |
| //make the bottom of the label be just adjacent to the associated textfield |
| constraints.insets.bottom = 0; |
| |
| return constraints; |
| } |
| |
| /** |
| * creates a specialty constraint that should be used with the |
| * Attachment Size restriction textfield. The constraints will |
| * use the given row. |
| * @param row which row on the grid will be used |
| * @return |
| */ |
| private GridBagConstraints getAttachSizeTextFieldConstraints(int row) { |
| GridBagConstraints constraints = getAdvancedLabelConstraints(row); |
| // fix the width |
| constraints.fill = GridBagConstraints.HORIZONTAL; |
| constraints.insets.right = 160; |
| |
| //make the top of the textfield be just adjacent to the associated label |
| constraints.insets.top = 0; |
| |
| return constraints; |
| } |
| |
| /** |
| * creates the basic constraints for the section headers |
| * that span the width of the app, with a default CENTER anchor |
| * @param column |
| * @param weight |
| * @return |
| */ |
| private GridBagConstraints getHeaderConstraintsByColumn(int column, double weight) { |
| return getHeaderConstraintsByColumn(column, weight, GridBagConstraints.CENTER); |
| } |
| |
| /** |
| * creates the basic constraints for the section headers |
| * that span the width of the app |
| * @param column |
| * @param weight weightx for the component. |
| * (handles how much space it gets as a column) |
| * @param anchor |
| * @return |
| */ |
| private GridBagConstraints getHeaderConstraintsByColumn(int column, double weight, int anchor) { |
| GridBagConstraints constraints = getBaseConstraints(); |
| constraints.gridx = column; |
| constraints.gridy = 0; |
| constraints.anchor = anchor; |
| constraints.fill = GridBagConstraints.HORIZONTAL; |
| constraints.weightx = weight; |
| constraints.weighty = 0.0; |
| constraints.insets = new Insets(0,0,0,0); |
| return constraints; |
| } |
| |
| /* Menu Getters */ |
| |
| /** |
| * This method initializes converterMenu |
| * |
| * @return javax.swing.JMenu |
| */ |
| private JMenu getConverterMenu() { |
| if (converterMenu == null) { |
| converterMenu = new JMenu(); |
| converterMenu.setFont(UWCLabel.getUWCFont()); |
| converterMenu.setText("Convert"); |
| converterMenu.add(getConvertMenuItem()); |
| converterMenu.add(getExportMenuItem()); |
| addSeparator(converterMenu); |
| converterMenu.add(getAddMenuItem()); |
| converterMenu.add(getRemoveMenuItem()); |
| addAccelerator(converterMenu, KeyEvent.VK_C); |
| } |
| return converterMenu; |
| } |
| |
| /** |
| * This method initializes View |
| * |
| * @return javax.swing.JMenu |
| */ |
| private JMenu getView() { |
| if (viewMenu == null) { |
| viewMenu = new JMenu(); |
| viewMenu.setFont(UWCLabel.getUWCFont()); |
| viewMenu.setText("View"); |
| viewMenu.add(getConversionSettingMenuItem()); |
| viewMenu.add(getOtherToolsTabMenuItem()); |
| addAccelerator(viewMenu, KeyEvent.VK_V); |
| } |
| return viewMenu; |
| } |
| |
| /** |
| * This method initializes toolsMenu |
| * |
| * @return javax.swing.JMenu |
| */ |
| private JMenu getToolsMenu() { |
| if (toolsMenu == null) { |
| toolsMenu = new JMenu(); |
| toolsMenu.setFont(UWCLabel.getUWCFont()); |
| toolsMenu.setText("Tools"); |
| toolsMenu.add(getWhenConvertingMenu()); |
| addSeparator(toolsMenu); |
| toolsMenu.add(getTestConnectionMenuItem()); |
| toolsMenu.add(getRegexTesterMenuItem()); |
| toolsMenu.add(getLaunchFeedbackMenuItem()); |
| addAccelerator(toolsMenu, KeyEvent.VK_T); |
| } |
| return toolsMenu; |
| } |
| |
| /** |
| * This method initializes convertMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getConvertMenuItem() { |
| if (convertMenuItem == null) { |
| convertMenuItem = new JMenuItem(); |
| convertMenuItem.setFont(UWCLabel.getUWCFont()); |
| convertMenuItem.setText("Convert"); |
| addAccelerator(convertMenuItem, KeyEvent.VK_C, getShiftAccelerator()); |
| convertMenuItem.setPreferredSize(getIncreasedHeight(convertMenuItem)); |
| convertMenuItem.addActionListener( |
| new ConvertListener(jComboBox_WikiType, model, getPropsDir(), getFeedbackWindow())); |
| convertMenuItem.setEnabled(hasSetAllConverterSettings()); |
| |
| } |
| return convertMenuItem; |
| } |
| |
| /** |
| * This method initializes exportMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getExportMenuItem() { |
| if (exportMenuItem == null) { |
| exportMenuItem = new JMenuItem(); |
| exportMenuItem.setFont(UWCLabel.getUWCFont()); |
| exportMenuItem.setText("Export"); |
| addAccelerator(exportMenuItem, KeyEvent.VK_E, getOsAccelerator()); |
| exportMenuItem.setPreferredSize(getIncreasedHeight(exportMenuItem)); |
| exportMenuItem.setEnabled(false); //only available when appropriate wiki is being used |
| exportMenuItem.addActionListener( |
| new ExportWikiListener( |
| jComboBox_WikiType, |
| this.model, |
| getPropsDir(), |
| getFeedbackWindow())); |
| } |
| return exportMenuItem; |
| } |
| |
| /** |
| * This method initializes addMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getAddMenuItem() { |
| if (addMenuItem == null) { |
| addMenuItem = new JMenuItem(); |
| addMenuItem.setFont(UWCLabel.getUWCFont()); |
| addMenuItem.setText("Add Pages"); |
| addAccelerator(addMenuItem, KeyEvent.VK_A, getOsAccelerator()); |
| addMenuItem.setPreferredSize(getIncreasedHeight(addMenuItem)); |
| addMenuItem.addActionListener(getAddPagesListener()); |
| } |
| return addMenuItem; |
| } |
| |
| /** |
| * This method initializes removeMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getRemoveMenuItem() { |
| if (removeMenuItem == null) { |
| removeMenuItem = new JMenuItem(); |
| removeMenuItem.setFont(UWCLabel.getUWCFont()); |
| removeMenuItem.setText("Remove Pages"); |
| addAccelerator(removeMenuItem, KeyEvent.VK_R, getOsAccelerator()); |
| removeMenuItem.setPreferredSize(getIncreasedHeight(removeMenuItem)); |
| removeMenuItem.addActionListener(getRemovePagesListener()); |
| } |
| return removeMenuItem; |
| } |
| |
| /** |
| * This method initializes conversionSettingMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getConversionSettingMenuItem() { |
| if (conversionTabMenuItem == null) { |
| conversionTabMenuItem = new JMenuItem(); |
| conversionTabMenuItem.setFont(UWCLabel.getUWCFont()); |
| conversionTabMenuItem.setText("Conversion Settings"); |
| addAccelerator(conversionTabMenuItem, KeyEvent.VK_1, getOsAccelerator()); |
| conversionTabMenuItem.setPreferredSize(getIncreasedHeight(removeMenuItem)); |
| conversionTabMenuItem.setPreferredSize(getIncreasedWidth(removeMenuItem, 40)); |
| conversionTabMenuItem.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| JTabbedPane tabs = getJTabbedPane(); |
| JPanel conTab = getJPanelBasic(); |
| tabs.setSelectedComponent(conTab); |
| } |
| }); |
| } |
| return conversionTabMenuItem; |
| } |
| |
| /** |
| * This method initializes otherToolsTabMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getOtherToolsTabMenuItem() { |
| if (otherToolsTabMenuItem == null) { |
| otherToolsTabMenuItem = new JMenuItem(); |
| otherToolsTabMenuItem.setFont(UWCLabel.getUWCFont()); |
| otherToolsTabMenuItem.setText("Other Tools"); |
| addAccelerator(otherToolsTabMenuItem, KeyEvent.VK_2, getOsAccelerator()); |
| otherToolsTabMenuItem.setPreferredSize(getIncreasedHeight(otherToolsTabMenuItem)); |
| } |
| otherToolsTabMenuItem.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| JTabbedPane tabs = getJTabbedPane(); |
| JPanel otherTab = getJPanelAdvanced(); |
| tabs.setSelectedComponent(otherTab); |
| } |
| }); |
| return otherToolsTabMenuItem; |
| } |
| |
| /** |
| * This method initializes sendPagesMenuItem |
| * |
| * @return javax.swing.JCheckBoxMenuItem |
| */ |
| private JCheckBoxMenuItem getSendPagesCheckboxMenuItem() { |
| if (sendPagesCheckboxMenuItem == null) { |
| sendPagesCheckboxMenuItem = new JCheckBoxMenuItem(); |
| sendPagesCheckboxMenuItem.setFont(UWCLabel.getUWCFont()); |
| sendPagesCheckboxMenuItem.setText("Send Pages"); |
| sendPagesCheckboxMenuItem.setPreferredSize(getIncreasedHeight(sendPagesCheckboxMenuItem)); |
| |
| loadSetting(sendPagesCheckboxMenuItem, Setting.SEND_TO_CONFLUENCE); |
| |
| sendPagesCheckboxMenuItem.addItemListener(getSendPagesCheckboxListener()); |
| |
| JCheckBox otherUiElement = getJCheckBoxSendToConfluence(); |
| CheckboxObserver observer = new CheckboxObserver( |
| this, otherUiElement, Setting.SEND_TO_CONFLUENCE); |
| getSendPagesCheckboxListener().addObserver(observer); |
| |
| } |
| return sendPagesCheckboxMenuItem; |
| } |
| |
| /** |
| * This method initializes attachmentSizeCheckboxMenuItem |
| * @return javaz.swing.JCheckBoxMenuItem |
| */ |
| private JCheckBoxMenuItem getAttachmentSizeCheckBoxMenuItem() { |
| if (attachmentSizeCheckboxMenuItem == null) { |
| attachmentSizeCheckboxMenuItem = new JCheckBoxMenuItem(); |
| attachmentSizeCheckboxMenuItem.setFont(UWCLabel.getUWCFont()); |
| attachmentSizeCheckboxMenuItem.setText("Restrict Attachment Size"); |
| attachmentSizeCheckboxMenuItem.setPreferredSize(getIncreasedHeight(attachmentSizeCheckboxMenuItem)); |
| |
| attachmentSizeCheckboxMenuItem.setSelected(getBooleanSettingFromString(Setting.ATTACHMENT_SIZE, UWCUserSettings.DEFAULT_ATTACHMENT_SIZE)); |
| |
| attachmentSizeCheckboxMenuItem.addItemListener(getAttachmentSizeMenuItemListener()); //FILE_ATTACH_Z1 |
| |
| JCheckBox otherUiElement = getJCheckBoxAttachmentSize(); //FILE_ATTACH_Z1 |
| CheckboxObserver observer = new CheckboxObserver( |
| this, otherUiElement, Setting.ATTACHMENT_SIZE); |
| getAttachmentSizeMenuItemListener().addObserver(observer); //FILE_ATTACH_Z1 |
| |
| |
| } |
| return attachmentSizeCheckboxMenuItem; |
| |
| } |
| |
| /** |
| * loads selectable with the boolean value associated with the setting |
| * as it is currently represented in the model |
| * @param selectable |
| * @param setting |
| */ |
| public void loadSetting(AbstractButton selectable, Setting setting) { |
| boolean settingBool = Boolean.parseBoolean(this.model.getSetting(setting)); |
| selectable.setSelected(settingBool); |
| } |
| |
| /** |
| * loads the given ui element with the boolean based on the value for the given setting |
| * and given defaultValue. |
| * @param element ui element to be loaded with a boolean value |
| * @param setting the key representing the current setting |
| * @param defaultValue default value for the setting |
| */ |
| public void loadBooleanSettingFromString(AbstractButton element, Setting setting, String defaultValue) { |
| boolean booleanSettingFromString = getBooleanSettingFromString(setting, defaultValue); |
| element.setSelected(booleanSettingFromString); |
| } |
| |
| /** |
| * @param setting key representing which setting is being examined |
| * @param defaultValue default value for this setting |
| * @return true if the model value for the given setting is not the default value |
| */ |
| public boolean getBooleanSettingFromString(Setting setting, String defaultValue ) { |
| String intString = this.model.getSetting(setting); |
| return (defaultValue.equals(intString))?false:true; |
| } |
| |
| /** |
| * @return gets or creates the sendPagesCheckboxListener |
| */ |
| private ChangeCheckboxListener getSendPagesCheckboxListener() { |
| if (this.sendPagesCheckboxListener == null) |
| this.sendPagesCheckboxListener = new ChangeCheckboxListener(this.model, Setting.SEND_TO_CONFLUENCE); |
| return this.sendPagesCheckboxListener; |
| } |
| |
| /** |
| * @return gets or returns the attachmentSizeCheckboxListener |
| */ |
| private ChangeCheckboxListener getAttachmentSizeCheckboxListener() { |
| if (this.attachmentSizeCheckboxListener == null) |
| this.attachmentSizeCheckboxListener = new ChangeAttachmentCheckboxListener(this.model, Setting.ATTACHMENT_SIZE, getJTextFieldAttachmentSize()); |
| return this.attachmentSizeCheckboxListener; |
| } |
| |
| /** |
| * @return gets or creates the attachmentSizeMenuItemListener |
| */ |
| private ChangeCheckboxListener getAttachmentSizeMenuItemListener() { |
| if (this.attachmentSizeMenuItemListener == null) |
| this.attachmentSizeMenuItemListener = new ChangeAttachmentCheckboxListener(this.model, Setting.ATTACHMENT_SIZE, getJTextFieldAttachmentSize()); |
| return this.attachmentSizeMenuItemListener; |
| } |
| |
| /** |
| * This method initializes launchFeedbackCheckBoxMenuItem |
| * |
| * @return javax.swing.JCheckBoxMenuItem |
| */ |
| private JCheckBoxMenuItem getLaunchFeedbackCheckBoxMenuItem() { |
| if (launchFeedbackCheckboxMenuItem == null) { |
| launchFeedbackCheckboxMenuItem = new JCheckBoxMenuItem(); |
| launchFeedbackCheckboxMenuItem.setFont(UWCLabel.getUWCFont()); |
| launchFeedbackCheckboxMenuItem.setText("Launch Feedback"); |
| launchFeedbackCheckboxMenuItem.setPreferredSize(getIncreasedHeight(launchFeedbackCheckboxMenuItem)); |
| loadSetting(launchFeedbackCheckboxMenuItem, Setting.FEEDBACK_OPTION); |
| launchFeedbackCheckboxMenuItem.addItemListener(getLaunchFeedbackCheckboxListener()); |
| |
| AbstractButton otherUiElement = getJCheckBoxFeedbackOption(); |
| CheckboxObserver observer = new CheckboxObserver( |
| this, otherUiElement, Setting.FEEDBACK_OPTION); |
| getLaunchFeedbackCheckboxListener().addObserver(observer); |
| |
| } |
| return launchFeedbackCheckboxMenuItem; |
| } |
| |
| /** |
| * @return gets or creates launchFeedbackCheckboxListener |
| */ |
| private ChangeCheckboxListener getLaunchFeedbackCheckboxListener() { |
| if (this.launchFeedbackCheckboxListener == null) |
| this.launchFeedbackCheckboxListener = new ChangeCheckboxListener(this.model, Setting.FEEDBACK_OPTION); |
| return this.launchFeedbackCheckboxListener; |
| } |
| |
| /** |
| * This method initializes testConnectionMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getTestConnectionMenuItem() { |
| if (testConnectionMenuItem == null) { |
| testConnectionMenuItem = new JMenuItem(); |
| testConnectionMenuItem.setFont(UWCLabel.getUWCFont()); |
| testConnectionMenuItem.setText("Test Connection"); |
| testConnectionMenuItem.setPreferredSize(getIncreasedHeight(testConnectionMenuItem)); |
| testConnectionMenuItem.addActionListener(testSettingsListener); |
| addAccelerator(testConnectionMenuItem, KeyEvent.VK_T, getOsAccelerator()); |
| } |
| return testConnectionMenuItem; |
| } |
| |
| /** |
| * This method initializes regexTesterMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getRegexTesterMenuItem() { |
| if (regexTesterMenuItem == null) { |
| regexTesterMenuItem = new JMenuItem(); |
| regexTesterMenuItem.setFont(UWCLabel.getUWCFont()); |
| regexTesterMenuItem.setText("Regex Tester"); |
| regexTesterMenuItem.setPreferredSize(getIncreasedHeight(regexTesterMenuItem)); |
| regexTesterMenuItem.addActionListener(getRegexLauncher()); |
| } |
| return regexTesterMenuItem; |
| } |
| |
| /** |
| * This method initializes launchFeedbackMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getLaunchFeedbackMenuItem() { |
| if (launchFeedbackMenuItem == null) { |
| launchFeedbackMenuItem = new JMenuItem(); |
| launchFeedbackMenuItem.setFont(UWCLabel.getUWCFont()); |
| launchFeedbackMenuItem.setText("Feedback Window"); |
| launchFeedbackMenuItem.setPreferredSize(getIncreasedHeight(launchFeedbackMenuItem)); |
| launchFeedbackMenuItem.setPreferredSize(getIncreasedWidth(launchFeedbackMenuItem, 40)); |
| launchFeedbackMenuItem.addActionListener(getLaunchFeedbackListener()); |
| addAccelerator(launchFeedbackMenuItem, KeyEvent.VK_F, getOsAccelerator()); |
| } |
| return launchFeedbackMenuItem; |
| } |
| |
| /** |
| * This method initializes whenConvertingMenu |
| * |
| * @return javax.swing.JMenu |
| */ |
| private JMenu getWhenConvertingMenu() { |
| if (whenConvertingMenu == null) { |
| whenConvertingMenu = new JMenu(); |
| whenConvertingMenu.setFont(UWCLabel.getUWCFont()); |
| whenConvertingMenu.setText("When Converting..."); |
| whenConvertingMenu.add(getSendPagesCheckboxMenuItem()); |
| whenConvertingMenu.add(getLaunchFeedbackCheckBoxMenuItem()); |
| whenConvertingMenu.add(getAttachmentSizeCheckBoxMenuItem()); |
| whenConvertingMenu.setPreferredSize(getIncreasedHeight(whenConvertingMenu)); |
| } |
| return whenConvertingMenu; |
| } |
| |
| /** |
| * This method initializes onlineDocMenu |
| * |
| * @return javax.swing.JMenu |
| */ |
| private JMenu getOnlineDocMenu() { |
| if (onlineDocMenu == null) { |
| onlineDocMenu = new JMenu(); |
| onlineDocMenu.setFont(UWCLabel.getUWCFont()); |
| onlineDocMenu.setText("Online Doc"); |
| onlineDocMenu.add(getUwcMainDoc()); |
| onlineDocMenu.add(getUwcGuiDoc()); |
| onlineDocMenu.add(getQuickDoc()); |
| onlineDocMenu.add(getSSLDoc()); |
| onlineDocMenu.setPreferredSize(getIncreasedHeight(onlineDocMenu)); |
| onlineDocMenu.setMnemonic(KeyEvent.VK_O); |
| |
| addSeparator(onlineDocMenu); |
| |
| //wiki specific doc pages |
| Vector<String> wikitypes = model.getWikiTypesList(getPropsDir()); |
| for (String wikitype : wikitypes) { |
| //ignore known test files |
| if (wikitype.equals("test") || |
| wikitype.equals("testHierarchy") || |
| wikitype.equals("NoSyntaxConversions") || |
| wikitype.equals("moinmoini")) |
| continue; |
| //add a menu item pointed at doc page for that wiki type |
| JMenuItem item = getWikitypeDocMenuItem(wikitype); |
| if (item != null) onlineDocMenu.add(item); |
| } |
| } |
| return onlineDocMenu; |
| } |
| |
| /** |
| * This method initializes uwcMainDoc |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getUwcMainDoc() { |
| if (uwcMainDoc == null) { |
| uwcMainDoc = new JMenuItem(); |
| uwcMainDoc.setFont(UWCLabel.getUWCFont()); |
| uwcMainDoc.setText("UWC Doc"); |
| uwcMainDoc.setPreferredSize(getIncreasedHeight(uwcMainDoc)); |
| uwcMainDoc.setMnemonic(KeyEvent.VK_U); |
| String link = UWC_DOC_WEBSITE; |
| uwcMainDoc.addActionListener(new UrlLauncher(link, this.feedbackWindow)); |
| } |
| return uwcMainDoc; |
| } |
| |
| /** |
| * This method initializes quickDoc |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getQuickDoc() { |
| if (quickDoc == null) { |
| quickDoc = new JMenuItem(); |
| quickDoc.setFont(UWCLabel.getUWCFont()); |
| quickDoc.setText("Quick Start Guide"); |
| quickDoc.setPreferredSize(getIncreasedHeight(quickDoc)); |
| quickDoc.setMnemonic(KeyEvent.VK_Q); |
| String link = UWC_DOC_URL + "UWC+Quick+Start"; |
| quickDoc.addActionListener(new UrlLauncher(link, this.feedbackWindow)); |
| } |
| return quickDoc; |
| } |
| |
| /** |
| * This method initializes sslDoc |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getSSLDoc() { |
| if (sslDoc == null) { |
| sslDoc = new JMenuItem(); |
| sslDoc.setFont(UWCLabel.getUWCFont()); |
| sslDoc.setText("SSL Support"); |
| sslDoc.setPreferredSize(getIncreasedHeight(sslDoc)); |
| String link = UWC_DOC_URL + "UWC+SSL+Support"; |
| sslDoc.addActionListener(new UrlLauncher(link, this.feedbackWindow)); |
| } |
| return sslDoc; |
| } |
| |
| /** |
| * @return creates or gets guiDoc |
| */ |
| private JMenuItem getUwcGuiDoc() { |
| if (this.guiDoc == null) { |
| guiDoc = new JMenuItem(); |
| guiDoc.setFont(UWCLabel.getUWCFont()); |
| guiDoc.setText("New UI Doc"); |
| guiDoc.setPreferredSize(getIncreasedHeight(guiDoc)); |
| guiDoc.setMnemonic(KeyEvent.VK_N); |
| String link = UWC_DOC_URL + "UWC+GUI+v3+Documentation"; |
| guiDoc.addActionListener(new UrlLauncher(link, this.feedbackWindow)); |
| } |
| return guiDoc; |
| } |
| |
| /** |
| * creates or gets a menu item for a particular wikitype's doc |
| * @param wikitype |
| * @return menu item linked to the wiki specific doc |
| * for the given wikitype |
| */ |
| private JMenuItem getWikitypeDocMenuItem(String wikitype) { |
| getWikiHelpMenuItems(); //if object is undefined, will define it. |
| if (this.wikiHelpMenuItems.containsKey(wikitype)) //return the existing one |
| return this.wikiHelpMenuItems.get(wikitype); |
| JMenuItem item = createJMenuItem(wikitype); //or if doesn't exist, create it |
| if (item == null) return null; |
| this.wikiHelpMenuItems.put(wikitype, item); |
| return item; |
| } |
| |
| /** |
| * @return gets or creates wikiHelpMenuItems |
| */ |
| private HashMap<String,JMenuItem> getWikiHelpMenuItems() { |
| if (this.wikiHelpMenuItems == null) |
| this.wikiHelpMenuItems = new HashMap<String,JMenuItem>(); |
| return this.wikiHelpMenuItems; |
| } |
| |
| /** |
| * @param wikitype |
| * @return a new menu item corresponding to the given wikitype, |
| * and linked to that wikitype's doc site |
| */ |
| private JMenuItem createJMenuItem(String wikitype) { |
| JMenuItem item = new JMenuItem(); |
| item.setFont(UWCLabel.getUWCFont()); |
| item.setText(getFirstCharUpperCase(wikitype) + " Doc"); |
| item.setPreferredSize(getIncreasedHeight(item)); |
| int mnemonic = getAvailableMnemonic(wikitype); |
| if (mnemonic > -1) //only set mnemonic if an appropriate one was found |
| item.setMnemonic(mnemonic); |
| String link = getWikiDocLink(wikitype); |
| if (link == null) return null; |
| item.addActionListener(new UrlLauncher(link, this.feedbackWindow)); |
| return item; |
| } |
| |
| /** |
| * transforms the given input to have the first letter be upper case |
| * @param input |
| * @return transformed string |
| */ |
| protected String getFirstCharUpperCase(String input) { |
| String first = input.substring(0,1); |
| String last = input.substring(1); |
| first = first.toUpperCase(); |
| return first + last; |
| } |
| |
| /** |
| * chooses an appropriate character based on the given input |
| * @param input |
| * @return an acceptable int value for a character from the given input |
| * that can be used as a mnemonic. character must be from given word, and |
| * must not be already in use with this set. if cannot find one, returns -1; |
| */ |
| protected int getAvailableMnemonic(String input) { |
| Vector<Integer> available = this.availableWikiHelpDocMnemonics; |
| if (available == null) { //create it if it doesn't exist |
| available = new Vector<Integer>(); |
| //add already existing Mnemonics |
| available.add((int)"U".toCharArray()[0]); //uwc doc |
| available.add((int)"Q".toCharArray()[0]); //quick start |
| } |
| input = input.toUpperCase(); //keyevents are associated with upper case chars |
| for (int i = 0; i < input.length(); i++) { //foreach character in the word |
| char c = input.charAt(i); |
| int charAsInt = (int) c ; |
| if (available.contains(charAsInt)) { //char already in use. choose another one. |
| continue; |
| } |
| available.add(charAsInt); //found a char. add it to the vector. |
| this.availableWikiHelpDocMnemonics = available; |
| return charAsInt; |
| } |
| return -1; //give up. can't find suitable unused char. |
| } |
| |
| Pattern nodocwiki = Pattern.compile("(test)|(-)"); |
| /** |
| * builds the url for the given wikitype's doc |
| * @param wikitype |
| * @return url |
| */ |
| protected String getWikiDocLink(String wikitype) { |
| //hide wikitypes that have the word "test" or a "-" |
| Matcher nodocFinder = nodocwiki.matcher(wikitype); |
| if (nodocFinder.find()) return null; |
| //create link |
| String link = |
| UWC_DOC_URL + |
| "UWC" + |
| "+" + |
| wikitype + |
| "+" + |
| "Notes"; |
| return link; |
| } |
| |
| /** |
| * This method initializes jJMenuBar |
| * |
| * @return javax.swing.JMenuBar |
| */ |
| private JMenuBar getJJMenuBar() { |
| if (jJMenuBar == null) { |
| jJMenuBar = new JMenuBar(); |
| jJMenuBar.add(getFileMenu()); |
| jJMenuBar.add(getConverterMenu()); |
| jJMenuBar.add(getView()); |
| jJMenuBar.add(getToolsMenu()); |
| jJMenuBar.add(getHelpMenu()); |
| } |
| return jJMenuBar; |
| } |
| |
| /** |
| * This method initializes jMenu |
| * |
| * @return javax.swing.JMenu |
| */ |
| private JMenu getFileMenu() { |
| if (fileMenu == null) { |
| fileMenu = new JMenu(); |
| fileMenu.setFont(UWCLabel.getUWCFont()); |
| fileMenu.setText("File"); |
| fileMenu.add(getSaveMenuItem()); |
| fileMenu.add(getExitMenuItem()); |
| addAccelerator(fileMenu, KeyEvent.VK_F); |
| } |
| return fileMenu; |
| } |
| |
| /** |
| * @return text for the close button/menu item. |
| * Should reflect user's OS |
| */ |
| private String getCloseText() { |
| boolean isMac = isMac(); |
| if (isMac) |
| return "Quit"; |
| return "Close"; |
| } |
| |
| /** |
| * @return keyboard accel key for the close menu item. |
| * Should reflect user's OS (X for Win, Q for Mac, etc.) |
| */ |
| private int getCloseKey() { |
| if (isMac()) |
| return KeyEvent.VK_Q; |
| return KeyEvent.VK_X; |
| } |
| |
| /** |
| * @return true if the system env variable os.name |
| * indicates the system is a mac |
| */ |
| private boolean isMac() { |
| String os = System.getProperty("os.name"); |
| String osRegex = "(?i)" + //case insensitive |
| "mac"; //the string: "mac" |
| return Pattern.compile(osRegex).matcher(os).find(); |
| } |
| |
| /** |
| * This method initializes jMenu |
| * |
| * @return javax.swing.JMenu |
| */ |
| private JMenu getHelpMenu() { |
| if (helpMenu == null) { |
| helpMenu = new JMenu(); |
| helpMenu.setFont(UWCLabel.getUWCFont()); |
| helpMenu.setText("Help"); |
| helpMenu.add(getOnlineDocMenu()); |
| helpMenu.add(getAboutMenuItem()); |
| addAccelerator(helpMenu, KeyEvent.VK_H); |
| } |
| return helpMenu; |
| } |
| |
| /** |
| * This method initializes jMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getExitMenuItem() { |
| if (exitMenuItem == null) { |
| exitMenuItem = new JMenuItem(); |
| exitMenuItem.setFont(UWCLabel.getUWCFont()); |
| exitMenuItem.setText(getCloseText()); |
| exitMenuItem.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| shutdownUWC(); |
| } |
| |
| }); |
| addAccelerator(exitMenuItem, getCloseKey(), getOsAccelerator()); |
| exitMenuItem.setPreferredSize(getIncreasedHeight(exitMenuItem)); |
| } |
| return exitMenuItem; |
| } |
| |
| /** |
| * This method initializes jMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getAboutMenuItem() { |
| if (aboutMenuItem == null) { |
| aboutMenuItem = new JMenuItem(); |
| aboutMenuItem.setFont(UWCLabel.getUWCFont()); |
| aboutMenuItem.setText("About"); |
| aboutMenuItem.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| JFrame aboutDialog = getAboutDialog(); |
| aboutDialog.setVisible(true); |
| } |
| }); |
| aboutMenuItem.setPreferredSize(getIncreasedHeight(aboutMenuItem)); |
| aboutMenuItem.setMnemonic(KeyEvent.VK_A); |
| } |
| return aboutMenuItem; |
| } |
| |
| /** |
| * This method initializes aboutDialog |
| * |
| * @return javax.swing.JDialog |
| */ |
| protected JFrame getAboutDialog() { |
| if (aboutDialog == null) { |
| aboutDialog = new SupportWindow("About " + APP_NAME); |
| } |
| return aboutDialog; |
| } |
| |
| /** |
| * This method initializes jMenuItem |
| * |
| * @return javax.swing.JMenuItem |
| */ |
| private JMenuItem getSaveMenuItem() { |
| if (saveMenuItem == null) { |
| saveMenuItem = new JMenuItem(); |
| saveMenuItem.setFont(UWCLabel.getUWCFont()); |
| saveMenuItem.setText("Save"); |
| addAccelerator(saveMenuItem, KeyEvent.VK_S, getOsAccelerator()); |
| saveMenuItem.setPreferredSize(getIncreasedHeight(saveMenuItem)); |
| |
| saveMenuItem.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| save(); |
| } |
| }); |
| } |
| return saveMenuItem; |
| } |
| |
| /** |
| * calculates an increased height for the given item |
| * @param item |
| * @return Dimension representing an increased height for the given item |
| */ |
| private Dimension getIncreasedHeight(JComponent item) { |
| return getIncreasedHeight(item, 6); |
| } |
| |
| /** |
| * calculates an increased height for the given item, with the given increase amount |
| * @param item |
| * @param increase |
| * @return Dimension representing an increased height for the given item |
| */ |
| private Dimension getIncreasedHeight(JComponent item, int increase) { |
| Dimension size = item.getPreferredSize(); |
| size.height += increase; |
| return size; |
| } |
| |
| /** |
| * calculates an increased width for the given item with the given increase amount |
| * @param item |
| * @param increase |
| * @return Dimension representing an increased width for the given item |
| */ |
| private Dimension getIncreasedWidth(JComponent item, int increase) { |
| Dimension size = item.getPreferredSize(); |
| size.width += increase; |
| return size; |
| } |
| |
| /** |
| * @return the correct accelerator mask for the system. |
| * For example: Command for Macs, Control for Windows, etc. |
| */ |
| public static int getOsAccelerator() { |
| return Toolkit.getDefaultToolkit().getMenuShortcutKeyMask(); |
| } |
| |
| /** |
| * @return Shift Mask + correct accelerator for the system. |
| * For example: Shift-Command for Macs |
| */ |
| private int getShiftAccelerator() { |
| int osAccel = getOsAccelerator(); |
| return InputEvent.SHIFT_MASK | osAccel; |
| } |
| |
| /** |
| * sets the given item's accelerator with the given key, and the given accelerator key |
| * @param item menu item which is getting the accelerator set |
| * @param key KeyEvent constant representing a key, Example: KeyEvent.VK_A |
| * @param accelerator KeyEvent constant representing a combo key. Example: InputEvent.CTRL_MASK |
| */ |
| public static void addAccelerator(JMenuItem item, int key, int accelerator) { |
| item.setAccelerator(KeyStroke.getKeyStroke(key, accelerator, true)); |
| } |
| |
| /** |
| * sets the given menu's mnemonic with the given key |
| * @param menu menu item which is getting the mnemonic set |
| * @param key KeyEvent constant representing a key, Example: KeyEvent.VK_S |
| */ |
| private void addAccelerator(JMenu menu, int key) { |
| menu.setMnemonic(key); |
| } |
| |
| /** |
| * adds a separator to the given menu. |
| * @param menu |
| */ |
| public void addSeparator(JMenu menu) { |
| JSeparator separator = new JSeparator(SwingConstants.HORIZONTAL); |
| separator.setForeground(new Color(200, 200, 200)); //224 |
| separator.setPreferredSize(getIncreasedHeight(separator, -1)); |
| menu.add(separator); |
| } |
| |
| /** |
| * This method initializes jCheckBoxAttachmentSize |
| * |
| * @return javax.swing.JCheckBox |
| */ |
| private JCheckBox getJCheckBoxAttachmentSize() { |
| if (jCheckBoxAttachmentSize == null) { |
| jCheckBoxAttachmentSize = new JCheckBox(); |
| jCheckBoxAttachmentSize.setFont(UWCLabel.getUWCFont()); |
| |
| jCheckBoxAttachmentSize.setText(""); //No label - we'll add one somewhere else |
| jCheckBoxAttachmentSize.setSelected(getBooleanSettingFromString(Setting.ATTACHMENT_SIZE, UWCUserSettings.DEFAULT_ATTACHMENT_SIZE)); |
| |
| jCheckBoxAttachmentSize.addItemListener(getAttachmentSizeCheckboxListener()); |
| |
| Observer enableTextFieldObserver = getEnableTextFieldObserver(getJTextFieldAttachmentSize()); |
| getAttachmentSizeCheckboxListener().addObserver(enableTextFieldObserver); |
| |
| AbstractButton otherUiElement = getAttachmentSizeCheckBoxMenuItem(); |
| CheckboxObserver observer = new CheckboxObserver( |
| this, otherUiElement, Setting.ATTACHMENT_SIZE); |
| getAttachmentSizeCheckboxListener().addObserver(observer); |
| |
| } |
| return jCheckBoxAttachmentSize; |
| } |
| |
| /** |
| * @param textfield |
| * @return new EnableTextFieldObserver instantiated with the given textfield |
| */ |
| private Observer getEnableTextFieldObserver(JTextField textfield) { |
| EnableTextFieldObserver observer = new EnableTextFieldObserver(textfield); |
| return observer; |
| } |
| |
| /** |
| * This method initializes jTextFieldAttachmentSize |
| * |
| * @return javax.swing.JTextField |
| */ |
| private JTextField getJTextFieldAttachmentSize() { |
| if (jTextFieldAttachmentSize == null) { |
| jTextFieldAttachmentSize = new JTextField(); |
| jTextFieldAttachmentSize.setFont(UWCLabel.getUWCFont()); |
| SaveListener saveListener = new SaveListener( |
| this.jTextFieldAttachmentSize, |
| this.model, |
| Setting.ATTACHMENT_SIZE, |
| this.feedbackWindow |
| ); |
| jTextFieldAttachmentSize.addActionListener(saveListener); |
| jTextFieldAttachmentSize.addFocusListener(saveListener); |
| jTextFieldAttachmentSize.addKeyListener(new IgnoreAltListener(jTextFieldAttachmentSize)); |
| |
| jTextFieldAttachmentSize.setText(this.model.getSetting(Setting.ATTACHMENT_SIZE)); |
| jTextFieldAttachmentSize.setEnabled(getBooleanSettingFromString(Setting.ATTACHMENT_SIZE, UWCUserSettings.DEFAULT_ATTACHMENT_SIZE)); |
| } |
| return jTextFieldAttachmentSize; |
| } |
| |
| /* General Methods */ |
| |
| /** |
| * @param args |
| */ |
| public static void main(String[] args) { |
| if (args.length > 0) setPropsDir(args[0]); //useful for testing |
| |
| SwingUtilities.invokeLater(new Runnable() { |
| public void run() { |
| UWCForm3 application = new UWCForm3(); |
| application.getJFrame().setVisible(true); |
| } |
| }); |
| } |
| |
| /** |
| * sets the properties directory with the given value. |
| * All proeprties loading will use this value unless it's null |
| * @param value directory containing properties |
| */ |
| private static void setPropsDir(String value) { |
| commandLineArgDir = value; |
| } |
| |
| /** |
| * any necessary init code that isn't handled by getJFrame |
| */ |
| private void init() { |
| //init the logging |
| PropertyConfigurator.configure("log4j.properties"); |
| //init the model |
| model = new UWCGuiModel(); |
| //setup shutdown hooks, important for OS-initiated shutdowns |
| Runtime.getRuntime().addShutdownHook(new Thread(new ShutDownController(this))); |
| } |
| |
| /** |
| * This method initializes jFrame |
| * |
| * @return javax.swing.JFrame |
| */ |
| protected JFrame getJFrame() { |
| if (jFrame == null) { |
| init(); |
| jFrame = new JFrame(); |
| jFrame.setSize(450, 640); |
| jFrame.setLocation(20, 0); //not quite flush with the left edge of the screen |
| jFrame.setContentPane(getJContentPane()); |
| jFrame.setTitle(getAppTitle()); |
| // can't use default close op, 'cause we need to save before closing |
| // jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); |
| // so instead we do this: |
| jFrame.addWindowListener(new java.awt.event.WindowAdapter() { |
| public void windowClosing(java.awt.event.WindowEvent e) { |
| shutdownUWC(); |
| } |
| }); |
| jFrame.setJMenuBar(getJJMenuBar()); //this has to be last, as necessary objects are defined earlier |
| } |
| return jFrame; |
| } |
| |
| /** |
| * @return UWC's official name as displayed on the UI, includes version number |
| */ |
| private String getAppTitle() { |
| String title = APP_NAME; |
| title += " " + VERSION_INDICATOR + VERSION_NUMBER; |
| return title; |
| } |
| |
| /** |
| * This method initializes jContentPane |
| * |
| * @return javax.swing.JPanel |
| */ |
| private JPanel getJContentPane() { |
| if (jContentPane == null) { |
| jContentPane = new JPanel(); |
| jContentPane.setLayout(new BorderLayout()); |
| jContentPane.add(getJTabbedPane(), BorderLayout.NORTH); |
| jContentPane.add(getJPanelMain(), BorderLayout.EAST); |
| } |
| return jContentPane; |
| } |
| |
| /* Convenience Methods */ |
| |
| /** |
| * convenience method for setting a colored border for |
| * a particular component. Useful for layout development. |
| * @param obj |
| * @param color |
| */ |
| private void setBorder(JComponent obj, Color color) { |
| obj.setBorder(new LineBorder(color)); |
| } |
| |
| /** |
| * @return Map of conversion setting components. |
| * Keys are: |
| * attachmentsText |
| * attachmentsButton |
| * pages |
| * add |
| * remove |
| * addMenu |
| * removeMenu |
| * address |
| * login |
| * password |
| * space |
| */ |
| public HashMap<String, Component> getConversionSettingsComponents() { |
| HashMap<String, Component> components = new HashMap<String, Component>(); |
| components.put("attachmentsText", getJTextFieldAttachments()); |
| components.put("attachmentsButton", getJButtonAttachments()); |
| components.put("pages", getJScrollPanePages()); |
| components.put("add", getJButtonAdd()); |
| components.put("remove", getJButtonRemovePages()); |
| components.put("addMenu", getAddMenuItem()); |
| components.put("removeMenu", getRemoveMenuItem()); |
| components.put("address", getJTextfieldAddress()); |
| components.put("login", getJTextFieldLogin()); |
| components.put("password", getJPasswordField()); |
| components.put("space", getJTextFieldSpace()); |
| return components; |
| } |
| |
| /* Inner Classes */ |
| |
| /** |
| * handles any tasks that need to be done before shutdown |
| */ |
| private class ShutDownController implements Runnable { |
| |
| private UWCForm3 form; |
| public ShutDownController(UWCForm3 form) { |
| this.form = form; |
| } |
| public void run() { |
| this.form.preShutdownCleanup(); |
| } |
| |
| } |
| } |
| |