tesseract_bin 1.0.0

data/vendor/tesseract-2.04/java/com/google/scrollview/ui/SVImageHandler.java

@@ -0,0 +1,228 @@
+// Copyright 2007 Google Inc. All Rights Reserved.
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); You may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
+// applicable law or agreed to in writing, software distributed under the
+// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+package com.google.scrollview.ui;
+
+import edu.umd.cs.piccolo.nodes.PImage;
+
+import java.awt.image.BufferedImage;
+import java.util.HashMap;
+
+/**
+ * The ScrollViewImageHandler is a helper class which takes care of image
+ * processing. It is used to construct an Image from the message-stream and
+ * basically consists of a number of utility functions to process the input
+ * stream.
+ * 
+ * @author wanke@google.com
+ */
+public class SVImageHandler {
+  /**
+   * Stores a mapping from the name of the string to its actual image. It
+   * enables us to re-use images without having to load or transmit them again
+   */
+  static HashMap<String, PImage> images = new HashMap<String, PImage>();
+
+  /** A global flag stating whether we are currently expecting Image data */
+  static boolean readImageData = false;
+
+  // TODO(wanke) Consider moving all this into an SVImage class.
+  /** These are all values belonging to the image which is currently being read */
+  static String imageName = null; // Image name
+  static int bytesRead = 0; // Nr. of bytes already read
+  static int bpp = 0; // Bit depth
+  static int pictureArray[]; // The array holding the actual image
+
+  static int bytePerPixel = 0; // # of used bytes to transmit a pixel (32 bpp
+                                // -> 7 BPP)
+  static int width = 0;
+  static int height = 0;
+
+  /* All methods are static, so we forbid to construct SVImageHandler objects */
+  private SVImageHandler() {
+  }
+
+  /**
+   * Takes a binary input string (consisting of '0' and '1' characters) and
+   * converts it to an integer representation usable as image data.
+   */
+  private static int[] processBinaryImage(String inputLine) {
+    int BLACK = 0;
+    int WHITE = Integer.MAX_VALUE;
+
+    int[] imgData = new int[inputLine.length()];
+
+    for (int i = 0; i < inputLine.length(); i++) {
+      if (inputLine.charAt(i) == '0') {
+        imgData[i] = WHITE;
+      } else if (inputLine.charAt(i) == '1') {
+        imgData[i] = BLACK;
+      } // BLACK is default anyway
+      else { // Something is wrong: We did get unexpected data
+        System.out.println("Error: unexpected non-image-data: ("
+            + SVImageHandler.bytesRead + "," + inputLine.length() + ","
+            + (SVImageHandler.height * SVImageHandler.width) + ")");
+        System.exit(1);
+      }
+    }
+    return imgData;
+  }
+
+  /**
+   * Takes an input string with pixel depth of 8 (represented by 2 bytes in
+   * hexadecimal format, e.g. FF for white) and converts it to an
+   * integer representation usable as image data
+   */
+  private static int[] processGrayImage(String inputLine) {
+    int[] imgData = new int[inputLine.length() / 2];
+    // Note: This is really inefficient, splitting it 2-byte-arrays in one pass
+    // would be wa faster than substring everytime.
+    for (int i = 0; i < inputLine.length(); i +=2) {
+      String s = inputLine.substring(i, i+1);
+      imgData[i] = Integer.parseInt(s, 16);
+    }
+    
+    return imgData;
+  }
+  
+  /**
+   * Takes an input string with pixel depth of 32 (represented by HTML-like
+   * colors in hexadecimal format, e.g. #00FF00 for green) and converts it to an
+   * integer representation usable as image data
+   */
+  private static int[] process32bppImage(String inputLine) {
+
+    String[] strData = inputLine.split("#");
+    int[] imgData = new int[strData.length - 1];
+
+    for (int i = 1; i < strData.length; i++) {
+      imgData[i - 1] = Integer.parseInt(strData[i], 16);
+    }
+
+    return imgData;
+  }
+
+  /**
+   * Called when all image data is transmitted. Generates the actual image used
+   * by java and puts it into the images-hashmap.
+   */
+  private static void closeImage() {
+
+    BufferedImage bi = null;
+    if (bpp == 1) {
+      bi = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);
+    } else if (bpp == 8) {
+      bi = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
+    } else if (bpp == 32) {
+      bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+    } else {
+      System.out.println("Unsupported Image Type: " + bpp + " bpp");
+      System.exit(1);
+    }
+
+    bi.setRGB(0, 0, width, height, pictureArray, 0, width);
+
+    PImage img = new PImage(bi);
+
+    images.put(imageName, img);
+
+    imageName = null;
+    readImageData = false;
+
+    System.out.println("(server, #Bytes:" + bytesRead + ") Image Completed");
+
+    bytesRead = 0;
+    bpp = 0;
+  }
+
+  /** Starts creation of a new image. */
+  public static void createImage(String name, int width, int height,
+      int bitsPerPixel) {
+    // Create buffered image that does not support transparency
+    bpp = bitsPerPixel;
+    if (bpp == 1) {
+      bytePerPixel = 1;
+    } else if (bpp == 8) {
+      bytePerPixel = 2;
+    } else if (bpp == 32) {
+      bytePerPixel = 7;
+    } else {
+      throw new IllegalArgumentException(
+          "bpp should be 1 (binary), 8 (gray) or 32 (argb), is " + bpp);
+    }
+    if (imageName != null) {
+      throw new IllegalArgumentException("Image " + imageName + " already opened!");
+    }
+    else {
+      imageName = name;
+      bytesRead = 0;
+      readImageData = true;
+      SVImageHandler.height = height;
+      SVImageHandler.width = width;
+      pictureArray = new int[width * height];
+    }   
+
+    System.out.println("Processing Image with " + bpp + " bpp, size " + width + "x" + height);
+  }
+
+  /**
+   * Opens an Image from location. This means the image does not have to be
+   * actually transfered over the network. Thus, it is a lot faster than using
+   * the createImage method.
+   * 
+   * @param location The (local) location from where to open the file. This is
+   * also the internal name associated with the image (if you want to draw it).
+   */
+  public static void openImage(String location) {
+    PImage img = new PImage(location);
+    images.put(location, img);
+  }
+
+  /** Find the image corresponding to a given name */
+  public static PImage getImage(String name) {
+    return images.get(name);
+  }
+
+  /**
+   * Gets called while currently reading image data. Decides, how to process it
+   * (which image type, whether all data is there).
+   */
+  public static void parseData(String inputLine) {
+    int[] data = null;
+
+    if (bpp == 1) {
+      data = processBinaryImage(inputLine);
+    } else if (bpp == 8) {
+      data = processGrayImage(inputLine);
+    } else if (bpp == 32) {
+      data = process32bppImage(inputLine);
+    } else {
+      System.out.println("Unsupported Bit Type: " + bpp);
+    }
+
+    System.arraycopy(data, 0, pictureArray, bytesRead, data.length);
+    bytesRead += data.length;
+
+    // We have read all image data - close the image
+    if (bytesRead == (height * width)) {
+      closeImage();
+    }
+  }
+
+  /** Returns whether we a currently reading image data or not */
+  public static boolean getReadImageData() {
+    return readImageData;
+  }
+
+  /** Computes how many bytes of the image data are still missing */
+  public static int getMissingRemainingBytes() {
+    return (height * width * bytePerPixel) - bytesRead;
+  }
+}

