Beispiel #1
0
 /** Update all the store-able properties to their current values */
 public void updateProperties() {
   // Kept up-to-date with event listeners
   // Manager.actorDetails.visible
   // Manager.groupTable.autoResize
   propertyBag.setProperty(
       "Manager.splitHorizontal.dividerLocation",
       String.valueOf(jSplitPaneHorizontal.getDividerLocation()));
   propertyBag.setProperty(
       "Manager.splitVertical.dividerLocation",
       String.valueOf(jSplitPaneVertical.getDividerLocation()));
   propertyBag.setProperty("Manager.location.x", String.valueOf(getLocation().x));
   propertyBag.setProperty("Manager.location.y", String.valueOf(getLocation().y));
   propertyBag.setProperty("Manager.size.width", String.valueOf(getSize().width));
   propertyBag.setProperty("Manager.size.height", String.valueOf(getSize().height));
   propertyBag.setProperty(
       "Manager.groupFileChooser.defaultLocation",
       groupFileChooser.getCurrentDirectory().getPath());
   propertyBag.setProperty(
       "Manager.gcaFileChooser.defaultLocation", gcaFileChooser.getCurrentDirectory().getPath());
   // Optional properties
   if (saveAsFile != null) {
     propertyBag.setProperty("Manager.currentLoadedFile", saveAsFile.getAbsolutePath());
   } else {
     propertyBag.remove("Manager.currentLoadedFile");
   }
   groupTable.updateProperties(); // Update properties for the table
 }
 @Override
 public void actionPerformed(ActionEvent e) {
   JFileChooser chooser = new JFileChooser();
   if (optionsPane != null) {
     chooser.setCurrentDirectory(new File(Settings.getSettings().getInstallPath()));
     chooser.setDialogTitle(choosertitle);
     chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
     chooser.setAcceptAllFileFilterUsed(false);
     if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
       Logger.logInfo("getCurrentDirectory(): " + chooser.getCurrentDirectory());
       Logger.logInfo("getSelectedFile() : " + chooser.getSelectedFile());
       optionsPane.setInstallFolderText(chooser.getSelectedFile().getPath());
     } else {
       Logger.logWarn("No Selection.");
     }
   } else if (editMPD != null) {
     if (!Settings.getSettings().getLastAddPath().isEmpty()) {
       chooser.setCurrentDirectory(new File(Settings.getSettings().getLastAddPath()));
     }
     chooser.setDialogTitle("Please select the mod to install");
     chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
     chooser.setAcceptAllFileFilterUsed(true);
     if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
       File destination = new File(editMPD.folder, chooser.getSelectedFile().getName());
       if (!destination.exists()) {
         try {
           FileUtils.copyFile(chooser.getSelectedFile(), destination);
           Settings.getSettings().setLastAddPath(chooser.getSelectedFile().getPath());
           LaunchFrame.getInstance().saveSettings();
         } catch (IOException e1) {
           Logger.logError(e1.getMessage());
         }
         editMPD.updateLists();
       } else {
         ErrorUtils.tossError("File already exists, cannot add mod!");
       }
     } else {
       Logger.logWarn("No Selection.");
     }
   } else {
     chooser.setCurrentDirectory(new File(Settings.getSettings().getInstallPath()));
     chooser.setDialogTitle(choosertitle);
     chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
     chooser.setAcceptAllFileFilterUsed(false);
     if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
       Logger.logInfo("getCurrentDirectory(): " + chooser.getCurrentDirectory());
       Logger.logInfo("getSelectedFile() : " + chooser.getSelectedFile());
       installDialog.setInstallFolderText(chooser.getSelectedFile().getPath());
     } else {
       Logger.logWarn("No Selection.");
     }
   }
 }
 public void actionPerformed(ActionEvent ae) {
   String cmd = ae.getActionCommand();
   if (JOkCancelPanel.OK.equals(cmd)) {
     // update evaluator
     evaluator.name = tfName.getText();
     evaluator.type = (byte) cbType.getSelectedIndex();
     evaluator.ignoreDiagonals = cbDiagonals.isSelected();
     evaluator.investments = (byte) cbInvestment.getSelectedIndex();
     evaluator.orgFile = orgFile;
     setVisible(false);
   } else if (JOkCancelPanel.CANCEL.equals(cmd)) {
     // don't update evaluator
     setVisible(false);
   } else if (CMD_CHOOSE_FILE.equals(cmd)) {
     // get a file dialog
     JFrame f = new JFrame();
     JFileChooser jfc = Application.getFileChooser();
     int res = jfc.showOpenDialog(f);
     Application.setWorkingDirectory(jfc.getCurrentDirectory());
     if (res == JFileChooser.CANCEL_OPTION) {
       return;
     }
     orgFile = jfc.getSelectedFile();
     lOrgFileName.setText("File: " + orgFile.getName());
   }
 }
  private void findPresentation() {
    JFileChooser fileChooser = new JFileChooser();
    if (lastDirectory_ != null) fileChooser.setCurrentDirectory(lastDirectory_);
    // if (imc.lecturnity.converter.ConverterWizard.USE_CUSTOM_COLORS)
    if (USE_CUSTOM_COLORS) fileChooser.setBackground(Wizard.BG_COLOR);
    LecturnityFileFilter lff = new LecturnityFileFilter();
    fileChooser.addChoosableFileFilter(lff);
    LpdFileFilter lpf = new LpdFileFilter();
    fileChooser.addChoosableFileFilter(lpf);
    EPresentationFileFilter eff = new EPresentationFileFilter();
    fileChooser.addChoosableFileFilter(eff);
    AofFileFilter aff = new AofFileFilter();
    fileChooser.addChoosableFileFilter(aff);
    fileChooser.addChoosableFileFilter(fileChooser.getAcceptAllFileFilter());
    fileChooser.setFileFilter(lff);

    Dimension fcSize = fileChooser.getPreferredSize();
    fileChooser.setPreferredSize(new Dimension(fcSize.width + 100, fcSize.height + 50));

    int action = fileChooser.showOpenDialog(this);

    lastDirectory_ = fileChooser.getCurrentDirectory();

    if (action == fileChooser.APPROVE_OPTION) {
      File selectedFile = fileChooser.getSelectedFile();
      presentationFileField_.setText(selectedFile.getAbsolutePath());
    }
  }
  @SuppressWarnings("null")
  @Test
  public void RememberLastSaveLocationFileChooserIsNull() throws Exception {
    String assertPath = "C:\\";
    Field fileChooser = fileHandler.getClass().getDeclaredField("saveFileChooser");

    fileChooser.setAccessible(true);
    // fileChooser.set(fileHandler, null);

    Constants.last_saved_path = assertPath;
    Main.getInstance().setCurrentDiagramHandler(handler);
    Object obj = null;
    Method[] meths = fileHandler.getClass().getDeclaredMethods();
    for (Method method : meths) {
      if (method.getName().equals("reloadSaveFileChooser")) {
        method.setAccessible(true);
        obj = method.invoke(fileHandler, new Boolean(false));
      }
    }
    Assert.assertNotNull("The FileChooser is null!", obj);
    if (obj != null) {
      JFileChooser jfc = (JFileChooser) obj;
      File file = jfc.getCurrentDirectory();
      Assert.assertEquals("The path is not the last saved path!", assertPath, file.getPath());
    }
  }
