/**
   * Draws as much as possible of a given string into a 2d square region in a graphical space.
   *
   * @param g component onto which to draw
   * @param f font to use in drawing the string
   * @param s string to be drawn
   * @param xPos
   * @param yPos
   * @param width
   * @param height
   */
  public static void drawStringMultiline(
      Graphics2D g, Font f, String s, double xPos, double yPos, double width, double height) {
    FontMetrics fm = g.getFontMetrics(f);
    int w = fm.stringWidth(s);
    int h = fm.getAscent();
    // g.setColor(Color.LIGHT_GRAY);
    g.setColor(Color.BLACK);
    g.setFont(f);

    Scanner lineSplitter = new Scanner(s);
    // draw as much as can fit in each item
    // read all content from scanner, storing in string lists (where each string == 1 line), each
    // string should be as long as possible without overflowing the space
    int maxRows = (int) height / h;
    List<String> textRows = new ArrayList<>();
    while (lineSplitter.hasNextLine() && textRows.size() < maxRows) {
      String line = lineSplitter.nextLine();
      // if line is blank, insert to maintain paragraph seps
      if (line.trim().equals("")) {
        textRows.add("");
      }
      // else, pass to inner loop
      StringBuilder currentBuilder = new StringBuilder();
      int currentStrWidth = 0;
      Scanner splitter = new Scanner(line);
      while (splitter.hasNext() && textRows.size() < maxRows) {
        String token = splitter.next() + " ";
        // TODO incorporate weight detection, formatting for token?
        currentStrWidth += fm.stringWidth(token);
        if (currentStrWidth >= width) {
          // if string length >= glyph width, build row
          textRows.add(currentBuilder.toString());
          currentBuilder = new StringBuilder();
          currentBuilder.append(token);
          currentStrWidth = fm.stringWidth(token);
        } else {
          // if not yet at end of row, append to builder
          currentBuilder.append(token);
        }
      }

      // if we've still space and still have things to write, add them here
      if (textRows.size() < maxRows) {
        textRows.add(currentBuilder.toString());
        currentBuilder = new StringBuilder();
        currentStrWidth = 0;
      }
    }

    // write each line to object
    for (int t = 0; t < textRows.size(); t++) {
      String line = textRows.get(t);
      if (fm.stringWidth(line) <= width) {
        // ensure that string doesn't overflow the box
        //                g.drawString(line, (float) (xPos-(width/2.)), (float) (yPos-(height/2.) +
        // h * (t+1)));
        g.drawString(line, (float) xPos, (float) (yPos + h * (t + 1)));
      }
    }
  }
Beispiel #2
0
  /**
   * Opens a file. If the file can be opened, get a drawing time estimate, update recent files list,
   * and repaint the preview tab.
   *
   * @param filename what file to open
   */
  public void LoadGCode(String filename) {
    CloseFile();

    try {
      Scanner scanner = new Scanner(new FileInputStream(filename));
      linesTotal = 0;
      gcode = new ArrayList<String>();
      try {
        while (scanner.hasNextLine()) {
          gcode.add(scanner.nextLine());
          ++linesTotal;
        }
      } finally {
        scanner.close();
      }
    } catch (IOException e) {
      Log("<span style='color:red'>File could not be opened.</span>\n");
      RemoveRecentFile(filename);
      return;
    }

    previewPane.setGCode(gcode);
    fileOpened = true;

    EstimateDrawTime();
    UpdateRecentFiles(filename);
    Halt();
  }
  public static int[] getTextDims(Graphics2D g, Font f, String s) {

    // [0] == max width of all lines
    // [1] == total height
    int[] textDims = new int[2];

    FontMetrics fm = g.getFontMetrics(f);
    int lineH = fm.getAscent();

    Scanner lineSplitter = new Scanner(s);
    int maxW = -1;
    int lineCounter = 0;
    while (lineSplitter.hasNextLine()) {
      String line = lineSplitter.nextLine();
      int w = fm.stringWidth(line);
      if (w > maxW) {
        maxW = w;
      }
      lineCounter++;
    }
    int h = lineH * lineCounter;

    textDims[0] = maxW;
    textDims[1] = h;
    return textDims;
  }