data/vendor/tesseract-2.04/java/com/google/scrollview/ui/SVMenuBar.java

@@ -0,0 +1,130 @@
+// Copyright 2007 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); You may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
+// applicable law or agreed to in writing, software distributed under the
+// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+package com.google.scrollview.ui;
+
+import com.google.scrollview.events.SVEventType;
+import com.google.scrollview.ui.SVWindow;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.HashMap;
+
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+
+/**
+ * The SVMenuBar class provides the functionality to add a menubar to
+ * ScrollView. Each menubar item gets associated with a (client-defined)
+ * command-id, which SVMenuBar will return upon clicking it.
+ *
+ * @author wanke@google.com
+ *
+ */
+public class SVMenuBar implements ActionListener {
+  /** The root entry to add items to. */
+  private JMenuBar root;
+  /** Contains a map of item name to its actual entry. */
+  private HashMap<String, SVAbstractMenuItem> items;
+  /** The window the menubar belongs to. */
+  private SVWindow svWindow;
+
+  /**
+   * Create a new SVMenuBar and place it at the top of the ScrollView window.
+   *
+   * @param scrollView The window our menubar belongs to.
+   */
+  public SVMenuBar(SVWindow scrollView) {
+    root = new JMenuBar();
+    svWindow = scrollView;
+    items = new HashMap<String, SVAbstractMenuItem>();
+    svWindow.setJMenuBar(root);
+  }
+
+
+  /**
+   * A click on one of the items in our menubar has occured. Forward it
+   * to the item itself to let it decide what happens.
+   */
+  public void actionPerformed(ActionEvent e) {
+    // Get the corresponding menuitem.
+    SVAbstractMenuItem svm = items.get(e.getActionCommand());
+
+    svm.performAction(svWindow, SVEventType.SVET_MENU);
+  }
+
+  /**
+   * Add a new entry to the menubar.
+   *
+   * @param parent The menu we add our new entry to (should have been defined
+   *        before). If the parent is "", we will add the entry to the root
+   *        (top-level)
+   * @param name The caption of the new entry.
+   * @param id The Id of the new entry. If it is -1, the entry will be treated
+   *        as a menu.
+   */
+  public void add(String parent, String name, int id) {
+    // A duplicate entry - we just throw it away, since its already in.
+    if (items.get(name) != null) { return; }
+    // A new submenu at the top-level
+    if (parent.equals("")) {
+      JMenu jli = new JMenu(name);
+      SVAbstractMenuItem mli = new SVSubMenuItem(name, jli);
+      items.put(name, mli);
+      root.add(jli);
+    }
+    // A new sub-submenu
+    else if (id == -1) {
+      SVAbstractMenuItem jmi = items.get(parent);
+      JMenu jli = new JMenu(name);
+      SVAbstractMenuItem mli = new SVSubMenuItem(name, jli);
+      items.put(name, mli);
+      jmi.add(jli);
+    }
+    // A new child entry. Add to appropriate parent.
+    else {
+      SVAbstractMenuItem jmi = items.get(parent);
+      if (jmi == null) {
+        System.out.println("ERROR: Unknown parent " + parent);
+        System.exit(1);
+      }
+      SVAbstractMenuItem mli = new SVEmptyMenuItem(id, name);
+      mli.mi.addActionListener(this);
+      items.put(name, mli);
+      jmi.add(mli);
+    }
+  }
+
+  /**
+   * Add a new checkbox entry to the menubar.
+   *
+   * @param parent The menu we add our new entry to (should have been defined
+   *        before). If the parent is "", we will add the entry to the root
+   *        (top-level)
+   * @param name The caption of the new entry.
+   * @param id The Id of the new entry. If it is -1, the entry will be treated
+   *        as a menu.
+   * @param b Whether the entry is initally flagged.
+   *
+   */
+
+  public void add(String parent, String name, int id, boolean b) {
+    SVAbstractMenuItem jmi = items.get(parent);
+    if (jmi == null) {
+      System.out.println("ERROR: Unknown parent " + parent);
+      System.exit(1);
+    }
+    SVAbstractMenuItem mli = new SVCheckboxMenuItem(id, name, b);
+    mli.mi.addActionListener(this);
+    items.put(name, mli);
+    jmi.add(mli);
+  }
+
+}