Beispiel #6
0
    public void actionPerformed(ActionEvent ev) {

      try {

        String[] logFiles = new String[] {"log"};

        JFileChooser chooser = new JFileChooser();
        chooser.setDialogTitle("Opening log file...");
        chooser.setMultiSelectionEnabled(false);
        chooser.addChoosableFileFilter(new SimpleFileFilter(logFiles, "Log files (*.log)"));
        chooser.setCurrentDirectory(workingDirectory);

        chooser.showOpenDialog(Utils.getActiveFrame());
        File file = chooser.getSelectedFile();
        logFilename = file.getAbsolutePath();
        System.out.println("Opened " + logFilename + "\n");

        File tmpDir = chooser.getCurrentDirectory();

        if (tmpDir != null) {
          workingDirectory = tmpDir;
        }

      } catch (Exception e) {
        System.err.println("Could not Open! \n");
      }
    }
  @Override
  public void actionPerformed(final ActionEvent e) {

    final Preferences pref = Preferences.userNodeForPackage(RunJavaScriptAction.class);

    JFileChooser chooser = new JFileChooser(pref.get(JAVASCRIPT_DIR, null));

    if (chooser.showOpenDialog(UIApplication.getFrame()) == JFileChooser.APPROVE_OPTION) {
      pref.put(JAVASCRIPT_DIR, chooser.getCurrentDirectory().getAbsolutePath());

      final String file = chooser.getSelectedFile().getAbsolutePath();

      EventQueue.invokeLater(
          new Runnable() {

            @Override
            public void run() {

              try (FileReader reader = new FileReader(file)) {
                new ScriptEngineManager().getEngineByName("JavaScript").eval(reader);
              } catch (IOException | ScriptException e) {
                Logger.getLogger(RunJavaScriptAction.class.getName())
                    .log(Level.SEVERE, e.toString(), e);
              }
            }
          });
    }
  }
  /** Handles the saving of a drawing to a file. */
  private void doSave() {
    JFileChooser chooser = new JFileChooser(getClass().getResource("").getFile());
    chooser.setDialogTitle("Save Graphic");
    chooser.setDialogType(JFileChooser.SAVE_DIALOG);
    FileFilter filter =
        new FileFilter() {
          @Override
          public String getDescription() {
            return "JDraw Graphic (*.draw)";
          }

          @Override
          public boolean accept(File f) {
            return f.getName().endsWith(".draw");
          }
        };
    chooser.setFileFilter(filter);
    int res = chooser.showOpenDialog(this);

    if (res == JFileChooser.APPROVE_OPTION) {
      // save graphic
      File file = chooser.getSelectedFile();
      if (chooser.getFileFilter() == filter && !filter.accept(file)) {
        file = new File(chooser.getCurrentDirectory(), file.getName() + ".draw");
      }
      System.out.println("save current graphic to file " + file.getName());
    }
  }
