svwindow.java

来自「一个google的OCR源码」· Java 代码 · 共 644 行 · 第 1/2 页

   * memory, so if you intend to redraw an image, you do not have to use
   * createImage again.
   */
  public void drawImage(String internalName, int x_pos, int y_pos) {
    PImage img = SVImageHandler.getImage(internalName);
    img.setX(x_pos);
    img.setY(y_pos);
    layer.addChild(img);
  }

  /**
   * Draw a line from (x1,y1) to (x2,y2) using the current pen color and stroke.
   */
  public void drawLine(int x1, int y1, int x2, int y2) {
    PPath pn = PPath.createLine(x1, y1, x2, y2);
    pn.setStrokePaint(currentPenColor);
    pn.setPaint(null);  // Null paint may render faster than the default.
    pn.setStroke(stroke);
    pn.moveTo(x1, y1);
    pn.lineTo(x2, y2);
    layer.addChild(pn);
  }

  /**
   * Draw a rectangle given the two points (x1,y1) and (x2,y2) using the current
   * stroke, pen color for the border and the brush to fill the
   * interior.
   */
  public void drawRectangle(int x1, int y1, int x2, int y2) {

    if (x1 > x2) {
      int t = x1;
      x1 = x2;
      x2 = t;
    }
    if (y1 > y2) {
      int t = y1;
      y1 = y2;
      y2 = t;
    }

    PPath pn = PPath.createRectangle(x1, y1, x2 - x1, y2 - y1);
    pn.setStrokePaint(currentPenColor);
    pn.setStroke(stroke);
    pn.setPaint(currentBrushColor);
    layer.addChild(pn);
  }

  /**
   * Draw some text at (x,y) using the current pen color and text attributes. If
   * the current font does NOT support at least one character, it tries to find
   * a font which is capable of displaying it and use that to render the text.
   * Note: If the font says it can render a glyph, but in reality it turns out
   * to be crap, there is nothing we can do about it.
   */
  public void drawText(int x, int y, String text) {
    int unreadableCharAt = -1;
    char[] chars = text.toCharArray();
    PText pt = new PText(text);
    pt.setTextPaint(currentPenColor);
    pt.setFont(currentFont);

    // Check to see if every character can be displayed by the current font.
    for (int i = 0; i < chars.length; i++) {
      if (!currentFont.canDisplay(chars[i])) {
        // Set to the first not displayable character.
        unreadableCharAt = i;
        break;
      }
    }

    // Have to find some working font and use it for this text entry.
    if (unreadableCharAt != -1) {
      Font[] allfonts =
          GraphicsEnvironment.getLocalGraphicsEnvironment().getAllFonts();
      for (int j = 0; j < allfonts.length; j++) {
        if (allfonts[j].canDisplay(chars[unreadableCharAt])) {
          Font tempFont =
              new Font(allfonts[j].getFontName(), currentFont.getStyle(),
                  currentFont.getSize());
          pt.setFont(tempFont);
          break;
        }
      }
    }

    pt.setX(x);
    pt.setY(y);
    layer.addChild(pt);
  }

  /** Set the pen color to an RGB value */
  public void pen(int red, int green, int blue) {
    pen(red, green, blue, 255);
  }

  /** Set the pen color to an RGBA value */
  public void pen(int red, int green, int blue, int alpha) {
    currentPenColor = new Color(red, green, blue, alpha);
  }

  /**
   * Define how to display text. Note: underlined is not currently not supported
   */
  public void textAttributes(String font, int pixelSize, boolean bold,
      boolean italic, boolean underlined) {

    // For legacy reasons convert "Times" to "Times New Roman"
    if (font.equals("Times")) {
      font = "Times New Roman";
    }

    int style = Font.PLAIN;
    if (bold) {
      style += Font.BOLD;
    }
    if (italic) {
      style += Font.ITALIC;
    }
    currentFont = new Font(font, style, pixelSize);
  }

  /**
   * Zoom the window to the rectangle given the two points (x1,y1)
   * and (x2,y2), which must be greater than (x1,y1).
   */
  public void zoomRectangle(int x1, int y1, int x2, int y2) {
    if (x2 > x1 && y2 > y1) {
      winSizeX = getWidth();
      winSizeY = getHeight();
      int width = x2 - x1;
      int height = y2 - y1;
      // Since piccolo doesn't do this well either, pad with a margin
      // all the way around.
      int wmargin = width / 2;
      int hmargin = height / 2;
      double scalefactor = Math.min(winSizeX / (2.0 * wmargin + width),
                                    winSizeY / (2.0 * hmargin + height));
      PCamera lc = canvas.getCamera();
      lc.scaleView(scalefactor / lc.getViewScale());
      lc.animateViewToPanToBounds(new Rectangle(x1 - hmargin, y1 - hmargin,
                                                2 * wmargin + width,
                                                2 * hmargin + height), 0);
    }
  }

  /**
   * Flush buffers and update display.
   *
   * Only actually reacts if there are no more messages in the stack, to prevent
   * the canvas from flickering.
   */
  public void update() {
    // TODO(rays) fix bugs in piccolo or use something else.
    // The repaint function generates many
    // exceptions for no good reason. We catch and ignore as many as we
    // can here, but most of them are generated by the system repaints
    // caused by resizing/exposing parts of the window etc, and they
    // generate unwanted stack traces that have to be piped to /dev/null
    // (on linux).
    try {
      repaint();
    } catch (NullPointerException e) {
      // Do nothing so the output isn't full of stack traces.
    } catch (IllegalPathStateException e) {
      // Do nothing so the output isn't full of stack traces.
    }
  }

  /** Adds a checkbox entry to the menubar, c.f. SVMenubar.add(...) */
  public void addMenuBarItem(String parent, String name, int id,
                             boolean checked) {
    svMenuBar.add(parent, name, id, checked);
  }

  /** Adds a submenu to the menubar, c.f. SVMenubar.add(...) */
  public void addMenuBarItem(String parent, String name) {
    addMenuBarItem(parent, name, -1);
  }

  /** Adds a new entry to the menubar, c.f. SVMenubar.add(...) */
  public void addMenuBarItem(String parent, String name, int id) {
    if (svMenuBar == null) {
      svMenuBar = new SVMenuBar(this);

    }
    svMenuBar.add(parent, name, id);
  }

  /** Add a message to the message box. */
  public void addMessage(String message) {
    if (ta != null) {
      ta.append(message + "\n");
    } else {
      System.out.println(message + "\n");
    }
  }

  /**
   * This method converts a string which might contain hexadecimal values to a
   * string which contains the respective unicode counterparts.
   *
   * For example, Hall0x0094chen returns Hall<o umlaut>chen
   * encoded as utf8.
   *
   * @param input The original string, containing 0x values
   * @return The converted string which has the replaced unicode symbols
   */
  private static String convertIntegerStringToUnicodeString(String input) {
    StringBuffer sb = new StringBuffer(input);
    Pattern numbers = Pattern.compile("0x[0-9a-fA-F]{4}");
    Matcher matcher = numbers.matcher(sb);

    while (matcher.find()) {
      // Find the next match which resembles a hexadecimal value and convert it
      // to
      // its char value
      char a = (char) (Integer.decode(matcher.group()).intValue());

      // Replace the original with the new character
      sb.replace(matcher.start(), matcher.end(), String.valueOf(a));

      // Start again, since our positions have switched
      matcher.reset();
    }
    return sb.toString();
  }

  /**
   * Show a modal input dialog. The answer by the dialog is then send to the
   * client, together with the associated menu id, as SVET_POPUP
   *
   * @param msg The text that is displayed in the dialog.
   * @param def The default value of the dialog.
   * @param id The associated commandId
   * @param evtype The event this is associated with (usually SVET_MENU
   * or SVET_POPUP)
   */
  public void showInputDialog(String msg, String def, int id,
                              SVEventType evtype) {
    svEventHandler.timer.stop();
    String tmp =
        (String) JOptionPane.showInputDialog(this, msg, "",
            JOptionPane.QUESTION_MESSAGE, null, null, def);

    if (tmp != null) {
      tmp = convertIntegerStringToUnicodeString(tmp);
      SVEvent res = new SVEvent(evtype, this, id, tmp);
      ScrollView.addMessage(res);
    }
    svEventHandler.timer.restart();
  }


  /**
   * Shows a modal input dialog to the user. The return value is automatically
   * sent to the client as SVET_INPUT event (with command id -1).
   *
   * @param msg The text of the dialog.
   */
  public void showInputDialog(String msg) {
    showInputDialog(msg, null, -1, SVEventType.SVET_INPUT);
  }

  /**
   * Shows a dialog presenting "Yes" and "No" as answers and returns either a
   * "y" or "n" to the client.
   *
   * @param msg The text that is displayed in the dialog.
   */
  public void showYesNoDialog(String msg) {
    // res returns 0 on yes, 1 on no. Seems to be a bit counterintuitive
    int res =
        JOptionPane.showOptionDialog(this, msg, "", JOptionPane.YES_NO_OPTION,
            JOptionPane.QUESTION_MESSAGE, null, null, null);
    SVEvent e = null;

    if (res == 0) {
      e = new SVEvent(SVEventType.SVET_INPUT, this, 0, 0, 0, 0, "y");
    } else if (res == 1) {
      e = new SVEvent(SVEventType.SVET_INPUT, this, 0, 0, 0, 0, "n");
    }
    ScrollView.addMessage(e);
  }

  /** Adds a submenu to the popup menu, c.f. SVPopupMenu.add(...) */
  public void addPopupMenuItem(String parent, String name) {
    if (svPuMenu == null) {
      svPuMenu = new SVPopupMenu(this);
    }
    svPuMenu.add(parent, name, -1);
  }

  /** Adds a new menu entry to the popup menu, c.f. SVPopupMenu.add(...) */
  public void addPopupMenuItem(String parent, String name, int cmdEvent,
      String value, String desc) {
    if (svPuMenu == null) {
      svPuMenu = new SVPopupMenu(this);
    }
    svPuMenu.add(parent, name, cmdEvent, value, desc);
  }

  /** Destroys a window. */
  public void destroy() {
    ScrollView.addMessage(new SVEvent(SVEventType.SVET_DESTROY, this, 0,
        "SVET_DESTROY"));
    setVisible(false);
    // dispose();
  }

  /**
   * Open an image from a given file location and store it in memory. Pro:
   * Faster than createImage. Con: Works only on the local file system.
   *
   * @param filename The path to the image.
   */
  public void openImage(String filename) {
    SVImageHandler.openImage(filename);
  }

}