protected void selectFile() {
    ResourceManager rm = ResourceManager.all(FilePropertyEditor.class);

    JFileChooser chooser = UserPreferences.getDefaultDirectoryChooser();

    chooser.setDialogTitle(rm.getString("DirectoryPropertyEditor.dialogTitle"));
    chooser.setApproveButtonText(rm.getString("DirectoryPropertyEditor.approveButtonText"));
    chooser.setApproveButtonMnemonic(rm.getChar("DirectoryPropertyEditor.approveButtonMnemonic"));

    File oldFile = (File) getValue();
    if (oldFile != null && oldFile.isDirectory()) {
      try {
        chooser.setCurrentDirectory(oldFile.getCanonicalFile());
      } catch (IOException e) {
        e.printStackTrace();
      }
    }

    if (JFileChooser.APPROVE_OPTION == chooser.showOpenDialog(editor)) {
      File newFile = chooser.getSelectedFile();
      String text = newFile.getAbsolutePath();
      textfield.setText(text);
      firePropertyChange(oldFile, newFile);
    }
  }
 public boolean exportToTxtFile() {
   Internal internal =
       BookUtil.get(
           this.mainFrame,
           SbConstants.BookKey.EXPORT_DIRECTORY,
           EnvUtil.getDefaultExportDir(this.mainFrame));
   File file1 = new File(internal.getStringValue());
   JFileChooser chooser = new JFileChooser(file1);
   chooser.setApproveButtonText(I18N.getMsg("msg.common.export"));
   chooser.setSelectedFile(new File(getFileName()));
   chooser.setFileFilter(new TextFileFilter());
   int i = chooser.showOpenDialog(this.mainFrame);
   if (i == 1) {
     return false;
   }
   File outFile = chooser.getSelectedFile();
   if (!outFile.getName().endsWith(".txt")) {
     outFile = new File(outFile.getPath() + ".txt");
   }
   StringBuffer buffer = getContent();
   try {
     try (BufferedWriter outStream = new BufferedWriter(new FileWriter(outFile))) {
       String str = buffer.toString();
       outStream.write(HtmlUtil.htmlToText(str, true));
     }
   } catch (IOException e) {
     return false;
   }
   JOptionPane.showMessageDialog(
       this.mainFrame,
       I18N.getMsg("msg.common.export.success") + "\n" + outFile.getAbsolutePath(),
       I18N.getMsg("msg.common.export"),
       1);
   return true;
 }
 private void setupFileChooser() {
   fileChooser = new JFileChooser();
   fileChooser.setDialogTitle("Select directory to output ISArchive to...");
   fileChooser.setDialogType(JFileChooser.OPEN_DIALOG);
   fileChooser.setApproveButtonText("Output to selected directory");
   fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
 }
Beispiel #4
0
  private void importProjectAndData() {
    JFileChooser fileChooser = new JFileChooser();
    fileChooser.setApproveButtonText("Importa");
    fileChooser.setDialogTitle("Importa progetto e  dati");
    fileChooser.addChoosableFileFilter(new GenericFileFilter(".atd", "Arduino Trend Data"));
    int n = fileChooser.showOpenDialog(view);

    if (n == JFileChooser.APPROVE_OPTION) {

      try {
        project.importProjectAndData(fileChooser.getSelectedFile());
        file = null;
        inizializePens(project.getPenModels());
        modelListPens.update(null, null);
        view.setTitle(project.getTitle());
        view.trend.setModel(project.getTrendModel());
        view.trend.setMillsAtFirstRecord();
      } catch (IOException e) {
        view.popupErrorMessage(e.getMessage());
        e.printStackTrace();
      } catch (ClassNotFoundException e) {
        view.popupErrorMessage("File non trovato");
        e.printStackTrace();
      }
    }
  }
Beispiel #5
0
  private void outputFolderBtnActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_outputFolderBtnActionPerformed

    if (chooser == null) {
      chooser = new JFileChooser();
      chooser.setApproveButtonText(options.getMsg("export_project_selectFolder"));
      chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
    }

    outputFolder = StrUtils.nullableString(outputFolderText.getText());
    if (outputFolder != null) {
      try {
        File f = new File(outputFolder);
        if (!f.exists()) {
          f.mkdirs();
        }
        chooser.setSelectedFile(f);
      } catch (Exception ex) {
        // Unable to create folders. By now, do nothing
      }
    }

    if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
      outputFolder = chooser.getSelectedFile().getAbsolutePath();
      outputFolderText.setText(outputFolder);
    }
  } // GEN-LAST:event_outputFolderBtnActionPerformed
 private JFileChooser initFileChooser(String choice) {
   final JFileChooser fileChooser = new JFileChooser();
   fileChooser.setCurrentDirectory(new File(System.getProperty("user.home")));
   fileChooser.setFileFilter(new FileNameExtensionFilter("Ser Files", "ser"));
   fileChooser.setApproveButtonText(choice);
   fileChooser.setDialogTitle(choice);
   return fileChooser;
 }