Beispiel #9
0
  public void doImport() {

    try {

      JFileChooser chooser = new JFileChooser();
      chooser.setDialogTitle("Select input tree file...");
      chooser.setMultiSelectionEnabled(false);
      chooser.setCurrentDirectory(frame.getWorkingDirectory());

      int returnValue = chooser.showOpenDialog(Utils.getActiveFrame());

      if (returnValue == JFileChooser.APPROVE_OPTION) {

        File file = chooser.getSelectedFile();

        if (file != null) {

          //					dataList.treeFilesList.add(file);
          treeFileNameText.setText(file.getName());

          importFromFile(file);

          File tmpDir = chooser.getCurrentDirectory();
          if (tmpDir != null) {
            frame.setWorkingDirectory(tmpDir);
          }
        } // END: file opened check
      } // END: dialog cancelled check

    } catch (IOException e) {
      e.printStackTrace();
    } catch (ImportException e) {
      e.printStackTrace();
    } // END: try-catch block
  } // END: doImport
Beispiel #10
0
  public void doLoad() {
    JFileChooser fc = new JFileChooser(m_fCurrentDirectory);

    fc.addChoosableFileFilter(
        new ExtensionsFilter(
            LocalRes.getIntString("label.imagefiles"), "png", "gif", "jpg", "jpeg", "bmp"));

    if (fc.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
      try {
        BufferedImage img = ImageIO.read(fc.getSelectedFile());
        if (img != null) {
          // compruebo que no exceda el tamano maximo.
          if (m_maxsize != null
              && (img.getHeight() > m_maxsize.height || img.getWidth() > m_maxsize.width)) {
            if (JOptionPane.showConfirmDialog(
                    this,
                    LocalRes.getIntString("message.resizeimage"),
                    LocalRes.getIntString("title.editor"),
                    JOptionPane.YES_NO_OPTION,
                    JOptionPane.QUESTION_MESSAGE)
                == JOptionPane.YES_OPTION) {
              // Redimensionamos la imagen para que se ajuste
              img = resizeImage(img);
            }
          }
          setImage(img);
          m_fCurrentDirectory = fc.getCurrentDirectory();
        }
      } catch (IOException eIO) {
      }
    }
  }
  private void loadFile() {
    JFileChooser fileChooser = new JFileChooser();

    FileNameExtensionFilter filter =
        new FileNameExtensionFilter("HTML Files (*.htm, *.html)", "htm", "html");
    fileChooser.addChoosableFileFilter(filter);
    fileChooser.addChoosableFileFilter(fileChooser.getAcceptAllFileFilter());
    fileChooser.setFileFilter(filter);

    if (internalBalloon.getBalloonContentPath().isSetLastUsedMode()) {
      fileChooser.setCurrentDirectory(
          new File(internalBalloon.getBalloonContentPath().getLastUsedPath()));
    } else {
      fileChooser.setCurrentDirectory(
          new File(internalBalloon.getBalloonContentPath().getStandardPath()));
    }
    int result = fileChooser.showSaveDialog(getTopLevelAncestor());
    if (result == JFileChooser.CANCEL_OPTION) return;
    try {
      String exportString = fileChooser.getSelectedFile().toString();
      browseText.setText(exportString);
      internalBalloon
          .getBalloonContentPath()
          .setLastUsedPath(fileChooser.getCurrentDirectory().getAbsolutePath());
      internalBalloon.getBalloonContentPath().setPathMode(PathMode.LASTUSED);
    } catch (Exception e) {
      //
    }
  }