data/vendor/tesseract-2.04/java/com/google/scrollview/ui/SVMenuItem.java

@@ -0,0 +1,61 @@
+// Copyright 2007 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); You may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
+// applicable law or agreed to in writing, software distributed under the
+// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+package com.google.scrollview.ui;
+
+/**
+ * A MenuListItem is any sort of menu entry. This can either be within a popup
+ * menu or within a menubar. It can either be a submenu (only name and
+ * command-id) or a name with an associated value and possibly description. They
+ * can also have new entries added (if they are submenus).
+ *
+ * @author wanke@google.com
+ */
+
+import com.google.scrollview.events.SVEventType;
+
+import javax.swing.JMenuItem;
+
+/**
+ * Constructs a new menulistitem which also has a value and a description. For
+ * these, we will not have to ask the server what the value is when the user
+ * wants to change it, but can just call the client with the new value.
+ */
+class SVMenuItem extends SVAbstractMenuItem {
+  public String value = null;
+  public String desc = null;
+
+  SVMenuItem(int id, String name, String v, String d) {
+    super(id, name, new JMenuItem(name));
+    value = v;
+    desc = d;
+  }
+
+  /**
+   * Ask the user for new input for a variable and send it.
+   * Depending on whether there is a description given for the entry, show
+   * the description in the dialog or just show the name.
+   */
+  @Override
+  public void performAction(SVWindow window, SVEventType eventType) {
+    if (desc != null) {
+      window.showInputDialog(desc, value, id, eventType);
+    } else {
+      window.showInputDialog(name, value, id, eventType);
+    }
+  }
+
+  /** Returns the actual value of the MenuListItem. */
+  @Override
+  public String getValue() {
+    return value;
+  }
+}
+