Beispiel #7
0
  /**
   * Displays a custom file chooser sheet with a custom approve button.
   *
   * @param chooser the chooser
   * @param parent the parent component of the dialog; can be {@code null}
   * @param approveButtonText the text of the {@code ApproveButton}
   * @param listener The listener for SheetEvents.
   */
  public static void showSheet(
      final JFileChooser chooser,
      Component parent,
      String approveButtonText,
      SheetListener listener) {
    if (approveButtonText != null) {
      chooser.setApproveButtonText(approveButtonText);
      chooser.setDialogType(JFileChooser.CUSTOM_DIALOG);
    }

    // Begin Create Dialog
    Frame frame =
        parent instanceof Frame
            ? (Frame) parent
            : (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parent);

    String title = chooser.getUI().getDialogTitle(chooser);
    chooser.getAccessibleContext().setAccessibleDescription(title);

    final JSheet sheet = new JSheet(frame);
    sheet.addSheetListener(listener);

    Container contentPane = sheet.getContentPane();
    contentPane.setLayout(new BorderLayout());
    contentPane.add(chooser, BorderLayout.CENTER);
    // End Create Dialog

    final ActionListener actionListener =
        new ActionListener() {

          public void actionPerformed(ActionEvent evt) {
            int option;
            if (evt.getActionCommand().equals("ApproveSelection")) {
              option = JFileChooser.APPROVE_OPTION;
            } else {
              option = JFileChooser.CANCEL_OPTION;
            }
            sheet.hide();
            sheet.fireOptionSelected(chooser, option);
            chooser.removeActionListener(this);
          }
        };
    chooser.addActionListener(actionListener);
    sheet.addWindowListener(
        new WindowAdapter() {

          @Override
          public void windowClosing(WindowEvent e) {
            sheet.fireOptionSelected(chooser, JFileChooser.CANCEL_OPTION);
            chooser.removeActionListener(actionListener);
          }
        });
    chooser.rescanCurrentDirectory();
    sheet.pack();
    sheet.show();
    sheet.toFront();
  }
  /**
   * Returns a new <tt>JFileChooser</tt> instance for selecting directories and with
   * internationalized strings for the caption and the selection button.
   *
   * @param approveKey can be <code>null</code>
   * @param directory can be <code>null</code>
   * @param filter can be <code>null</code>
   * @return a new <tt>JFileChooser</tt> instance for selecting directories.
   */
  private static JFileChooser getDirectoryChooser(
      String titleKey, String approveKey, File directory, int mode, FileFilter filter) {
    JFileChooser chooser = null;
    if (directory == null) directory = getLastInputDirectory();

    if (directory == null) {
      chooser = new JFileChooser();
    } else {
      try {
        chooser = new JFileChooser(directory);
      } catch (NullPointerException e) {
        // Workaround for JRE bug 4711700. A NullPointer is thrown
        // sometimes on the first construction under XP look and feel,
        // but construction succeeds on successive attempts.
        try {
          chooser = new JFileChooser(directory);
        } catch (NullPointerException npe) {
          // ok, now we use the metal file chooser, takes a long time to load
          // but the user can still use the program
          UIManager.getDefaults().put("FileChooserUI", "javax.swing.plaf.metal.MetalFileChooserUI");
          chooser = new JFileChooser(directory);
        }
      } catch (ArrayIndexOutOfBoundsException ie) {
        // workaround for Windows XP, not sure if second try succeeds
        // then
        chooser = new JFileChooser(directory);
      }
    }
    if (filter != null) {
      chooser.setFileFilter(filter);
    } else {
      if (mode == JFileChooser.DIRECTORIES_ONLY) {
        chooser.setFileFilter(
            new FileFilter() {
              public boolean accept(File file) {
                return true;
              }

              public String getDescription() {
                return I18n.tr("All Folders");
              }
            });
      }
    }
    chooser.setFileSelectionMode(mode);
    String title = I18n.tr(titleKey);
    chooser.setDialogTitle(title);

    if (approveKey != null) {
      String approveButtonText = I18n.tr(approveKey);
      chooser.setApproveButtonText(approveButtonText);
    }
    return chooser;
  }