Beispiel #12
0
  /**
   * Accionado quando se faz clique no botao para extrair um ficheiro.
   *
   * <p>Permite extrair o conteudo de um ficheiro selecionado pelo utilizador. A extracção só será
   * possivel caso o objecto selecionado seja um ficheiro.
   *
   * <p>É lançado uma excepção caso a extracção falhe.
   *
   * @param evt
   */
  private void jMenuItem6ActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_jMenuItem6ActionPerformed
    try {
      // verificar a seleccão
      int row = jTable1.getSelectedRow();
      Object obj = jTable1.getModel().getValueAt(row, 0);
      if (obj instanceof RFPFileHeader) {
        final JFileChooser fc = new JFileChooser();
        fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
        int returnVal = fc.showOpenDialog(this);
        if (returnVal == JFileChooser.APPROVE_OPTION) {
          File dir = fc.getCurrentDirectory();
          File dest = fc.getSelectedFile();

          if ((int) (((RFPFileHeader) obj).getFlags() & RFPBinaryFile.RFP_COMPRESSED)
              == RFPBinaryFile.RFP_COMPRESSED) {
            rfpFile.decompressFile(((RFPFileHeader) obj).getFilenameId(), dest.getPath());

          } else {
            rfpFile.extractFile(((RFPFileHeader) obj).getFilenameId(), dest.getPath());
          }
        }
      } else {
        JOptionPane.showMessageDialog(
            null,
            "Impossivel extrair ficheiro.",
            "Extração de Ficheiro",
            JOptionPane.ERROR_MESSAGE);
      }
    } catch (Exception ex) {
      JOptionPane.showMessageDialog(
          null, "Impossivel extrair ficheiro.", "Extração de Ficheiro", JOptionPane.ERROR_MESSAGE);
    }
  } // GEN-LAST:event_jMenuItem6ActionPerformed
Beispiel #13
0
  /**
   * Accionado quando se faz clique no botao para extrair uma directoria do ficheiro RFP.
   *
   * <p>Permite extrair uma directoria do ficheiro RFP na pasta de destino escolhida pelo
   * utilizador.
   *
   * <p>Se o objecto selecionado for uma directoria, irá então ser extraido o conteúdo dessa mesma
   * directoria.
   *
   * <p>É lançado uma excepção caso seja impossivel extrair os conteúdos da directoria selecionada.
   *
   * @param evt
   */
  private void jMenuItem11ActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_jMenuItem11ActionPerformed
    try {
      // verificar a seleccão
      int row = jTable1.getSelectedRow();
      Object obj = jTable1.getModel().getValueAt(row, 0);
      if (obj instanceof RFPDirectoryHeader) {
        final JFileChooser fc = new JFileChooser();
        fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
        int returnVal = fc.showOpenDialog(this);
        if (returnVal == JFileChooser.APPROVE_OPTION) {
          File dir = fc.getCurrentDirectory();
          File dest = fc.getSelectedFile();
          rfpFile.extractAll(((RFPDirectoryHeader) obj).getId(), dest.getPath());
        }
      } else {
        JOptionPane.showMessageDialog(
            null,
            "Impossível extrair directoria.",
            "Extrair Directoria",
            JOptionPane.ERROR_MESSAGE);
      }

    } catch (Exception ex) {
      JOptionPane.showMessageDialog(
          null, "Impossível extrair directoria.", "Extrair Directoria", JOptionPane.ERROR_MESSAGE);
    }
  } // GEN-LAST:event_jMenuItem11ActionPerformed