Beispiel #4
0
  public static void main(String[] args) throws IOException {

    // First reads in the lines from the .txt file.  The first and second lines determine the start
    // and ending point of the maze.
    // The rest of the lines give the locations of the corners of each convex polygon in the maze.

    //        Example map input:
    //        1, 3
    //        34, 19
    //        0, 14; 6, 19; 9, 15; 7, 8; 1, 9
    //        2, 6; 17, 6; 17, 1; 2, 1
    //        12, 15; 14, 8; 10, 8
    //        14, 19; 18, 20; 20, 17; 14, 13
    //        18, 10; 23, 6; 19, 3
    //        22, 19; 28, 19; 28, 9; 22, 9
    //        25, 6; 29, 8; 31, 6; 31, 2; 28, 1; 25, 2
    //        31, 19; 34, 16; 32, 8; 29, 17

    // Open specified text file
    List<String> list = new ArrayList<String>();
    File library = new File(args[0]);
    Scanner sc = new Scanner(library);

    // Reads in every line of the text file
    // creates a new String for every line, then adds it to an arraylist
    while (sc.hasNextLine()) {
      String line;
      line = sc.nextLine();
      list.add(line);
    }

    // Takes the first and second lines as the start and goal points
    int count = 0;

    sPoint = list.get(0);
    ePoint = list.get(1);

    sPoint = sPoint.replace(" ", "");
    ePoint = ePoint.replace(" ", "");

    // remove the first line from the polygon list
    list.remove(0);

    // Create a 2 element array for the start point
    String[] Starter = sPoint.split(",");
    String[] Ender = ePoint.split(",");
    Startx = Double.parseDouble(Starter[0]);
    Starty = Double.parseDouble(Starter[1]);

    Polygon[] FinalPolygons = ListPolygons(list);

    // Text Graph of the polygon maze and the Start/End points
    graph(FinalPolygons);

    // A* search algorithm is performed to find the shortest path
    AStarSearch(FinalPolygons);
  }
Beispiel #5
0
 // Reads name popularity rank data from text file into HashMap
 public void readRankData(Scanner input) {
   while (input.hasNextLine()) {
     String dataLine = input.nextLine();
     Person entry = new Person(dataLine);
     Scanner tokens = new Scanner(dataLine);
     String nameGender = tokens.next();
     nameGender += tokens.next();
     persons.put(nameGender, entry);
   }
 }
Beispiel #6
0
  /**
   * Loads into a double[][] a plain text file of numbers, with newlines dividing the numbers into
   * rows and tabs or spaces delimiting columns. The Y dimension is not flipped.
   */
  public static double[][] loadTextFile(InputStream stream) throws IOException {
    Scanner scan = new Scanner(stream);

    ArrayList rows = new ArrayList();
    int width = -1;

    while (scan.hasNextLine()) {
      String srow = scan.nextLine().trim();
      if (srow.length() > 0) {
        int w = 0;
        if (width == -1) // first time compute width
        {
          ArrayList firstRow = new ArrayList();
          Scanner rowScan = new Scanner(new StringReader(srow));
          while (rowScan.hasNextDouble()) {
            firstRow.add(new Double(rowScan.nextDouble())); // ugh, boxed
            w++;
          }
          width = w;
          double[] row = new double[width];
          for (int i = 0; i < width; i++) row[i] = ((Double) (firstRow.get(i))).doubleValue();
          rows.add(row);
        } else {
          double[] row = new double[width];
          Scanner rowScan = new Scanner(new StringReader(srow));
          while (rowScan.hasNextDouble()) {
            if (w == width) // uh oh
            throw new IOException("Row lengths do not match in text file");
            row[w] = rowScan.nextDouble();
            w++;
          }
          if (w < width) // uh oh
          throw new IOException("Row lengths do not match in text file");
          rows.add(row);
        }
      }
    }

    if (width == -1) // got nothing
    return new double[0][0];

    double[][] fieldTransposed = new double[rows.size()][];
    for (int i = 0; i < rows.size(); i++) fieldTransposed[i] = ((double[]) (rows.get(i)));

    // now transpose because we have width first
    double[][] field = new double[width][fieldTransposed.length];
    for (int i = 0; i < field.length; i++)
      for (int j = 0; j < field[i].length; j++) field[i][j] = fieldTransposed[j][i];

    return field;
  }
 public void readFile(String name) { // reads the file and puts everything in the stats list
   Scanner inFile = null;
   stats = new ArrayList<String>();
   chars = new ArrayList<String>();
   powerUps = new ArrayList<String>();
   try {
     inFile = new Scanner(new BufferedReader(new FileReader(name + ".txt")));
     while (inFile.hasNextLine()) {
       stats.add(inFile.nextLine());
     }
   } catch (IOException ex) {
     System.out.println("Did you forget to make the" + name + ".txt file?");
   }
 }