data/vendor/tesseract-2.04/java/com/google/scrollview/ui/SVPopupMenu.java

@@ -0,0 +1,142 @@
+// Copyright 2007 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); You may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
+// applicable law or agreed to in writing, software distributed under the
+// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+package com.google.scrollview.ui;
+
+import com.google.scrollview.events.SVEventType;
+import com.google.scrollview.ui.SVMenuItem;
+import com.google.scrollview.ui.SVWindow;
+
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.HashMap;
+
+import javax.swing.JMenu;
+import javax.swing.JPopupMenu;
+
+/**
+ * The SVPopupMenu class provides the functionality to add a popup menu to
+ * ScrollView. Each popup menu item gets associated with a (client-defined)
+ * command-id, which SVPopupMenu will return upon clicking it.
+ *
+ * @author wanke@google.com
+ *
+ */
+
+public class SVPopupMenu implements ActionListener {
+  /** The root entry to add items to. */
+  private JPopupMenu root;
+  /** Contains a map of item name to its actual entry. */
+  private HashMap<String, SVAbstractMenuItem> items;
+  /** The window the menubar belongs to. */
+  private SVWindow svWindow;
+
+  /**
+   * Create a new SVPopupMenu and associate it with a ScrollView window.
+   *
+   * @param sv The window our popup menu belongs to.
+   */
+  SVPopupMenu(SVWindow sv) {
+    root = new JPopupMenu();
+    svWindow = sv;
+    items = new HashMap<String, SVAbstractMenuItem>();
+  }
+
+  /**
+   * Add a new entry to the menubar. For these items, the server will poll the
+   * client to ask what to do.
+   *
+   * @param parent The menu we add our new entry to (should have been defined
+   *        before). If the parent is "", we will add the entry to the root
+   *        (top-level)
+   * @param name The caption of the new entry.
+   * @param id The Id of the new entry. If it is -1, the entry will be treated
+   *        as a menu.
+   */
+  public void add(String parent, String name, int id) {
+    // A duplicate entry - we just throw it away, since its already in.
+    if (items.get(name) != null) { return; }
+    // A new submenu at the top-level
+    if (parent.equals("")) {
+      JMenu jli = new JMenu(name);
+      SVAbstractMenuItem mli = new SVSubMenuItem(name, jli);
+      items.put(name, mli);
+      root.add(jli);
+    }
+    // A new sub-submenu
+    else if (id == -1) {
+      SVAbstractMenuItem jmi = items.get(parent);
+      JMenu jli = new JMenu(name);
+      SVAbstractMenuItem mli = new SVSubMenuItem(name, jli);
+      items.put(name, mli);
+      jmi.add(jli);
+    }
+    // A new child entry. Add to appropriate parent.
+    else {
+      SVAbstractMenuItem jmi = items.get(parent);
+      if (jmi == null) {
+        System.out.println("ERROR: Unknown parent " + parent);
+        System.exit(1);
+      }
+      SVAbstractMenuItem mli = new SVEmptyMenuItem(id, name);
+      mli.mi.addActionListener(this);
+      items.put(name, mli);
+      jmi.add(mli);
+    }
+  }
+
+  /**
+   * Add a new entry to the menubar. In this case, we also know its value and
+   * possibly even have a description. For these items, the server will not poll
+   * the client to ask what to do, but just show an input dialog and send a
+   * message with the new value.
+   *
+   * @param parent The menu we add our new entry to (should have been defined
+   *        before). If the parent is "", we will add the entry to the root
+   *        (top-level)
+   * @param name The caption of the new entry.
+   * @param id The Id of the new entry. If it is -1, the entry will be treated
+   *        as a menu.
+   */
+  public void add(String parent, String name, int id, String value, String desc) {
+    SVAbstractMenuItem jmi = items.get(parent);
+    SVMenuItem mli = new SVMenuItem(id, name, value, desc);
+    mli.mi.addActionListener(this);
+    items.put(name, mli);
+    if (jmi == null) { // add to root
+      root.add(mli.mi);
+    } else { // add to parent
+      jmi.add(mli);
+    }
+  }
+
+
+
+  /**
+   * A click on one of the items in our menubar has occured. Forward it
+   * to the item itself to let it decide what happens.
+   */
+  public void actionPerformed(ActionEvent e) {
+
+    // Get the corresponding menuitem
+    SVAbstractMenuItem svm = items.get(e.getActionCommand());
+
+   svm.performAction(svWindow, SVEventType.SVET_POPUP);
+  }
+
+  /**
+   * Gets called by the SVEventHandler of the window to actually show the
+   * content of the popup menu.
+   */
+  public void show(Component Invoker, int x, int y) {
+    root.show(Invoker, x, y);
+  }
+}

data/vendor/tesseract-2.04/java/com/google/scrollview/ui/SVSubMenuItem.java

@@ -0,0 +1,41 @@
+// Copyright 2007 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); You may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
+// applicable law or agreed to in writing, software distributed under the
+// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+package com.google.scrollview.ui;
+
+/**
+ * A MenuListItem is any sort of menu entry. This can either be within a popup
+ * menu or within a menubar. It can either be a submenu (only name and
+ * command-id) or a name with an associated value and possibly description. They
+ * can also have new entries added (if they are submenus).
+ *
+ * @author wanke@google.com
+ */
+
+import javax.swing.JMenu;
+
+/** Constructs a new submenu which can hold other entries. */
+class SVSubMenuItem extends SVAbstractMenuItem {
+  public SVSubMenuItem(String name, JMenu jli) {
+    super(-1, name, jli);
+  }
+  /** Adds a child entry to the submenu. */
+  @Override
+  public void add(SVAbstractMenuItem mli) {
+    mi.add(mli.mi);
+  }
+  /** Adds a child menu to the submenu (or root node). */
+  @Override
+  public void add(JMenu jli) {
+    mi.add(jli);
+  }
+}
+
+