Beispiel #14
0
  /**
   * Accionado quando se faz clique no botao para criar um ficheiro RFP.
   *
   * <p>Cria um novo ficheiro RFP. Pergunta ao utilizador o caminho onde será guardado o ficheiro.
   * Fecha o ficheiro RFP actual caso exista e faz um reset ao conteudo da tabela, mostrando de
   * seguida o conteudo do novo ficheiro RFP.
   *
   * <p>É lançado uma excepção caso seja impossivel criar o ficheiro na directoria de destino.
   *
   * @param evt
   */
  private void jMenuItem14ActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_jMenuItem14ActionPerformed
    try {
      final JFileChooser fc = new JFileChooser();
      int returnVal = fc.showSaveDialog(this);
      if (returnVal == JFileChooser.APPROVE_OPTION) {
        File dir = fc.getCurrentDirectory();
        File file = fc.getSelectedFile();

        if (rfpFile != null && !rfpFile.isClosed()) rfpFile.closeRFP();
        this.resetTable();
        this.resetVariables();

        rfpFile = new RFPBinaryFile(file.getName(), dir.getPath());
        rfpFile.openRFP();
        rfpFile.generateEmptyFile();
        rfpFile.readContents();
        nativePath = dir.getPath();
        this.showRFPContents();
      }
    } catch (Exception ex) {
      JOptionPane.showMessageDialog(
          null, "Impossivel criar ficheiro rfp.", "Novo Ficheiro RFP", JOptionPane.ERROR_MESSAGE);
    }
  } // GEN-LAST:event_jMenuItem14ActionPerformed
Beispiel #15
0
  /**
   * Accionado quando se faz clique no botao para abrir um ficheiro RFP Permite selecionar um
   * ficheiro rfp escolhido pelo utilizador. Fecha o ficheiro actual caso este exista e faz um reset
   * ao conteu do actual da tabela, mostrando de seguida os novos conteudos do ficheiro escolhido.
   *
   * <p>É lançado uma excepção caso seja feito um duplo clique sem selecção.
   *
   * @param evt
   */
  private void jMenuItem2ActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_jMenuItem2ActionPerformed

    try {
      final JFileChooser fc = new JFileChooser();
      RFPFileFilter filter = new RFPFileFilter();
      fc.addChoosableFileFilter(filter);
      int returnVal = fc.showOpenDialog(this);
      if (returnVal == JFileChooser.APPROVE_OPTION) {
        File file = fc.getSelectedFile();
        File dir = fc.getCurrentDirectory();
        // fechar o ficheiro actual
        if (rfpFile != null && !rfpFile.isClosed()) rfpFile.closeRFP();

        resetTable();
        resetVariables();
        rfpFile = new RFPBinaryFile(file.getName(), dir.getPath());
        rfpFile.openRFP();
        rfpFile.readContents();
        nativePath = dir.getPath();
        showRFPContents();
      }
    } catch (Exception e) {
      JOptionPane.showMessageDialog(
          null,
          "Impossivel abrir o ficheiro rfp.",
          "Abrir Ficheiro RFP",
          JOptionPane.ERROR_MESSAGE);
    }
  } // GEN-LAST:event_jMenuItem2ActionPerformed
  protected void cmdBrowse() {
    final Preferences prefs = this.getPreferences();
    final String sLastDir =
        (prefs == null)
            ? null
            : prefs.node(PREFS_NODE_COLLECTABLEFILECHOOSER).get(PREFS_KEY_LAST_DIRECTORY, null);
    final JFileChooser filechooser = new JFileChooser(sLastDir);

    configureFileSelection(filechooser);

    final int iBtn = filechooser.showOpenDialog(getJComponent());
    if (iBtn == JFileChooser.APPROVE_OPTION) {
      final java.io.File file = filechooser.getSelectedFile();
      if (file != null) {
        if (prefs != null) {
          prefs
              .node(PREFS_NODE_COLLECTABLEFILECHOOSER)
              .put(PREFS_KEY_LAST_DIRECTORY, filechooser.getCurrentDirectory().getAbsolutePath());
        }
        final String sFileName = file.getAbsolutePath();
        final CollectableValueField clctf = new CollectableValueField(sFileName);
        this.setField(clctf);
      }
    }
  }
    public void actionPerformed(ActionEvent e) {
      if (readOnly) {
        return;
      }
      JFileChooser fc = getFileChooser();
      File currentDirectory = fc.getCurrentDirectory();

      if (!currentDirectory.exists()) {
        JOptionPane.showMessageDialog(
            fc,
            newFolderParentDoesntExistText,
            newFolderParentDoesntExistTitleText,
            JOptionPane.WARNING_MESSAGE);
        return;
      }

      File newFolder;
      try {
        newFolder = fc.getFileSystemView().createNewFolder(currentDirectory);
        if (fc.isMultiSelectionEnabled()) {
          fc.setSelectedFiles(new File[] {newFolder});
        } else {
          fc.setSelectedFile(newFolder);
        }
      } catch (IOException exc) {
        JOptionPane.showMessageDialog(
            fc,
            newFolderErrorText + newFolderErrorSeparator + exc,
            newFolderErrorText,
            JOptionPane.ERROR_MESSAGE);
        return;
      }

      fc.rescanCurrentDirectory();
    }