Beispiel #8
0
  protected void initUI() {
    File f = new File("Top100");
    String Str;
    String WORDS[] = new String[100];
    int FREQ[] = new int[100];
    String shuffle[] = new String[100];
    ArrayList<String> shuffling = new ArrayList<String>();
    int count = 0, i, temp = 1000000;
    try {
      Scanner br = new Scanner(f);

      while (br.hasNextLine()) {
        Str = br.nextLine();
        shuffling.add(Str);
      }
      br.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
    Collections.shuffle(shuffling);
    for (String str : shuffling) {

      WORDS[count] = str.substring(0, str.indexOf(' '));
      FREQ[count] = Integer.parseInt(str.substring(str.indexOf(' ') + 1, str.length()));
      if (FREQ[count] < temp) temp = FREQ[count];
      count++;
    }
    JFrame frame = new JFrame(TestOpenCloud.class.getSimpleName());
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    JPanel panel = new JPanel();
    // Cloud cloud = new Cloud();
    Random random = new Random();
    for (i = 0; i < 100; i++) {

      final int red = (int) (Math.random() * 150);
      final int green = (int) (Math.random() * 150);
      final int blue = (int) (Math.random() * 150);
      final JLabel label = new JLabel(WORDS[i]);
      label.setOpaque(false);
      label.setFont(new Font("Andalus", Font.PLAIN, ((FREQ[i] * 11) / temp)));
      Color color = new Color(red, green, blue);
      label.setForeground(color);
      panel.add(label);
    }
    frame.add(panel);
    frame.setSize(1366, 768);
    frame.setVisible(true);
  }
Beispiel #9
0
  // Constructor
  public Ballot(int index, int ID, int numCandidates, String title, ArrayList<String> candidates)
      throws IOException {
    _index = index;
    _ID = ID;
    _numCandidates = numCandidates;
    _votes = new int[_numCandidates];
    _title = title;
    _candidates = candidates;
    _usrVotes = new String[numCandidates];

    // if the ballot file already exists, read in the votes for that ballot
    // otherwise the number of votes for each candidate will default to 0
    file = new File(_ID + ".txt");
    if (file.exists()) {
      Scanner reader = new Scanner(file);
      int i = 0;
      while (reader.hasNextLine()) {
        String strLine = reader.nextLine();
        String arrLine[] = strLine.split(":");
        int vote = Integer.parseInt(arrLine[1]);
        _votes[i] = vote;

        i++;
      }
      reader.close();
    }

    _ballotPanel = new JPanel();
    _ballotPanel.setLayout(new GridLayout(_candidates.size() + 1, 1));

    _titleLabel = new JLabel(_title);
    _titleLabel.setHorizontalAlignment(JLabel.CENTER);
    _titleLabel.setFont(new Font("CourierNew", Font.PLAIN, 15));
    _ballotPanel.add(_titleLabel);

    for (int i = 0; i < _candidates.size(); i++) {
      // Make a JButton for each candidate in the ballot
      // Disable it by default. Will enable when the user logs in
      String cText = _candidates.get(i);
      JButton candidate = new JButton(cText);
      candidate.setEnabled(false);
      candidate.addActionListener(_buttonListener);

      _candidateButtons.add(candidate);
      _ballotPanel.add(candidate);
    }
  }
 @Override
 public StringBuilder doInBackground() throws IOException, InterruptedException {
   int lineNumber = 0;
   try (Scanner in = new Scanner(new FileInputStream(file))) {
     while (in.hasNextLine()) {
       String line = in.nextLine();
       lineNumber++;
       text.append(line);
       text.append("\n");
       ProgressData data = new ProgressData();
       data.number = lineNumber;
       data.line = line;
       publish(data);
       Thread.sleep(1); // to test cancellation; no need to do this
       // in your programs
     }
   }
   return text;
 }
Beispiel #11
0
  /**
   * Makes a POST request and returns the server response.
   *
   * @param urlString the URL to post to
   * @param nameValuePairs a map of name/value pairs to supply in the request.
   * @return the server reply (either from the input stream or the error stream)
   */
  public static String doPost(String urlString, Map<String, String> nameValuePairs)
      throws IOException {
    URL url = new URL(urlString);
    URLConnection connection = url.openConnection();
    connection.setDoOutput(true);

    PrintWriter out = new PrintWriter(connection.getOutputStream());

    boolean first = true;
    for (Map.Entry<String, String> pair : nameValuePairs.entrySet()) {
      if (first) first = false;
      else out.print('&');
      String name = pair.getKey();
      String value = pair.getValue();
      out.print(name);
      out.print('=');
      out.print(URLEncoder.encode(value, "UTF-8"));
    }

    out.close();

    Scanner in;
    StringBuilder response = new StringBuilder();
    try {
      in = new Scanner(connection.getInputStream());
    } catch (IOException e) {
      if (!(connection instanceof HttpURLConnection)) throw e;
      InputStream err = ((HttpURLConnection) connection).getErrorStream();
      if (err == null) throw e;
      in = new Scanner(err);
    }

    while (in.hasNextLine()) {
      response.append(in.nextLine());
      response.append("\n");
    }

    in.close();
    return response.toString();
  }
  public void parseInput(String file, int threads, int limit)
      throws FileNotFoundException, InterruptedException {
    // long startParseTime = System.currentTimeMillis();
    m_jgAdapter = new JGraphModelAdapter<Position, DefaultEdge>(graph);
    jgraph = new JGraph(m_jgAdapter);
    this.threads = threads;

    Scanner input = new Scanner(new File(file));
    try {
      for (int r = 0; input.hasNextLine() && r < limit; r++) {
        Scanner line = new Scanner(input.nextLine());
        try {

          ArrayList<Position> row = new ArrayList<Position>();
          grid.add(row);

          System.out.println("Row " + r);

          for (int c = 0; line.hasNextInt() && c < limit; c++) {
            Position position = new Position(r, c, line.nextInt());
            row.add(position);
            graph.addVertex(position);
            positionVertexAt(position, position.column * 5, position.row * 5);
          }
        } finally {
          line.close();
        }
      }
    } finally {
      input.close();
    }

    graphGrid(grid);

    // ArrayList<ArrayList<Position>> grid2 = transpose(grid);
    // outputGrid(grid2);

  }
Beispiel #13
0
  public Ssys3() {
    store = new Storage();
    tableSorter = new TableRowSorter<Storage>(store);
    jobs = new LinkedList<String>();

    makeGUI();
    frm.setSize(800, 600);
    frm.addWindowListener(
        new WindowListener() {
          public void windowActivated(WindowEvent evt) {}

          public void windowClosed(WindowEvent evt) {
            try {
              System.out.println("joining EDT's");
              for (EDT edt : encryptDecryptThreads) {
                edt.weakStop();
                try {
                  edt.join();
                  System.out.println("  - joined");
                } catch (InterruptedException e) {
                  System.out.println("  - Not joined");
                }
              }
              System.out.println("saving storage");
              store.saveAll(tempLoc);
            } catch (IOException e) {
              e.printStackTrace();
              System.err.println(
                  "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\nFailed to save properly\n\n!!!!!!!!!!!!!!!!!!!!!!!!!");
              System.exit(1);
            }
            clean();
            System.exit(0);
          }

          public void windowClosing(WindowEvent evt) {
            windowClosed(evt);
          }

          public void windowDeactivated(WindowEvent evt) {}

          public void windowDeiconified(WindowEvent evt) {}

          public void windowIconified(WindowEvent evt) {}

          public void windowOpened(WindowEvent evt) {}
        });
    ImageIcon ico = new ImageIcon(ICON_NAME);
    frm.setIconImage(ico.getImage());
    frm.setLocationRelativeTo(null);
    frm.setVisible(true);

    // load config
    storeLocs = new ArrayList<File>();
    String ossl = "openssl";
    int numThreadTemp = 2;
    boolean priorityDecryptTemp = true;
    boolean allowExportTemp = false;
    boolean checkImportTemp = true;
    try {
      Scanner sca = new Scanner(CONF_FILE);
      while (sca.hasNextLine()) {
        String ln = sca.nextLine();
        if (ln.startsWith(CONF_SSL)) {
          ossl = ln.substring(CONF_SSL.length());
        } else if (ln.startsWith(CONF_THREAD)) {
          try {
            numThreadTemp = Integer.parseInt(ln.substring(CONF_THREAD.length()));
          } catch (Exception exc) {
            // do Nothing
          }
        } else if (ln.equals(CONF_STORE)) {
          while (sca.hasNextLine()) storeLocs.add(new File(sca.nextLine()));
        } else if (ln.startsWith(CONF_PRIORITY)) {
          try {
            priorityDecryptTemp = Boolean.parseBoolean(ln.substring(CONF_PRIORITY.length()));
          } catch (Exception exc) {
            // do Nothing
          }
        } else if (ln.startsWith(CONF_EXPORT)) {
          try {
            allowExportTemp = Boolean.parseBoolean(ln.substring(CONF_EXPORT.length()));
          } catch (Exception exc) {
            // do Nothing
          }
        } else if (ln.startsWith(CONF_CONFIRM)) {
          try {
            checkImportTemp = Boolean.parseBoolean(ln.substring(CONF_CONFIRM.length()));
          } catch (Exception exc) {
            // do Nothing
          }
        }
      }
      sca.close();
    } catch (IOException e) {

    }
    String osslWorks = OpenSSLCommander.test(ossl);
    while (osslWorks == null) {
      ossl =
          JOptionPane.showInputDialog(
              frm,
              "Please input the command used to run open ssl\n  We will run \"<command> version\" to confirm\n  Previous command: "
                  + ossl,
              "Find open ssl",
              JOptionPane.OK_CANCEL_OPTION);
      if (ossl == null) {
        System.err.println("Refused to provide openssl executable location");
        System.exit(1);
      }
      osslWorks = OpenSSLCommander.test(ossl);
      if (osslWorks == null)
        JOptionPane.showMessageDialog(
            frm, "Command " + ossl + " unsuccessful", "Unsuccessful", JOptionPane.ERROR_MESSAGE);
    }
    if (storeLocs.size() < 1)
      JOptionPane.showMessageDialog(
          frm,
          "Please select an initial sotrage location\nIf one already exists, or there are more than one, please select it");
    while (storeLocs.size() < 1) {
      JFileChooser jfc = new JFileChooser();
      jfc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
      if (jfc.showOpenDialog(frm) != JFileChooser.APPROVE_OPTION) {
        System.err.println("Refused to provide an initial store folder");
        System.exit(1);
      }
      File sel = jfc.getSelectedFile();
      if (sel.isDirectory()) storeLocs.add(sel);
    }
    numThreads = numThreadTemp;
    priorityExport = priorityDecryptTemp;
    allowExport = allowExportTemp;
    checkImports = checkImportTemp;

    try {
      PrintWriter pw = new PrintWriter(CONF_FILE);
      pw.println(CONF_SSL + ossl);
      pw.println(CONF_THREAD + numThreads);
      pw.println(CONF_PRIORITY + priorityExport);
      pw.println(CONF_EXPORT + allowExport);
      pw.println(CONF_CONFIRM + checkImports);
      pw.println(CONF_STORE);
      for (File fi : storeLocs) {
        pw.println(fi.getAbsolutePath());
      }
      pw.close();
    } catch (IOException e) {
      System.err.println("Failed to save config");
    }

    File chk = null;
    for (File fi : storeLocs) {
      File lib = new File(fi, LIBRARY_NAME);
      if (lib.exists()) {
        chk = lib;
        // break;
      }
    }

    char[] pass = null;
    if (chk == null) {
      JOptionPane.showMessageDialog(
          frm,
          "First time run\n  Create your password",
          "Create Password",
          JOptionPane.INFORMATION_MESSAGE);
      char[] p1 = askPassword();
      char[] p2 = askPassword();
      boolean same = p1.length == p2.length;
      for (int i = 0; i < Math.min(p1.length, p2.length); i++) {
        if (p1[i] != p2[i]) same = false;
      }
      if (same) {
        JOptionPane.showMessageDialog(
            frm, "Password created", "Create Password", JOptionPane.INFORMATION_MESSAGE);
        pass = p1;
      } else {
        JOptionPane.showMessageDialog(
            frm, "Passwords dont match", "Create Password", JOptionPane.ERROR_MESSAGE);
        System.exit(1);
      }
    } else {
      pass = askPassword();
    }
    sec = OpenSSLCommander.getCommander(chk, pass, ossl);
    if (sec == null) {
      System.err.println("Wrong Password");
      System.exit(1);
    }
    store.useSecurity(sec);
    store.useStorage(storeLocs);

    tempLoc = new File("temp");
    if (!tempLoc.exists()) tempLoc.mkdirs();
    // load stores
    try {
      store.loadAll(tempLoc);
      store.fireTableDataChanged();
    } catch (IOException e) {
      System.err.println("Storage loading failure");
      System.exit(1);
    }

    needsSave = false;
    encryptDecryptThreads = new EDT[numThreads];
    for (int i = 0; i < encryptDecryptThreads.length; i++) {
      encryptDecryptThreads[i] = new EDT(i);
      encryptDecryptThreads[i].start();
    }

    updateStatus();
    txaSearch.grabFocus();
  }
Beispiel #14
0
 public void secureImport() {
   JFileChooser imp = new JFileChooser();
   imp.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
   imp.setMultiSelectionEnabled(true);
   int ret = imp.showOpenDialog(frm);
   if (ret != JFileChooser.APPROVE_OPTION) {
     return;
   }
   File[] fis = imp.getSelectedFiles();
   ArrayList<String> impJobs = new ArrayList<String>();
   boolean dirs = false;
   for (File fi : fis) {
     if (fi.isDirectory()) {
       dirs = true;
       File lib = new File(fi, LIBRARY_NAME);
       if (lib.exists()) {
         try {
           Scanner sca = new Scanner(lib);
           while (sca.hasNextLine()) {
             String nm = sca.nextLine();
             String date = sca.nextLine();
             String tags = sca.nextLine();
             File addr = new File(fi, nm);
             if (addr.exists() && !addr.isDirectory()) impJobs.add(impJob(addr, date, tags));
           }
           sca.close();
         } catch (IOException exc) {
           // add nothing?
         }
       } else {
         for (File cont : fi.listFiles())
           if (!cont.isDirectory()) impJobs.add(impJob(cont, null, null));
       }
     } else {
       impJobs.add(impJob(fi, null, null));
     }
   }
   if (impJobs.size() > 1 || dirs) { // dont bother user if selected single file
     String shw = "Importing:";
     if (impJobs.size() > 30) shw = null;
     int pcount = 0;
     for (String jb : impJobs) {
       String[] prts = jb.split(",", 4); // import jobs have 4 parts, import, name, date, tags
       if (shw != null) shw = shw + "\n  - " + new File(prts[1]).getName();
       if (!prts[3].equalsIgnoreCase(Storage.NEW_TAG)) {
         pcount++;
         if (shw != null) shw = shw + " []";
       }
     }
     if (shw == null) shw = "importing ";
     else shw = shw + "\n";
     shw = shw + impJobs.size() + "(" + pcount + ") files";
     if (JOptionPane.showConfirmDialog(frm, shw, "Confirm Import", JOptionPane.YES_NO_OPTION)
         != JOptionPane.YES_OPTION) return;
   }
   synchronized (jobs) {
     for (String j : impJobs) {
       if (priorityExport) jobs.addLast(j);
       else jobs.addFirst(j);
     }
   }
   updateStatus();
 }