Beispiel #9
0
  public void selectFile() {
    final JFileChooser chooser = new JFileChooser(overlays.defaultDirectory);
    chooser.setFileFilter(
        GuiUtils.getCustomFileFilter(I18n.text("LSF log files"), new String[] {"lsf", "lsf.gz"}));
    chooser.setApproveButtonText(I18n.text("Open Log"));

    int option = chooser.showOpenDialog(overlays.getConsole());
    if (option != JFileChooser.APPROVE_OPTION) return;
    else {
      Thread logLoading =
          new Thread(
              new Runnable() {

                @Override
                public void run() {
                  final ProgressMonitor monitor =
                      new ProgressMonitor(
                          overlays.getConsole(),
                          I18n.text("Opening LSF log"),
                          I18n.text("Opening LSF log"),
                          0,
                          100);
                  try {
                    clearOverlays();
                    fileLabel.setText("loading...");
                    logFile = chooser.getSelectedFile();
                    LsfLogSource source =
                        new LsfLogSource(
                            chooser.getSelectedFile(),
                            new LsfIndexListener() {
                              @Override
                              public void updateStatus(String messageToDisplay) {
                                monitor.setNote(messageToDisplay);
                              }
                            });
                    logSource = source;
                    loadOverlays(source);
                  } catch (Exception e) {
                    GuiUtils.errorMessage(overlays.getConsole(), e);
                  }
                  SwingUtilities.invokeLater(
                      new Runnable() {
                        @Override
                        public void run() {
                          fileLabel.setText(chooser.getSelectedFile().getParentFile().getName());
                        }
                      });
                  monitor.close();
                  overlays.defaultDirectory = chooser.getSelectedFile().getParent();
                }
              });
      logLoading.start();
    }
  }
Beispiel #10
0
 private String getFileName(String title, String okButton, String currentDirectory) {
   JFileChooser fileChooser = new JFileChooser();
   fileChooser.setDialogTitle(title);
   fileChooser.setApproveButtonText(okButton);
   fileChooser.setCurrentDirectory(new File(currentDirectory));
   int result = fileChooser.showOpenDialog(this);
   if (result == JFileChooser.APPROVE_OPTION) {
     File selectedFile = fileChooser.getSelectedFile();
     return selectedFile.getAbsolutePath();
   }
   return null;
 }
 @Action
 public void browse() {
   File l = new File(diskLocation);
   if (l.isDirectory()) {
     chooser.setCurrentDirectory(l);
   }
   chooser.setApproveButtonText("Select");
   int returnval = chooser.showOpenDialog(null);
   if (returnval == JFileChooser.APPROVE_OPTION) {
     File f = chooser.getSelectedFile();
     setDiskLocation(f.getAbsolutePath());
   }
 } // GEN-LAST:event_selectType
Beispiel #12
0
  /** Creates new form ConfigDialog */
  public ConfigDialog() {
    initComponents();

    saveNames =
        Arrays.asList(
            saveNameTextField1, saveNameTextField2, saveNameTextField3, saveNameTextField4);
    savePaths =
        Arrays.asList(
            savePathTextField1, savePathTextField2, savePathTextField3, savePathTextField4);

    fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
    fileChooser.setApproveButtonText(messages.getString("select"));
  }
Beispiel #13
0
  private void createSaveButton() {
    saveButton = new JButton("Save");
    fileChooser = new JFileChooser();

    fileChooser.setApproveButtonText("Export");
    fileChooser.setApproveButtonToolTipText("Export your file!");

    saveButton.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent e) {

            int retrival = fileChooser.showOpenDialog(null);
            if (retrival == JFileChooser.APPROVE_OPTION) { // IF A FILE WAS
              // CHOSEN THE IF
              // STATEMENT IS
              // TRUE

              try (PrintStream fw = new PrintStream(fileChooser.getSelectedFile() + ".txt")) {

                fw.println("To: " + toField.getText());
                fw.println(
                    "____________________________________________________________________________________________________________");
                fw.println();
                fw.println("Subject: " + subjectField.getText());
                fw.println(
                    "____________________________________________________________________________________________________________");
                fw.println();

                char[] textAreaArray = referenceTextArea.getText().toCharArray();
                StringBuilder textAreaStringBuilder = new StringBuilder();
                for (int i = 0; i < textAreaArray.length; i++) {

                  textAreaStringBuilder.append(textAreaArray[i]);

                  if (i == 30) {

                    fw.println();
                  }
                }

                fw.println(textAreaStringBuilder.toString());

              } catch (Exception ex) {
                ex.printStackTrace();
              }
            }
          }
        });
  }