Beispiel #18
0
  private void onTranslation() {
    final JFileChooser fc = new JFileChooser();
    fc.setCurrentDirectory(filePath);

    fc.setMultiSelectionEnabled(false);
    final int returnVal = fc.showOpenDialog(panel);
    filePath = fc.getCurrentDirectory();

    if (returnVal == JFileChooser.APPROVE_OPTION) {
      translationFilePath = fc.getSelectedFile();

      if (fc.getName(translationFilePath).endsWith(".txt")) {
        if (translationFilePath.exists()) {
          translationDoc = fc.getName(translationFilePath);
          fieldTranslation.setText(translationFilePath.getPath());
        } else {
          JOptionPane.showMessageDialog(
              panel,
              getString("MSG.ERROR.FILE_NOTFOUND"),
              getString("MSG.ERROR"),
              JOptionPane.ERROR_MESSAGE);

          fieldTranslation.setText("");
        }
      }
      //  ToDo: remember filename by preferences
    }
  }
 private void openFile() {
   // opens a single file chooser (can select multiple), does not traverse folders.
   this.copyList = new ArrayList();
   final JFileChooser fc = new JFileChooser(currentPath);
   fc.setMultiSelectionEnabled(true);
   fc.setFileSelectionMode(JFileChooser.FILES_ONLY);
   FileNameExtensionFilter filterhtml = new FileNameExtensionFilter("HTML File (.html)", "html");
   fc.addChoosableFileFilter(filterhtml);
   fc.setFileFilter(filterhtml);
   int result = fc.showOpenDialog(FrontEnd.this);
   dir = fc.getCurrentDirectory();
   dirImp = dir.toString();
   switch (result) {
     case JFileChooser.APPROVE_OPTION:
       for (File file1 : fc.getSelectedFiles()) {
         fileImp = file1.toString();
         boolean exists = false;
         for (int i = 0; i < table.getRowCount(); i++) {
           dir = fc.getCurrentDirectory();
           dirImp = dir.toString();
           String copyC = dtm.getValueAt(i, 0).toString();
           if (duplC.isSelected()) {
             if (fileImp.endsWith(copyC)) {
               exists = true;
               break;
             }
           }
         }
         if (!exists) {
           addRow();
           dtm.setValueAt(fileImp.substring(67), curRow, 0);
           dtm.setValueAt(dirImp.substring(67), curRow, 1);
           curRow++;
           if (headC == 1) {
             if (fileImp.substring(67).endsWith(dirImp.substring(67) + ".html")) {
               curRow--;
               dtm.removeRow(curRow);
             }
           }
         }
       }
     case JFileChooser.CANCEL_OPTION:
       break;
   }
 }
  public SelectorDeArchivos(OPERACION operacion) {
    _archivo = null;
    JFileChooser selector = new JFileChooser();
    int opcion;
    if (operacion == OPERACION.CARGA) {
      selector.setFileFilter(new FiltroArchivos());
      opcion = selector.showOpenDialog(new JFrame());
    } else opcion = selector.showSaveDialog(new JFrame());

    if (opcion == JFileChooser.APPROVE_OPTION)
      _archivo =
          selector.getCurrentDirectory().toString() + "/" + selector.getSelectedFile().getName();
  }
 public void actionPerformed(ActionEvent e) {
   int x = jfc.showSaveDialog(null);
   // int x=jfc.showOpenDialog(null);
   if (x == JFileChooser.APPROVE_OPTION) {
     File f = jfc.getSelectedFile();
     System.out.println(f.getPath());
     System.out.println(jfc.getName(f));
     File f1 = jfc.getCurrentDirectory();
     System.out.println(jfc.getName(f1));
   }
   if (x == JFileChooser.CANCEL_OPTION) {
     System.out.println("cancle");
   }
 }
  /** Validates content of file cache. */
  public void validateFileCache() {
    File currentDirectory = filechooser.getCurrentDirectory();
    if (currentDirectory == null) {
      return;
    }
    if (filesLoader != null) {
      filesLoader.loadThread.interrupt();
      filesLoader.cancelRunnables();
    }

    setBusy(true, ++fetchID);

    filesLoader = new FilesLoader(currentDirectory, fetchID);
  }
Beispiel #23
0
 /**
  * Accionado quando se faz clique no botao para adicionar um ficheiro ao ficheiro RFP. Permite
  * adicionar um ficheiro escolhido pelo utilizador..
  *
  * <p>É lançado uma excepção caso seja impossivel adicionar o ficheiro.
  *
  * @param evt
  */
 private void jMenuItem4ActionPerformed(
     java.awt.event.ActionEvent evt) { // GEN-FIRST:event_jMenuItem4ActionPerformed
   try {
     final JFileChooser fc = new JFileChooser();
     int returnVal = fc.showOpenDialog(this);
     if (returnVal == JFileChooser.APPROVE_OPTION) {
       File file = fc.getSelectedFile();
       File dir = fc.getCurrentDirectory();
       rfpFile.addFile(file.getName(), dir.getPath(), RFPBinaryFile.RFP_NO_FLAG);
       showRFPContents();
     }
   } catch (Exception e) {
     JOptionPane.showMessageDialog(
         null, "Impossível adicionar ficheiro.", "Adicionar Ficheiro", JOptionPane.ERROR_MESSAGE);
   }
 } // GEN-LAST:event_jMenuItem4ActionPerformed
  private void btnLoadXmlActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_btnLoadXmlActionPerformed

    JFileChooser chooser = new JFileChooser();
    chooser.setFileFilter(
        new FileFilter() {
          @Override
          public boolean accept(File f) {
            if (f.isDirectory()) return true;
            return f.getPath().toLowerCase().endsWith(".xml") && f.canRead() && f.canWrite();
          }

          @Override
          public String getDescription() {
            return "XML file";
          }
        });
    chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
    if (currentDir != null) chooser.setCurrentDirectory(currentDir);

    if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
      currentDir = chooser.getCurrentDirectory();

      FileInputStream fileInputStream = null;
      try {
        fileInputStream = new FileInputStream(chooser.getSelectedFile());
        String contents = Common.streamToString(fileInputStream);
        txtXml.setSyntaxEditingStyle("text/xml");
        txtXml.setText(contents);
        txtXml.setEditable(true);
      } catch (Exception ex) {
        txtXml.setSyntaxEditingStyle("text/text");
        txtXml.setText(Common.traceToString(ex));
        txtXml.setEditable(false);
      } finally {
        if (fileInputStream != null) {
          try {
            fileInputStream.close();
          } catch (Exception ex) {
          }
        }
      }

      //            setXmlTextIsDirty( true );
    }
  } // GEN-LAST:event_btnLoadXmlActionPerformed