Beispiel #14
0
		/**
		 * Creates a new BrowseButtonAction and initializes it with filters.
		 *
		 * @param filters filter collection
		 * @param allFilters wheter the all files filter should be included
		 */
		public BrowseButtonAction(HashMap<String, String[]> filters, boolean allFilters) {
			super();
			fileChooser = new JFileChooser();
			fileChooser.setApproveButtonText(_("Ok"));

			fileChooser.setAcceptAllFileFilterUsed(allFilters);

			for (String description : filters.keySet()) {

				FileNameExtensionFilter filter = new FileNameExtensionFilter(description, filters.get(description));
				fileChooser.addChoosableFileFilter(filter);
			}

			this.filters = filters;
		}
  private void openRecordPathFileChooser() {
    JFileChooser fc = new JFileChooser();
    fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
    fc.setDialogType(JFileChooser.SAVE_DIALOG);

    fc.setApproveButtonText(ControlMain.getProperty("msg_choose"));
    fc.setApproveButtonToolTipText(ControlMain.getProperty("msg_chooseDirectory"));
    int returnVal = fc.showSaveDialog(null);

    if (returnVal == JFileChooser.APPROVE_OPTION) {
      String path = fc.getSelectedFile().toString();
      this.getView().getJTextFieldRecordSavePath().setText(path);
      this.getTimer().setSavePath(path);
    }
  }
Beispiel #16
0
  private void selectFolder() {

    JFileChooser fileChooser = new JFileChooser();
    fileChooser.setCurrentDirectory(new File(textFolder.getText()));
    fileChooser.setDialogTitle(CAPTION_SELECT_FOLDER);
    fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
    fileChooser.setApproveButtonText("Select");
    fileChooser.setApproveButtonToolTipText(TOOL_TIP_SELECT_FOLDER);

    if (fileChooser.showOpenDialog(FileTransferServer.this) == JFileChooser.APPROVE_OPTION) {
      // Get the selected file
      String path = fileChooser.getSelectedFile().getPath() + "\\";
      textFolder.setText(path);
    }
  }
Beispiel #17
0
  public void init() {
    tabbedPane.addMouseListener(
        new MouseAdapter() {
          public void mousePressed(MouseEvent e) {
            if (e.getModifiers() == InputEvent.BUTTON3_MASK) {
              contextMenu.show(e.getComponent(), e.getX(), e.getY());
            }
          }

          public void mouseReleased(MouseEvent e) {}
        });
    fileChooser = new JFileChooser();
    fileChooser.setDialogTitle("Save file");
    fileChooser.setApproveButtonText("Save file");
    fileChooser.setDialogType(JFileChooser.SAVE_DIALOG);
  }
 /** Action to perform */
 public void actionPerformed(ActionEvent e) {
   if (e.getSource() == appdirChooser) {
     JFileChooser fileChooser = new JFileChooser();
     fileChooser.setDialogTitle("Select an Application Directory");
     fileChooser.setApproveButtonText("OK");
     if (!appDirTF.getText().equals(""))
       fileChooser.setCurrentDirectory(new File(appDirTF.getText()));
     fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
     int result = fileChooser.showOpenDialog(this);
     // if we selected an image, load the image
     if (result == JFileChooser.APPROVE_OPTION) {
       String path = fileChooser.getSelectedFile().getPath();
       appDirTF.setText(path);
     }
   }
 }
  private void localizarButtonActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_localizarButtonActionPerformed

    try {
      JFileChooser chooser = null;
      if (StringHelper.isBlank(field.getText())) {
        chooser = new JFileChooser(System.getProperty("user.home"));
      } else {
        chooser = new JFileChooser(field.getText());
      }

      FileNameExtensionFilter extension = new FileNameExtensionFilter("Arquivo Xml (*.xml)", "xml");
      chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
      chooser.setAcceptAllFileFilterUsed(false);
      chooser.setFileFilter(extension);
      chooser.setFileHidingEnabled(true);
      chooser.setMultiSelectionEnabled(true);

      chooser.setApproveButtonText("Abrir");

      int choice = chooser.showOpenDialog(this);

      if (choice == JFileChooser.APPROVE_OPTION) {
        File oneFile = chooser.getSelectedFile();

        String path = null;
        path = oneFile.getPath();
        String nomeArquivo = StringHelper.substringAfterLast(path, SO.getSepArqSO());
        String caminhoArq = StringHelper.substringBeforeLast(path, SO.getSepArqSO());
        if (defaultListModel.contains(new InfoArq(nomeArquivo, caminhoArq))) {
          throw new Exception("O arquivo com este mesmo caminho ja existe na lista abaixo!");
        }
        field.setText(path.substring(0, path.lastIndexOf(SO.getSepArqSO())));

        File[] files = chooser.getSelectedFiles();
        for (File file : files) {
          defaultListModel.addElement(
              new InfoArq(
                  file.getName(),
                  StringHelper.substringBeforeLast(file.getPath(), SO.getSepArqSO())));
        }
      }
    } catch (Exception ex) {
      ex.printStackTrace();
      JMessageUtil.showInfoMessage(this, ex.getMessage());
    }
  } // GEN-LAST:event_localizarButtonActionPerformed