Beispiel #25
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 #26
0
 public int show() {
   if (useFileDialog) {
     fileDialog.setVisible(true);
     if (fileDialog.getDirectory() == null) {
       return JFileChooser.CANCEL_OPTION;
     } else {
       PreferenceManager.getCurrent()
           .setFile(dirPreference, new File(fileDialog.getDirectory()));
       return JFileChooser.APPROVE_OPTION;
     }
   }
   int status = jfc.showDialog(getApplicationPanel(), taskName);
   if (status == JFileChooser.APPROVE_OPTION) {
     PreferenceManager.getCurrent().setFile(dirPreference, jfc.getCurrentDirectory());
   }
   return status;
 }
  @Override
  public void actionPerformed(ActionEvent arg0) {
    int rv;
    jfc.setCurrentDirectory(defaultDir.val);
    if (isOpen) rv = jfc.showOpenDialog(parent);
    else rv = jfc.showSaveDialog(parent);

    if (rv == JFileChooser.APPROVE_OPTION) {
      File f = jfc.getSelectedFile();

      try {
        textbox.setText(f.getCanonicalPath());
      } catch (IOException e) {
        textbox.setText(f.getAbsolutePath());
      }
    }

    defaultDir.val = jfc.getCurrentDirectory();
  }
Beispiel #28
0
  /**
   * Checks whether the given window is either a FileDialog, or contains a JFileChooser component.
   * If so, its current directory is restored from the given properties.
   *
   * @param aNamespace the name space to use;
   * @param aProperties the properties to get the directory from;
   * @param aWindow the window to check for.
   */
  private static void saveFileDialogState(final Preferences aProperties, final Window aWindow) {
    final String propKey = "lastDirectory";

    if (aWindow instanceof FileDialog) {
      final String dir = ((FileDialog) aWindow).getDirectory();
      if (dir != null) {
        aProperties.put(propKey, dir);
      }
    } else if (aWindow instanceof JDialog) {
      final Container contentPane = ((JDialog) aWindow).getContentPane();
      final JFileChooser fileChooser =
          (JFileChooser) findComponent(contentPane, JFileChooser.class);
      if (fileChooser != null) {
        final File dir = fileChooser.getCurrentDirectory();
        if (dir != null) {
          aProperties.put(propKey, dir.getAbsolutePath());
        }
      }
    }
  }
Beispiel #29
0
    private void LoadExternalPressed() {

      JFileChooser chooser = new JFileChooser();
      chooser.setFileFilter(
          new javax.swing.filechooser.FileFilter() {
            public String getDescription() {
              return "Class files";
            }

            public boolean accept(File f) {
              return f.getName().endsWith(".class") || f.isDirectory();
            }
          });

      chooser.showOpenDialog(this);

      File chosen = chooser.getSelectedFile();
      File chosenDir = chooser.getCurrentDirectory();

      // System.out.println("Loading class " + chosen.getAbsolutePath());
      // Load file
      FileClass fc = null;
      try {
        URL url = chosenDir.toURI().toURL();
        URL[] urls = new URL[] {url};
        ClassLoader cl = new URLClassLoader(urls);
        Class<?> cls = cl.loadClass(chosen.getName().replace(".class", ""));
        ArrayList<Class<?>> interfaces = getAllInterfaces(cls);
        for (Class<?> c : interfaces) {
          if (c.equals(mytype) && !Modifier.isAbstract(cls.getModifiers())) {
            fc = new FileClass(chosen, cls);
            break;
          }
        }
      } catch (Exception ex) {
        System.err.println("Error loading class file: " + chosen.getAbsolutePath());
      }
      if (fc != null) {
        LoadClass(fc, false);
      }
    }
 public void actionPerformed(ActionEvent e) {
   if (e.getSource() == create) {
     boolean flag = false;
     for (JCheckBox cur : checks) if (cur.isSelected()) flag = true;
     if (flag) {
       File path = chooser.getCurrentDirectory();
       ArrayList<String> cath_selected = new ArrayList<String>();
       for (JCheckBox cur : checks)
         if (cur.isSelected())
           if (cur.getText().compareTo("выбрать все...") != 0) cath_selected.add(cur.getText());
       String mode = new String();
       if (semester_combo.getSelectedItem().toString().compareTo("летний") == 0) mode = "summer";
       else mode = "winter";
       Dispatcher.createEducAssignment(cath_selected, path, mode);
       this.dispose();
     } else
       JOptionPane.showMessageDialog(
           null, "ƒл¤ формировани¤ учебных поручений необходимо определить кафедры.");
   }
   if (e.getSource() == cancel) this.dispose();
 }