Beispiel #20
0
  // When called, opens a file chooser
  public static void start() {

    FileNameExtensionFilter filter = new FileNameExtensionFilter("Synth File", ".synth");
    JFileChooser saveFile = new JFileChooser();

    // Set file chooser properties
    saveFile.setDialogTitle("Save");
    saveFile.setApproveButtonText("Save");
    saveFile.setSelectedFile(new File(filename));
    saveFile.setFileFilter(filter);

    // If valid choice is made, run fileWrite with this file
    if (saveFile.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
      filename = saveFile.getSelectedFile().getName();
      fileWrite(saveFile.getCurrentDirectory().toString());
    }
  }
Beispiel #21
0
  /** Constructor */
  public SaverCustomizer() {

    try {
      m_SaverEditor.addPropertyChangeListener(
          new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent e) {
              repaint();
              if (m_dsSaver != null) {
                System.err.println("Property change!!");
                m_dsSaver.setSaver(m_dsSaver.getSaver());
              }
            }
          });
      repaint();
    } catch (Exception ex) {
      ex.printStackTrace();
    }
    setLayout(new BorderLayout());
    m_fileChooser.setDialogType(JFileChooser.SAVE_DIALOG);
    m_fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
    m_fileChooser.setApproveButtonText("Select directory");
    m_fileChooser.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent e) {
            if (e.getActionCommand().equals(JFileChooser.APPROVE_SELECTION)) {
              try {
                File selectedFile = m_fileChooser.getSelectedFile();
                m_directoryText.setText(selectedFile.toString());

                /* (m_dsSaver.getSaver()).setFilePrefix(m_prefixText.getText());
                (m_dsSaver.getSaver()).setDir(m_fileChooser.getSelectedFile().getPath());
                m_dsSaver.
                  setRelationNameForFilename(m_relationNameForFilename.isSelected()); */

              } catch (Exception ex) {
                ex.printStackTrace();
              }
            }
            // closing
            if (m_fileChooserFrame != null) {
              m_fileChooserFrame.dispose();
            }
          }
        });
  }
Beispiel #22
0
  private void exportProjectAndData() {
    JFileChooser fileChooser = new JFileChooser();
    fileChooser.setApproveButtonText("Esporta");
    fileChooser.setDialogTitle("Esporta progetto e dati");
    fileChooser.addChoosableFileFilter(new GenericFileFilter(".csv", "File generico csv"));
    fileChooser.addChoosableFileFilter(new GenericFileFilter(".atd", "Arduino Trend Data"));

    int n = fileChooser.showSaveDialog(view);

    if (n == JFileChooser.APPROVE_OPTION) {
      File file = fileChooser.getSelectedFile();
      FileFilter currentFilter = fileChooser.getFileFilter();
      if (currentFilter instanceof GenericFileFilter) {
        String ext = ((GenericFileFilter) currentFilter).getExtension();
        if (file.getName().endsWith(ext) == false) {
          try {
            file = new File(file.getCanonicalPath() + ext);
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
      }
      int a = JOptionPane.OK_OPTION;
      if (file.exists()) {
        a = JOptionPane.showConfirmDialog(view, "Vuoi sovrascire il file?");
      }
      switch (a) {
        case JOptionPane.OK_OPTION:
          try {
            project.exportProject(file, pens, view.trend.getModel());
          } catch (IOException e) {
            view.popupErrorMessage(e.getMessage());
            e.printStackTrace();
          }
          break;
        case JOptionPane.NO_OPTION:
          exportProjectAndData();
          break;
        case JOptionPane.CANCEL_OPTION:
          System.out.println("CANCEL");
          break;
      }
    }
  }
 /** Uses a {@link JFileChooser} to get a database location */
 private static String chooseDatabaseLocation(final IWindowUtils windowUtils) {
   final JFileChooser fileChooser = new JFileChooser();
   fileChooser.setDialogTitle("Select Database");
   fileChooser.setApproveButtonText("Use this Database");
   final int result = fileChooser.showDialog(null, null);
   if (result == JFileChooser.APPROVE_OPTION) {
     return fileChooser.getSelectedFile().getAbsolutePath();
   } else {
     if (windowUtils.showWarningQuestionMessage(
         "Apprentice needs a database!\nDo you want to go back and select or create a new one?\nOtherwise the program will terminate.",
         "Database")) {
       return chooseDatabaseLocation(windowUtils);
     } else {
       LOG.info("Shut down due to lack of database.");
       System.exit(0);
     }
   }
   return ""; // kinda unreachable
 }
Beispiel #24
0
 /** 实现对打开文件的处理 */
 public void openAnswer() {
   if (answer == 0) {
     cb.canPlay = true;
     File file = null;
     JFileChooser fileChooser = new JFileChooser();
     fileChooser.setApproveButtonText("确定");
     fileChooser.setDialogTitle("打开文件");
     fileChooser.setCurrentDirectory(new File("SavaAndOpen"));
     int result = fileChooser.showOpenDialog(gc); // 显示选择框
     if (result == JFileChooser.APPROVE_OPTION) { // 选择的是确定按钮
       file = fileChooser.getSelectedFile(); // 得到选择的文件
       cb.repaint();
     }
     if (file != null) {
       try {
         DataInputStream dis = new DataInputStream(new FileInputStream(file));
         for (int i = 0; i < 8; i++) {
           for (int j = 0; j < 8; j++) {
             allChess[i][j] = dis.readInt();
           }
         }
         cb.message = dis.readUTF();
         cb.isBlack = dis.readBoolean();
         if (cb.isBlack == false) { // 如果是和电脑下且轮到白子下
           cb.ch.playWithCom();
         }
         cb.changeColor = dis.readBoolean();
         cb.isStop = dis.readBoolean();
         if (cb.computerPlay == false) { // 如果不和电脑下,发送信息
           cb.send(cc.dos);
         }
         dis.close();
         cb.repaint();
       } catch (Exception e1) {
       }
     }
   }
   if (answer != 0) {
     JOptionPane.showMessageDialog(cb, "对方拒绝了你的请求!");
   }
   answer = 3;
 }
 /**
  * Load the app configuration from the external file
  *
  * @param path The full path of the configuration file
  */
 private void loadFromFile() {
   JFileChooser fileChooser = new JFileChooser();
   fileChooser.setDialogTitle("Select a Model File");
   fileChooser.setApproveButtonText("OK");
   if (!pictureFileName.getText().equals(""))
     fileChooser.setCurrentDirectory(new File(pictureFileName.getText()));
   else {
     try {
       if (engine.appManager.currentApp.getAppDir() != null)
         fileChooser.setCurrentDirectory(new File(engine.appManager.currentApp.getAppDir()));
     } catch (Exception ex) {
     }
   }
   fileChooser.setFileFilter(
       new FileFilterUtils(new String[] {"xml"}, true, "XML File (*.xml)"));
   int result = fileChooser.showOpenDialog(this);
   // if we selected an image, load the image
   if (result == JFileChooser.APPROVE_OPTION) {
     String path = fileChooser.getSelectedFile().getPath();
     pictureFileName.setText(path.trim());
   }
 }
Beispiel #26
0
  public void setPath() {

    if (saveDir == null) {
      saveDir = DirectoryManager.getUserHomeDirectory();
    }

    JFileChooser fc = new JFileChooser(saveDir);
    fc.setApproveButtonText("Set");
    // fc.setDialogType(JFileChooser.SAVE_DIALOG );

    fc.setFileSelectionMode(javax.swing.JFileChooser.DIRECTORIES_ONLY);
    fc.setMultiSelectionEnabled(false);
    int returnVal = fc.showOpenDialog(null);
    // int returnVal = fc.showSaveDialog(null);

    if (returnVal == JFileChooser.APPROVE_OPTION) {
      saveDir = fc.getSelectedFile();
      getSaveDirTextField().setText(saveDir.getPath());
    }
    // String srcDirName  = getWorkDirComboBox().getSelectedItem().toString();
    // File  dst          = new File (saveDir, srcDirName);

  }
Beispiel #27
0
  public void actionPerformed(ActionEvent ae) {
    JDialog saveDialog = new JDialog(MainFrame.getInstance(), "Save Termbank as CSV", true);
    MainFrame.getGuiRoots().add(saveDialog);
    saveDialog.setLayout(new BorderLayout());
    SliderPanel sliderPanel = new SliderPanel(termbank, "save", true, null);
    saveDialog.add(sliderPanel, BorderLayout.CENTER);

    JPanel chooserPanel = new JPanel();
    chooserPanel.setLayout(new BoxLayout(chooserPanel, BoxLayout.Y_AXIS));
    chooserPanel.add(new JSeparator());

    JFileChooser chooser = new JFileChooser();
    FileNameExtensionFilter filter =
        new FileNameExtensionFilter("CSV files", Utilities.EXTENSION_CSV);
    chooser.setFileFilter(filter);
    chooser.setApproveButtonText("Save");
    chooser.addActionListener(
        new CsvFileSelectionActionListener(chooser, termbank, sliderPanel, saveDialog, Mode.SAVE));
    chooserPanel.add(chooser);
    saveDialog.add(chooserPanel, BorderLayout.SOUTH);
    saveDialog.pack();
    saveDialog.setLocationRelativeTo(saveDialog.getOwner());
    saveDialog.setVisible(true);
  }
  /** Allows subclasses to modify the chooser to suit their needs. */
  protected JFileChooser createFileChooser() {
    File originalFile = (File) getValue();

    final JFileChooser chooser = new JFileChooser();
    chooser.setFileSelectionMode(mode);
    if (originalFile != null && originalFile.getParent() != null)
      chooser.setCurrentDirectory(new File(originalFile.getParent()));
    chooser.setSelectedFile(originalFile);
    chooser.setApproveButtonText(bundle.getString("CTL_ApproveSelect"));
    chooser.setApproveButtonToolTipText(bundle.getString("CTL_ApproveSelectToolTip"));
    switch (mode) {
      case JFileChooser.FILES_AND_DIRECTORIES:
        chooser.setDialogTitle(bundle.getString("CTL_DialogTitleFilesAndDirs"));
        break;
      case JFileChooser.FILES_ONLY:
        chooser.setDialogTitle(bundle.getString("CTL_DialogTitleFiles"));
        break;
      case JFileChooser.DIRECTORIES_ONLY:
        chooser.setDialogTitle(bundle.getString("CTL_DialogTitleDirs"));
        break;
    }

    return chooser;
  }
Beispiel #29
0
  @Override
  public void actionPerformed(final ActionEvent e) {
    beforeAction(e);

    final ResourceBundle appMessages =
        ResourceBundle.getBundle(
            "application", ServiceLocator.get(ConfigurationManager.class).get().getLocale());

    final Component parent;
    if (e.getSource() instanceof Component) parent = (Component) e.getSource();
    else parent = null;

    JFileChooser chooser = new JFileChooser();
    File defaultFile =
        ServiceLocator.get(ConfigurationManager.class).get().getLastExportPath().getParentFile();
    chooser.setCurrentDirectory(defaultFile);
    chooser.setFileFilter(
        new FileNameExtensionFilter("*." + format.toString().toLowerCase(), format.toString()));
    chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
    chooser.setDialogType(JFileChooser.SAVE_DIALOG);
    chooser.setApproveButtonText(appMessages.getString("exportDialog.approve"));
    chooser.setApproveButtonMnemonic(
        KeyStroke.getKeyStroke(appMessages.getString("exportDialog.approve.mnemonic"))
            .getKeyCode());
    chooser.setApproveButtonToolTipText(
        ServiceLocator.get(TooltipFactory.class)
            .getDecorated(
                appMessages.getString("exportDialog.approve.tooltip.message"),
                appMessages.getString("exportDialog.approve.tooltip.title"),
                "save.png",
                KeyStroke.getKeyStroke(
                    "alt " + appMessages.getString("exportDialog.approve.mnemonic"))));
    if (chooser.showDialog(parent, null) == JFileChooser.APPROVE_OPTION) {
      chooserApproved(e);

      File f = chooser.getSelectedFile();
      if (!chooser.accept(f)) {
        f = new File(f.toString() + "." + format.toString().toLowerCase());
      }
      ServiceLocator.get(ConfigurationManager.class).get().setLastExportPath(f);

      if (f.exists()) {
        if (JOptionPane.showConfirmDialog(
                parent,
                MessageFormat.format(
                    appMessages.getString("exportDialog.overwrite"), new Object[] {f}),
                appMessages.getString("exportDialog.overwrite.title"),
                JOptionPane.YES_NO_OPTION,
                JOptionPane.QUESTION_MESSAGE,
                null)
            != JOptionPane.YES_OPTION) {
          return;
        }
      }

      final File file = f;

      final ExportOptions options = format.askForOptions(origami);

      final JDialog progressDialog = new JDialog();
      final JProgressBar bar = new JProgressBar(0, format.getNumOfProgressChunks(origami, options));
      bar.setStringPainted(true);
      bar.setString(appMessages.getString("exporting.no.percentage"));
      progressDialog.getContentPane().setLayout(new FlowLayout());
      progressDialog.setUndecorated(true);
      progressDialog.setAlwaysOnTop(true);
      progressDialog.setLocationRelativeTo(null);

      final SwingWorker<Set<File>, Void> worker =
          new SwingWorker<Set<File>, Void>() {

            private int chunksReceived = 0;

            @Override
            protected Set<File> doInBackground() throws Exception {
              final Runnable progressCallback =
                  new Runnable() {
                    @Override
                    public void run() {
                      publish(new Void[] {null});
                      if (isCancelled()) throw new RuntimeException();
                    }
                  };

              return ServiceLocator.get(OrigamiHandler.class)
                  .export(origami, file, format, options, progressCallback);
            }

            @Override
            protected void process(List<Void> chunks) {
              chunksReceived += chunks.size();
              bar.setValue(chunksReceived);
              bar.setString(
                  MessageFormat.format(
                      appMessages.getString("exporting.percentage"), bar.getPercentComplete()));
            }

            @Override
            protected void done() {
              progressDialog.setVisible(false);
              progressDialog.dispose();
              try {
                if (!isCancelled()) {
                  Set<File> resultFiles = get();
                  StringBuilder b = new StringBuilder();
                  for (File f : resultFiles) b.append("\n").append(f.toString());
                  JOptionPane.showMessageDialog(
                      parent,
                      MessageFormat.format(
                          appMessages.getString("exportSuccessful.message"),
                          new Object[] {b.toString(), resultFiles.size()}),
                      appMessages.getString("exportSuccessful.title"),
                      JOptionPane.INFORMATION_MESSAGE,
                      null);
                }
              } catch (HeadlessException e) {
                JOptionPane.showMessageDialog(
                    parent,
                    MessageFormat.format(
                        appMessages.getString("failedToExport.message"),
                        new Object[] {file.toString()}),
                    appMessages.getString("failedToExport.title"),
                    JOptionPane.ERROR_MESSAGE,
                    null);
                Logger.getLogger("application").warn("Unable to export origami.", e);
              } catch (InterruptedException e) {
                JOptionPane.showMessageDialog(
                    parent,
                    MessageFormat.format(
                        appMessages.getString("failedToExport.message"),
                        new Object[] {file.toString()}),
                    appMessages.getString("failedToExport.title"),
                    JOptionPane.ERROR_MESSAGE,
                    null);
                Logger.getLogger("application").warn("Unable to export origami.", e);
              } catch (ExecutionException e) {
                JOptionPane.showMessageDialog(
                    parent,
                    MessageFormat.format(
                        appMessages.getString("failedToExport.message"),
                        new Object[] {file.toString()}),
                    appMessages.getString("failedToExport.title"),
                    JOptionPane.ERROR_MESSAGE,
                    null);
                Logger.getLogger("application").warn("Unable to export origami.", e);
              }
              ExportAction.this.done(e);
            }
          };

      progressDialog.getContentPane().add(bar);
      JButton cancel = new JButton();
      cancel.setAction(
          new AbstractAction() {
            /** */
            private static final long serialVersionUID = 104733262578076493L;

            @Override
            public void actionPerformed(ActionEvent e) {
              worker.cancel(true);
            }
          });
      cancel.setText(appMessages.getString("buttons.cancel"));
      progressDialog.getContentPane().add(cancel);

      progressDialog.pack();

      progressDialog.setVisible(true);
      worker.execute();
    } else {
      if (e.getSource() instanceof JComponent)
        ((JComponent) e.getSource()).setCursor(Cursor.getDefaultCursor());
    }
  }
Beispiel #30
0
		/**
		 * Creates a new BrowseButtonAction and initializes it.
		 */
		public BrowseButtonAction() {
			super();
			fileChooser = new JFileChooser();
			fileChooser.setApproveButtonText(_("Ok"));
		}