Initial Contribution
diff --git a/awt/java/awt/AWTEvent.java b/awt/java/awt/AWTEvent.java
new file mode 100644
index 0000000..1ed9a37
--- /dev/null
+++ b/awt/java/awt/AWTEvent.java
@@ -0,0 +1,618 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Dmitry A. Durnev, Michael Danilov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.util.EventObject;
+import java.util.Hashtable;
+import java.util.EventListener;
+
+import java.awt.event.*;
+
+/**
+ * The abstract AWT events is base class for all AWT events.
+ * This class and its subclasses supercede the original java.awt.Event class.
+ */
+public abstract class AWTEvent extends EventObject {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -1825314779160409405L;
+
+ /** The Constant COMPONENT_EVENT_MASK indicates the event relates to a component. */
+ public static final long COMPONENT_EVENT_MASK = 1;
+
+ /** The Constant CONTAINER_EVENT_MASK indicates the event relates to a container. */
+ public static final long CONTAINER_EVENT_MASK = 2;
+
+ /** The Constant FOCUS_EVENT_MASK indicates the event relates to the focus. */
+ public static final long FOCUS_EVENT_MASK = 4;
+
+ /** The Constant KEY_EVENT_MASK indicates the event relates to a key. */
+ public static final long KEY_EVENT_MASK = 8;
+
+ /** The Constant MOUSE_EVENT_MASK indicates the event relates to the mouse. */
+ public static final long MOUSE_EVENT_MASK = 16;
+
+ /** The Constant MOUSE_MOTION_EVENT_MASK indicates the event relates to a mouse motion. */
+ public static final long MOUSE_MOTION_EVENT_MASK = 32;
+
+ /** The Constant WINDOW_EVENT_MASK indicates the event relates to a window. */
+ public static final long WINDOW_EVENT_MASK = 64;
+
+ /** The Constant ACTION_EVENT_MASK indicates the event relates to an action. */
+ public static final long ACTION_EVENT_MASK = 128;
+
+ /** The Constant ADJUSTMENT_EVENT_MASK indicates the event relates to an adjustment. */
+ public static final long ADJUSTMENT_EVENT_MASK = 256;
+
+ /** The Constant ITEM_EVENT_MASK indicates the event relates to an item. */
+ public static final long ITEM_EVENT_MASK = 512;
+
+ /** The Constant TEXT_EVENT_MASK indicates the event relates to text. */
+ public static final long TEXT_EVENT_MASK = 1024;
+
+ /** The Constant INPUT_METHOD_EVENT_MASK indicates the event relates to an input method. */
+ public static final long INPUT_METHOD_EVENT_MASK = 2048;
+
+ /** The Constant PAINT_EVENT_MASK indicates the event relates to a paint method. */
+ public static final long PAINT_EVENT_MASK = 8192;
+
+ /** The Constant INVOCATION_EVENT_MASK indicates the event relates to a method invocation. */
+ public static final long INVOCATION_EVENT_MASK = 16384;
+
+ /** The Constant HIERARCHY_EVENT_MASK indicates the event relates to a hierarchy. */
+ public static final long HIERARCHY_EVENT_MASK = 32768;
+
+ /**
+ * The Constant HIERARCHY_BOUNDS_EVENT_MASK indicates the event relates to hierarchy bounds.
+ */
+ public static final long HIERARCHY_BOUNDS_EVENT_MASK = 65536;
+
+ /** The Constant MOUSE_WHEEL_EVENT_MASK indicates the event relates to the mouse wheel. */
+ public static final long MOUSE_WHEEL_EVENT_MASK = 131072;
+
+ /** The Constant WINDOW_STATE_EVENT_MASK indicates the event relates to a window state. */
+ public static final long WINDOW_STATE_EVENT_MASK = 262144;
+
+ /** The Constant WINDOW_FOCUS_EVENT_MASK indicates the event relates to a window focus. */
+ public static final long WINDOW_FOCUS_EVENT_MASK = 524288;
+
+ /** The Constant RESERVED_ID_MAX indicates the maximum value for reserved
+ * AWT event IDs.
+ */
+ public static final int RESERVED_ID_MAX = 1999;
+
+ /** The Constant eventsMap. */
+ private static final Hashtable<Integer, EventDescriptor> eventsMap = new Hashtable<Integer, EventDescriptor>();
+
+ /** The converter. */
+ private static EventConverter converter;
+
+ /** The ID of the event. */
+ protected int id;
+
+ /**
+ * The consumed indicates whether or not the event is sent back down to
+ * the peer once the source has processed it (false means it's sent to the peer,
+ * true means it's not).
+ */
+ protected boolean consumed;
+
+ /** The dispatched by kfm. */
+ boolean dispatchedByKFM;
+
+ /** The is posted. */
+ transient boolean isPosted;
+
+ static {
+ eventsMap.put(new Integer(KeyEvent.KEY_TYPED),
+ new EventDescriptor(KEY_EVENT_MASK, KeyListener.class));
+ eventsMap.put(new Integer(KeyEvent.KEY_PRESSED),
+ new EventDescriptor(KEY_EVENT_MASK, KeyListener.class));
+ eventsMap.put(new Integer(KeyEvent.KEY_RELEASED),
+ new EventDescriptor(KEY_EVENT_MASK, KeyListener.class));
+ eventsMap.put(new Integer(MouseEvent.MOUSE_CLICKED),
+ new EventDescriptor(MOUSE_EVENT_MASK, MouseListener.class));
+ eventsMap.put(new Integer(MouseEvent.MOUSE_PRESSED),
+ new EventDescriptor(MOUSE_EVENT_MASK, MouseListener.class));
+ eventsMap.put(new Integer(MouseEvent.MOUSE_RELEASED),
+ new EventDescriptor(MOUSE_EVENT_MASK, MouseListener.class));
+ eventsMap.put(new Integer(MouseEvent.MOUSE_MOVED),
+ new EventDescriptor(MOUSE_MOTION_EVENT_MASK, MouseMotionListener.class));
+ eventsMap.put(new Integer(MouseEvent.MOUSE_ENTERED),
+ new EventDescriptor(MOUSE_EVENT_MASK, MouseListener.class));
+ eventsMap.put(new Integer(MouseEvent.MOUSE_EXITED),
+ new EventDescriptor(MOUSE_EVENT_MASK, MouseListener.class));
+ eventsMap.put(new Integer(MouseEvent.MOUSE_DRAGGED),
+ new EventDescriptor(MOUSE_MOTION_EVENT_MASK, MouseMotionListener.class));
+ eventsMap.put(new Integer(MouseEvent.MOUSE_WHEEL),
+ new EventDescriptor(MOUSE_WHEEL_EVENT_MASK, MouseWheelListener.class));
+ eventsMap.put(new Integer(ComponentEvent.COMPONENT_MOVED),
+ new EventDescriptor(COMPONENT_EVENT_MASK, ComponentListener.class));
+ eventsMap.put(new Integer(ComponentEvent.COMPONENT_RESIZED),
+ new EventDescriptor(COMPONENT_EVENT_MASK, ComponentListener.class));
+ eventsMap.put(new Integer(ComponentEvent.COMPONENT_SHOWN),
+ new EventDescriptor(COMPONENT_EVENT_MASK, ComponentListener.class));
+ eventsMap.put(new Integer(ComponentEvent.COMPONENT_HIDDEN),
+ new EventDescriptor(COMPONENT_EVENT_MASK, ComponentListener.class));
+ eventsMap.put(new Integer(FocusEvent.FOCUS_GAINED),
+ new EventDescriptor(FOCUS_EVENT_MASK, FocusListener.class));
+ eventsMap.put(new Integer(FocusEvent.FOCUS_LOST),
+ new EventDescriptor(FOCUS_EVENT_MASK, FocusListener.class));
+ eventsMap.put(new Integer(PaintEvent.PAINT),
+ new EventDescriptor(PAINT_EVENT_MASK, null));
+ eventsMap.put(new Integer(PaintEvent.UPDATE),
+ new EventDescriptor(PAINT_EVENT_MASK, null));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_OPENED),
+ new EventDescriptor(WINDOW_EVENT_MASK, WindowListener.class));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_CLOSING),
+ new EventDescriptor(WINDOW_EVENT_MASK, WindowListener.class));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_CLOSED),
+ new EventDescriptor(WINDOW_EVENT_MASK, WindowListener.class));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_DEICONIFIED),
+ new EventDescriptor(WINDOW_EVENT_MASK, WindowListener.class));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_ICONIFIED),
+ new EventDescriptor(WINDOW_EVENT_MASK, WindowListener.class));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_STATE_CHANGED),
+ new EventDescriptor(WINDOW_STATE_EVENT_MASK, WindowStateListener.class));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_LOST_FOCUS),
+ new EventDescriptor(WINDOW_FOCUS_EVENT_MASK, WindowFocusListener.class));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_GAINED_FOCUS),
+ new EventDescriptor(WINDOW_FOCUS_EVENT_MASK, WindowFocusListener.class));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_DEACTIVATED),
+ new EventDescriptor(WINDOW_EVENT_MASK, WindowListener.class));
+ eventsMap.put(new Integer(WindowEvent.WINDOW_ACTIVATED),
+ new EventDescriptor(WINDOW_EVENT_MASK, WindowListener.class));
+ eventsMap.put(new Integer(HierarchyEvent.HIERARCHY_CHANGED),
+ new EventDescriptor(HIERARCHY_EVENT_MASK, HierarchyListener.class));
+ eventsMap.put(new Integer(HierarchyEvent.ANCESTOR_MOVED),
+ new EventDescriptor(HIERARCHY_BOUNDS_EVENT_MASK, HierarchyBoundsListener.class));
+ eventsMap.put(new Integer(HierarchyEvent.ANCESTOR_RESIZED),
+ new EventDescriptor(HIERARCHY_BOUNDS_EVENT_MASK, HierarchyBoundsListener.class));
+ eventsMap.put(new Integer(ContainerEvent.COMPONENT_ADDED),
+ new EventDescriptor(CONTAINER_EVENT_MASK, ContainerListener.class));
+ eventsMap.put(new Integer(ContainerEvent.COMPONENT_REMOVED),
+ new EventDescriptor(CONTAINER_EVENT_MASK, ContainerListener.class));
+ eventsMap.put(new Integer(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED),
+ new EventDescriptor(INPUT_METHOD_EVENT_MASK, InputMethodListener.class));
+ eventsMap.put(new Integer(InputMethodEvent.CARET_POSITION_CHANGED),
+ new EventDescriptor(INPUT_METHOD_EVENT_MASK, InputMethodListener.class));
+ eventsMap.put(new Integer(InvocationEvent.INVOCATION_DEFAULT),
+ new EventDescriptor(INVOCATION_EVENT_MASK, null));
+ eventsMap.put(new Integer(ItemEvent.ITEM_STATE_CHANGED),
+ new EventDescriptor(ITEM_EVENT_MASK, ItemListener.class));
+ eventsMap.put(new Integer(TextEvent.TEXT_VALUE_CHANGED),
+ new EventDescriptor(TEXT_EVENT_MASK, TextListener.class));
+ eventsMap.put(new Integer(ActionEvent.ACTION_PERFORMED),
+ new EventDescriptor(ACTION_EVENT_MASK, ActionListener.class));
+ eventsMap.put(new Integer(AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED),
+ new EventDescriptor(ADJUSTMENT_EVENT_MASK, AdjustmentListener.class));
+ converter = new EventConverter();
+ }
+
+ /**
+ * Instantiates a new AWT event from the specified Event object.
+ *
+ * @param event the Event object.
+ */
+ public AWTEvent(Event event) {
+ this(event.target, event.id);
+ }
+
+ /**
+ * Instantiates a new AWT event with the specified object and type.
+ *
+ * @param source the source Object.
+ * @param id the event's type.
+ */
+ public AWTEvent(Object source, int id) {
+ super(source);
+ this.id = id;
+ consumed = false;
+ }
+
+ /**
+ * Gets the event's type.
+ *
+ * @return the event type ID.
+ */
+ public int getID() {
+ return id;
+ }
+
+ /**
+ * Sets a new source for the AWTEvent.
+ *
+ * @param newSource the new source Object for the AWTEvent.
+ */
+ public void setSource(Object newSource) {
+ source = newSource;
+ }
+
+ /**
+ * Returns a String representation of the AWTEvent.
+ *
+ * @return the String representation of the AWTEvent.
+ */
+ @Override
+ public String toString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * AWTEvent event = new AWTEvent(new Component(){}, 1){};
+ * System.out.println(event);
+ */
+ String name = ""; //$NON-NLS-1$
+
+ if (source instanceof Component && (source != null)) {
+ Component comp = (Component) getSource();
+ name = comp.getName();
+ if (name == null) {
+ name = ""; //$NON-NLS-1$
+ }
+ }
+
+ return (getClass().getName() + "[" + paramString() + "]" //$NON-NLS-1$ //$NON-NLS-2$
+ + " on " + (name.length() > 0 ? name : source)); //$NON-NLS-1$
+ }
+
+ /**
+ * Returns a string representation of the AWTEvent state.
+ *
+ * @return a string representation of the AWTEvent state.
+ */
+ public String paramString() {
+ //nothing to implement: all event types must override this method
+ return ""; //$NON-NLS-1$
+ }
+
+ /**
+ * Checks whether or not this AWTEvent has been consumed.
+ *
+ * @return true, if this AWTEvent has been consumed, false otherwise.
+ */
+ protected boolean isConsumed() {
+ return consumed;
+ }
+
+ /**
+ * Consumes the AWTEvent.
+ */
+ protected void consume() {
+ consumed = true;
+ }
+
+ /**
+ * Convert AWTEvent object to a corresponding (deprecated) Event object.
+ *
+ * @return new Event object which is a converted AWTEvent object or null
+ * if the conversion is not possible
+ */
+ Event getEvent() {
+
+ if (id == ActionEvent.ACTION_PERFORMED) {
+ ActionEvent ae = (ActionEvent) this;
+ return converter.convertActionEvent(ae);
+
+ } else if (id == AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED) {
+ AdjustmentEvent ae = (AdjustmentEvent) this;
+ return converter.convertAdjustmentEvent(ae);
+
+//???AWT
+// } else if (id == ComponentEvent.COMPONENT_MOVED
+// && source instanceof Window) {
+// //the only type of Component events is COMPONENT_MOVED on window
+// ComponentEvent ce = (ComponentEvent) this;
+// return converter.convertComponentEvent(ce);
+
+ } else if (id >= FocusEvent.FOCUS_FIRST && id <= FocusEvent.FOCUS_LAST) {
+ //nothing to convert
+
+//???AWT
+// } else if (id == ItemEvent.ITEM_STATE_CHANGED) {
+// ItemEvent ie = (ItemEvent) this;
+// return converter.convertItemEvent(ie);
+
+ } else if (id == KeyEvent.KEY_PRESSED || id == KeyEvent.KEY_RELEASED) {
+ KeyEvent ke = (KeyEvent) this;
+ return converter.convertKeyEvent(ke);
+ } else if (id >= MouseEvent.MOUSE_FIRST && id <= MouseEvent.MOUSE_LAST) {
+ MouseEvent me = (MouseEvent) this;
+ return converter.convertMouseEvent(me);
+ } else if (id == WindowEvent.WINDOW_CLOSING
+ || id == WindowEvent.WINDOW_ICONIFIED
+ || id == WindowEvent.WINDOW_DEICONIFIED) {
+ //nothing to convert
+ } else {
+ return null;
+ }
+ return new Event(source, id, null);
+ }
+
+
+ /**
+ * The Class EventDescriptor.
+ */
+ static final class EventDescriptor {
+
+ /** The event mask. */
+ final long eventMask;
+
+ /** The listener type. */
+ final Class<? extends EventListener> listenerType;
+
+ /**
+ * Instantiates a new event descriptor.
+ *
+ * @param eventMask the event mask
+ * @param listenerType the listener type
+ */
+ EventDescriptor(long eventMask, Class<? extends EventListener> listenerType) {
+ this.eventMask = eventMask;
+ this.listenerType = listenerType;
+ }
+
+ }
+
+ /**
+ * The Class EventTypeLookup.
+ */
+ static final class EventTypeLookup {
+
+ /** The last event. */
+ private AWTEvent lastEvent = null;
+
+ /** The last event descriptor. */
+ private EventDescriptor lastEventDescriptor = null;
+
+ /**
+ * Gets the event descriptor.
+ *
+ * @param event the event
+ *
+ * @return the event descriptor
+ */
+ EventDescriptor getEventDescriptor(AWTEvent event) {
+ synchronized (this) {
+ if (event != lastEvent) {
+ lastEvent = event;
+ lastEventDescriptor = eventsMap.get(new Integer(event.id));
+ }
+
+ return lastEventDescriptor;
+ }
+ }
+
+ /**
+ * Gets the event mask.
+ *
+ * @param event the event
+ *
+ * @return the event mask
+ */
+ long getEventMask(AWTEvent event) {
+ final EventDescriptor ed = getEventDescriptor(event);
+ return ed == null ? -1 : ed.eventMask;
+ }
+ }
+
+ /**
+ * The Class EventConverter.
+ */
+ static final class EventConverter {
+
+ /** The Constant OLD_MOD_MASK. */
+ static final int OLD_MOD_MASK = Event.ALT_MASK | Event.CTRL_MASK
+ | Event.META_MASK | Event.SHIFT_MASK;
+
+ /**
+ * Convert action event.
+ *
+ * @param ae the ae
+ *
+ * @return the event
+ */
+ Event convertActionEvent(ActionEvent ae) {
+ Event evt = new Event(ae.getSource(), ae.getID(), ae.getActionCommand());
+ evt.when = ae.getWhen();
+ evt.modifiers = ae.getModifiers() & OLD_MOD_MASK;
+
+ /* if (source instanceof Button) {
+ arg = ((Button) source).getLabel();
+ } else if (source instanceof Checkbox) {
+ arg = new Boolean(((Checkbox) source).getState());
+ } else if (source instanceof CheckboxMenuItem) {
+ arg = ((CheckboxMenuItem) source).getLabel();
+ } else if (source instanceof Choice) {
+ arg = ((Choice) source).getSelectedItem();
+ } else if (source instanceof List) {
+ arg = ((List) source).getSelectedItem();
+ } else if (source instanceof MenuItem) {
+ arg = ((MenuItem) source).getLabel();
+ } else if (source instanceof TextField) {
+ arg = ((TextField) source).getText();
+ }
+*/
+ return evt;
+ }
+
+
+ /**
+ * Convert adjustment event.
+ *
+ * @param ae the ae
+ *
+ * @return the event
+ */
+ Event convertAdjustmentEvent(AdjustmentEvent ae) {
+ //TODO: Event.SCROLL_BEGIN/SCROLL_END
+ return new Event(ae.source, ae.id + ae.getAdjustmentType() - 1,
+ new Integer(ae.getValue()));
+ }
+
+ /**
+ * Convert component event.
+ *
+ * @param ce the ce
+ *
+ * @return the event
+ */
+ Event convertComponentEvent(ComponentEvent ce) {
+ Component comp = ce.getComponent();
+ Event evt = new Event(comp, Event.WINDOW_MOVED, null);
+ evt.x = comp.getX();
+ evt.y = comp.getY();
+ return evt;
+ }
+
+ //???AWT
+ /*
+ Event convertItemEvent(ItemEvent ie) {
+ int oldId = ie.id + ie.getStateChange() - 1;
+ Object source = ie.source;
+ int idx = -1;
+ if (source instanceof List) {
+ List list = (List) source;
+ idx = list.getSelectedIndex();
+ }
+ else if (source instanceof Choice) {
+ Choice choice = (Choice) source;
+ idx = choice.getSelectedIndex();
+ }
+ Object arg = idx >= 0 ? new Integer(idx) : null;
+ return new Event(source, oldId, arg);
+ }
+ */
+
+ /**
+ * Convert key event.
+ *
+ * @param ke the ke
+ *
+ * @return the event
+ */
+ Event convertKeyEvent(KeyEvent ke) {
+ int oldId = ke.id;
+ //leave only old Event's modifiers
+
+ int mod = ke.getModifiers() & OLD_MOD_MASK;
+ Component comp = ke.getComponent();
+ char keyChar = ke.getKeyChar();
+ int keyCode = ke.getKeyCode();
+ int key = convertKey(keyChar, keyCode);
+ if (key >= Event.HOME && key <= Event.INSERT) {
+ oldId += 2; //non-ASCII key -> action key
+ }
+ return new Event(comp, ke.getWhen(), oldId, 0, 0, key, mod);
+ }
+
+ /**
+ * Convert mouse event.
+ *
+ * @param me the me
+ *
+ * @return the event
+ */
+ Event convertMouseEvent(MouseEvent me) {
+ int id = me.id;
+ if (id != MouseEvent.MOUSE_CLICKED) {
+ Event evt = new Event(me.source, id, null);
+ evt.x = me.getX();
+ evt.y = me.getY();
+ int mod = me.getModifiers();
+ //in Event modifiers mean button number for mouse events:
+ evt.modifiers = mod & (Event.ALT_MASK | Event.META_MASK);
+ if (id == MouseEvent.MOUSE_PRESSED) {
+ evt.clickCount = me.getClickCount();
+ }
+ return evt;
+ }
+ return null;
+ }
+
+ /**
+ * Convert key.
+ *
+ * @param keyChar the key char
+ * @param keyCode the key code
+ *
+ * @return the int
+ */
+ int convertKey(char keyChar, int keyCode) {
+ int key;
+ //F1 - F12
+ if (keyCode >= KeyEvent.VK_F1 && keyCode <= KeyEvent.VK_F12) {
+ key = Event.F1 + keyCode - KeyEvent.VK_F1;
+ } else {
+ switch (keyCode) {
+ default: //non-action key
+ key = keyChar;
+ break;
+ //action keys:
+ case KeyEvent.VK_HOME:
+ key = Event.HOME;
+ break;
+ case KeyEvent.VK_END:
+ key = Event.END;
+ break;
+ case KeyEvent.VK_PAGE_UP:
+ key = Event.PGUP;
+ break;
+ case KeyEvent.VK_PAGE_DOWN:
+ key = Event.PGDN;
+ break;
+ case KeyEvent.VK_UP:
+ key = Event.UP;
+ break;
+ case KeyEvent.VK_DOWN:
+ key = Event.DOWN;
+ break;
+ case KeyEvent.VK_LEFT:
+ key = Event.LEFT;
+ break;
+ case KeyEvent.VK_RIGHT:
+ key = Event.RIGHT;
+ break;
+ case KeyEvent.VK_PRINTSCREEN:
+ key = Event.PRINT_SCREEN;
+ break;
+ case KeyEvent.VK_SCROLL_LOCK:
+ key = Event.SCROLL_LOCK;
+ break;
+ case KeyEvent.VK_CAPS_LOCK:
+ key = Event.CAPS_LOCK;
+ break;
+ case KeyEvent.VK_NUM_LOCK:
+ key = Event.NUM_LOCK;
+ break;
+ case KeyEvent.VK_PAUSE:
+ key = Event.PAUSE;
+ break;
+ case KeyEvent.VK_INSERT:
+ key = Event.INSERT;
+ break;
+ }
+ }
+ return key;
+ }
+
+ }
+
+}
diff --git a/awt/java/awt/AWTException.java b/awt/java/awt/AWTException.java
new file mode 100644
index 0000000..70ce6e1
--- /dev/null
+++ b/awt/java/awt/AWTException.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt;
+
+
+/**
+ * The AWTException class is used to provide notification and information
+ * about AWT errors.
+ */
+public class AWTException extends Exception {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -1900414231151323879L;
+
+ /**
+ * Instantiates a new AWT exception with the specified message.
+ *
+ * @param msg the specific message for current exception.
+ */
+ public AWTException(String msg) {
+ super(msg);
+ }
+
+}
+
diff --git a/awt/java/awt/AWTKeyStroke.java b/awt/java/awt/AWTKeyStroke.java
new file mode 100644
index 0000000..5e7de4e
--- /dev/null
+++ b/awt/java/awt/AWTKeyStroke.java
@@ -0,0 +1,678 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Dmitry A. Durnev
+ * @version $Revision$
+ */
+package java.awt;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.StringTokenizer;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The AWTKeyStroke holds all of the information for the complete act of
+ * typing a character. This includes the events that are generated when
+ * the key is pressed, released, or typed (pressed and released generating
+ * a unicode character result) which are associated with the event
+ * objects KeyEvent.KEY_PRESSED, KeyEvent.KEY_RELEASED, or KeyEvent.KEY_TYPED.
+ * It also holds information about which modifiers (such as control or
+ * shift) were used in conjunction with the keystroke. The following masks
+ * are available to identify the modifiers:
+ * <ul>
+ * <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.CTRL_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.META_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.SHIFT_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_GRAPH_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_MASK</li>
+ * <li>java.awt.event.InputEvent.CTRL_MASK</li>
+ * <li>java.awt.event.InputEvent.META_MASK</li>
+ * <li>java.awt.event.InputEvent.SHIFT_MASK</li>
+ * </ul>
+ * <br>
+ * The AWTKeyStroke is unique, and applications should not create their own
+ * instances of AWTKeyStroke. All applications should use getAWTKeyStroke
+ * methods for obtaining instances of AWTKeyStroke.
+ */
+public class AWTKeyStroke implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -6430539691155161871L;
+
+ /** The Constant cache. */
+ private static final Map<AWTKeyStroke, AWTKeyStroke> cache = new HashMap<AWTKeyStroke, AWTKeyStroke>(); //Map<AWTKeyStroke, ? extends AWTKeyStroke>
+
+ /** The Constant keyEventTypesMap. */
+ private static final Map<Integer, String> keyEventTypesMap = new HashMap<Integer, String>(); //Map<int, String>
+
+ private static Constructor<?> subConstructor;
+
+ static {
+ keyEventTypesMap.put(new Integer(KeyEvent.KEY_PRESSED), "pressed"); //$NON-NLS-1$
+ keyEventTypesMap.put(new Integer(KeyEvent.KEY_RELEASED), "released"); //$NON-NLS-1$
+ keyEventTypesMap.put(new Integer(KeyEvent.KEY_TYPED), "typed"); //$NON-NLS-1$
+ }
+
+ /** The key char. */
+ private char keyChar;
+
+ /** The key code. */
+ private int keyCode;
+
+ /** The modifiers. */
+ private int modifiers;
+
+ /** The on key release. */
+ private boolean onKeyRelease;
+
+ /**
+ * Instantiates a new AWTKeyStroke.
+ * getAWTKeyStroke method should be used by applications code.
+ *
+ * @param keyChar the key char
+ * @param keyCode the key code
+ * @param modifiers the modifiers
+ * @param onKeyRelease true if AWTKeyStroke is for a key release, overwise false.
+ */
+ protected AWTKeyStroke(char keyChar, int keyCode, int modifiers,
+ boolean onKeyRelease)
+ {
+ setAWTKeyStroke(keyChar, keyCode, modifiers, onKeyRelease);
+ }
+
+ /** Sets the awt key stroke.
+ *
+ * @param keyChar the key char
+ * @param keyCode the key code
+ * @param modifiers the modifiers
+ * @param onKeyRelease the on key release
+ */
+ private void setAWTKeyStroke( char keyChar, int keyCode, int modifiers,
+ boolean onKeyRelease)
+ {
+ this.keyChar = keyChar;
+ this.keyCode = keyCode;
+ this.modifiers = modifiers;
+ this.onKeyRelease = onKeyRelease;
+ }
+
+ /**
+ * Instantiates a new AWTKeyStroke with default parameters:
+ * KeyEvent.CHAR_UNDEFINED key char, KeyEvent.VK_UNDEFINED key code,
+ * without modifiers and false key realised value.
+ */
+ protected AWTKeyStroke() {
+ this(KeyEvent.CHAR_UNDEFINED, KeyEvent.VK_UNDEFINED, 0, false);
+ }
+
+ /**
+ * Returns the unique number value for AWTKeyStroke object.
+ *
+ * @return the int unique value of the AWTKeyStroke object.
+ */
+ @Override
+ public int hashCode() {
+ return modifiers + ( keyCode != KeyEvent.VK_UNDEFINED ?
+ keyCode : keyChar) + (onKeyRelease ? -1 : 0);
+ }
+
+ /**
+ * Gets the set of modifiers for the AWTKeyStroke object.
+ *
+ * @return the int value which contains modifiers.
+ */
+ public final int getModifiers() {
+ return modifiers;
+ }
+
+ /**
+ * Compares the AWTKeyStroke object to the specified object.
+ *
+ * @return true, if objects are identical, overwise false.
+ */
+ @Override
+ public final boolean equals(Object anObject) {
+ if (anObject instanceof AWTKeyStroke) {
+ AWTKeyStroke key = (AWTKeyStroke)anObject;
+ return ((key.keyCode == keyCode) && (key.keyChar == keyChar) &&
+ (key.modifiers == modifiers) &&
+ (key.onKeyRelease == onKeyRelease));
+ }
+ return false;
+ }
+
+ /**
+ * Returns the string representation of the AWTKeyStroke.
+ * This string should contain key stroke properties.
+ *
+ * @return the string representation of the AWTKeyStroke.
+ */
+ @Override
+ public String toString() {
+ int type = getKeyEventType();
+ return InputEvent.getModifiersExText(getModifiers()) + " " + //$NON-NLS-1$
+ keyEventTypesMap.get(new Integer(type)) + " " + //$NON-NLS-1$
+ (type == KeyEvent.KEY_TYPED ? new String(new char[] {keyChar}) :
+ KeyEvent.getKeyText(keyCode));
+ }
+
+ /**
+ * Gets the key code for the AWTKeyStroke object.
+ *
+ * @return the key code for the AWTKeyStroke object.
+ */
+ public final int getKeyCode() {
+ return keyCode;
+ }
+
+ /**
+ * Gets the key character for the AWTKeyStroke object.
+ *
+ * @return the key character for the AWTKeyStroke object.
+ */
+ public final char getKeyChar() {
+ return keyChar;
+ }
+
+ /**
+ * Gets the AWT key stroke.
+ *
+ * @param keyChar the key char
+ * @param keyCode the key code
+ * @param modifiers the modifiers
+ * @param onKeyRelease the on key release
+ *
+ * @return the AWT key stroke
+ */
+ private static AWTKeyStroke getAWTKeyStroke(char keyChar, int keyCode,
+ int modifiers,
+ boolean onKeyRelease) {
+ AWTKeyStroke key = newInstance(keyChar, keyCode, modifiers, onKeyRelease);
+
+ AWTKeyStroke value = cache.get(key);
+ if (value == null) {
+ value = key;
+ cache.put(key, value);
+ }
+ return value;
+ }
+
+ /**
+ * New instance.
+ *
+ * @param keyChar the key char
+ * @param keyCode the key code
+ * @param modifiers the modifiers
+ * @param onKeyRelease the on key release
+ *
+ * @return the AWT key stroke
+ */
+ private static AWTKeyStroke newInstance(char keyChar, int keyCode,
+ int modifiers,
+ boolean onKeyRelease) {
+ AWTKeyStroke key;
+ //???AWT
+// if (subConstructor == null) {
+ key = new AWTKeyStroke();
+ //???AWT
+// } else {
+// try {
+// key = (AWTKeyStroke) subConstructor.newInstance();
+// } catch (Exception e) {
+// throw new RuntimeException(e);
+// }
+// }
+ int allModifiers = getAllModifiers(modifiers);
+ key.setAWTKeyStroke(keyChar, keyCode, allModifiers, onKeyRelease);
+ return key;
+ }
+
+ /**
+ * Adds the mask.
+ *
+ * @param mod the mod
+ * @param mask the mask
+ *
+ * @return the int
+ */
+ private static int addMask(int mod, int mask) {
+ return ((mod & mask) != 0) ? (mod | mask) : mod;
+ }
+
+ /**
+ * return all (old & new) modifiers corresponding to.
+ *
+ * @param mod old or new modifiers
+ *
+ * @return old and new modifiers together
+ */
+ static int getAllModifiers(int mod) {
+ int allMod = mod;
+ int shift = (InputEvent.SHIFT_MASK | InputEvent.SHIFT_DOWN_MASK);
+ int ctrl = (InputEvent.CTRL_MASK | InputEvent.CTRL_DOWN_MASK);
+ int meta = (InputEvent.META_MASK | InputEvent.META_DOWN_MASK);
+ int alt = (InputEvent.ALT_MASK | InputEvent.ALT_DOWN_MASK);
+ int altGr = (InputEvent.ALT_GRAPH_MASK | InputEvent.ALT_GRAPH_DOWN_MASK);
+ // button modifiers are not converted between old & new
+
+ allMod = addMask(allMod, shift);
+ allMod = addMask(allMod, ctrl);
+ allMod = addMask(allMod, meta);
+ allMod = addMask(allMod, alt);
+ allMod = addMask(allMod, altGr);
+
+ return allMod;
+ }
+
+ /**
+ * Returns an instance of AWTKeyStroke for parsed string.
+ *
+ * The string must have the following syntax:
+ *<p>
+ * <modifiers>* (<typedID> | <pressedReleasedID>)
+ *<p>
+ * modifiers := shift | control | ctrl | meta | alt | altGraph
+ * <br>
+ * typedID := typed <typedKey>
+ * <br>
+ * typedKey := string of length 1 giving the Unicode character.
+ * <br>
+ * pressedReleasedID := (pressed | released) <key>
+ * <br>
+ * key := KeyEvent key code name, i.e. the name following "VK_".
+ * <p>
+ * @param s the String which contains key stroke parameters.
+ *
+ * @return the AWTKeyStroke for string.
+ *
+ * @throws IllegalArgumentException if string has incorrect format or null.
+ */
+ public static AWTKeyStroke getAWTKeyStroke(String s) {
+ if (s == null) {
+ // awt.65=null argument
+ throw new IllegalArgumentException(Messages.getString("awt.65")); //$NON-NLS-1$
+ }
+
+ StringTokenizer tokenizer = new StringTokenizer(s);
+
+ Boolean release = null;
+ int modifiers = 0;
+ int keyCode = KeyEvent.VK_UNDEFINED;
+ char keyChar = KeyEvent.CHAR_UNDEFINED;
+ boolean typed = false;
+ long modifier = 0;
+ String token = null;
+ do {
+ token = getNextToken(tokenizer);
+ modifier = parseModifier(token);
+ modifiers |= modifier;
+ } while (modifier > 0);
+
+ typed = parseTypedID(token);
+
+ if (typed) {
+ token = getNextToken(tokenizer);
+ keyChar = parseTypedKey(token);
+
+ }
+ if (keyChar == KeyEvent.CHAR_UNDEFINED) {
+ release = parsePressedReleasedID(token);
+ if (release != null) {
+ token = getNextToken(tokenizer);
+ }
+ keyCode = parseKey(token);
+ }
+ if (tokenizer.hasMoreTokens()) {
+ // awt.66=Invalid format
+ throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
+ }
+
+ return getAWTKeyStroke(keyChar, keyCode, modifiers,
+ release == Boolean.TRUE);
+ }
+
+ /**
+ * Gets the next token.
+ *
+ * @param tokenizer the tokenizer
+ *
+ * @return the next token
+ */
+ private static String getNextToken(StringTokenizer tokenizer) {
+ try {
+ return tokenizer.nextToken();
+ } catch (NoSuchElementException exception) {
+ // awt.66=Invalid format
+ throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Gets the key code.
+ *
+ * @param s the s
+ *
+ * @return the key code
+ */
+ static int getKeyCode(String s) {
+ try {
+ Field vk = KeyEvent.class.getField("VK_" + s); //$NON-NLS-1$
+ return vk.getInt(null);
+ } catch (Exception e) {
+ if (s.length() != 1) {
+ // awt.66=Invalid format
+ throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
+ }
+ return KeyEvent.VK_UNDEFINED;
+ }
+ }
+
+ /**
+ * Gets an instance of the AWTKeyStroke for specified character.
+ *
+ * @param keyChar the keyboard character value.
+ *
+ * @return a AWTKeyStroke for specified character.
+ */
+ public static AWTKeyStroke getAWTKeyStroke(char keyChar) {
+ return getAWTKeyStroke(keyChar, KeyEvent.VK_UNDEFINED, 0, false);
+ }
+
+ /**
+ * Returns an instance of AWTKeyStroke for a given key code, set
+ * of modifiers, and specified key released flag value.
+ * The key codes are defined in java.awt.event.KeyEvent class.
+ * The set of modifiers is given as a bitwise combination
+ * of masks taken from the following list:
+ * <ul>
+ * <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.CTRL_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.META_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.SHIFT_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_GRAPH_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_MASK</li>
+ * <li>java.awt.event.InputEvent.CTRL_MASK</li>
+ * <li>java.awt.event.InputEvent.META_MASK</li>
+ * <li>java.awt.event.InputEvent.SHIFT_MASK</li>
+ * </ul>
+ * <br>
+ *
+ * @param keyCode the specified key code of keyboard.
+ * @param modifiers the bit set of modifiers.
+ *
+ * @return the AWTKeyStroke.
+ */
+ public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers,
+ boolean onKeyRelease) {
+ return getAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode, modifiers,
+ onKeyRelease);
+ }
+
+ /**
+ * Returns AWTKeyStroke for a specified character and set of modifiers.
+ * The set of modifiers is given as a bitwise combination
+ * of masks taken from the following list:
+ * <ul>
+ * <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.CTRL_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.META_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.SHIFT_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_GRAPH_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_MASK</li>
+ * <li>java.awt.event.InputEvent.CTRL_MASK</li>
+ * <li>java.awt.event.InputEvent.META_MASK</li>
+ * <li>java.awt.event.InputEvent.SHIFT_MASK</li>
+ * </ul>
+ *
+ * @param keyChar the Character object which represents keyboard character value.
+ * @param modifiers the bit set of modifiers.
+ *
+ * @return the AWTKeyStroke object.
+ *
+ * @throws IllegalArgumentException if keyChar value is null.
+ */
+ public static AWTKeyStroke getAWTKeyStroke(Character keyChar, int modifiers) {
+ if (keyChar == null) {
+ // awt.01='{0}' parameter is null
+ throw new IllegalArgumentException(Messages.getString("awt.01", "keyChar")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ return getAWTKeyStroke(keyChar.charValue(), KeyEvent.VK_UNDEFINED,
+ modifiers, false);
+ }
+
+ /**
+ * Returns an instance of AWTKeyStroke for a specified key code and
+ * set of modifiers.
+ * The key codes are defined in java.awt.event.KeyEvent class.
+ * The set of modifiers is given as a bitwise combination
+ * of masks taken from the following list:
+ * <ul>
+ * <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.CTRL_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.META_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.SHIFT_DOWN_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_GRAPH_MASK</li>
+ * <li>java.awt.event.InputEvent.ALT_MASK</li>
+ * <li>java.awt.event.InputEvent.CTRL_MASK</li>
+ * <li>java.awt.event.InputEvent.META_MASK</li>
+ * <li>java.awt.event.InputEvent.SHIFT_MASK</li>
+ * </ul>
+ *
+ * @param keyCode the specified key code of keyboard.
+ * @param modifiers the bit set of modifiers.
+ *
+ * @return the AWTKeyStroke
+ */
+ public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers) {
+ return getAWTKeyStroke(keyCode, modifiers, false);
+ }
+
+ /**
+ * Gets the AWTKeyStroke for a key event. This method obtains the key char
+ * and key code from the specified key event.
+ *
+ * @param anEvent the key event which identifies the desired AWTKeyStroke.
+ *
+ * @return the AWTKeyStroke for the key event.
+ */
+ public static AWTKeyStroke getAWTKeyStrokeForEvent(KeyEvent anEvent) {
+ int id = anEvent.getID();
+ char undef = KeyEvent.CHAR_UNDEFINED;
+ char keyChar = (id == KeyEvent.KEY_TYPED ? anEvent.getKeyChar() :
+ undef);
+ int keyCode = (keyChar == undef ? anEvent.getKeyCode() :
+ KeyEvent.VK_UNDEFINED);
+ return getAWTKeyStroke(keyChar, keyCode, anEvent.getModifiersEx(),
+ id == KeyEvent.KEY_RELEASED);
+ }
+
+ /**
+ * Gets the key event type for the AWTKeyStroke object.
+ *
+ * @return the key event type: KeyEvent.KEY_PRESSED, KeyEvent.KEY_TYPED, or KeyEvent.KEY_RELEASED
+ */
+ public final int getKeyEventType() {
+ if (keyCode == KeyEvent.VK_UNDEFINED) {
+ return KeyEvent.KEY_TYPED;
+ }
+ return (onKeyRelease ? KeyEvent.KEY_RELEASED : KeyEvent.KEY_PRESSED);
+ }
+
+ /**
+ * Retuns true if the key event is associated with the AWTKeyStroke is
+ * KEY_RELEASED, overwise false.
+ *
+ * @return true, if if the key event associated with the AWTKeyStroke is
+ * KEY_RELEASED, overwise false.
+ */
+ public final boolean isOnKeyRelease() {
+ return onKeyRelease;
+ }
+
+ /**
+ * Read resolve.
+ *
+ * @return the object
+ *
+ * @throws ObjectStreamException the object stream exception
+ */
+ protected Object readResolve() throws ObjectStreamException {
+ return getAWTKeyStroke(this.keyChar, this.keyCode,
+ this.modifiers, this.onKeyRelease);
+ }
+
+ /**
+ * Register subclass.
+ *
+ * @param subclass the subclass
+ */
+ protected static void registerSubclass(Class<?> subclass) {
+ //???AWT
+ /*
+ if (subclass == null) {
+ // awt.01='{0}' parameter is null
+ throw new IllegalArgumentException(Messages.getString("awt.01", "subclass")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if (! AWTKeyStroke.class.isAssignableFrom(subclass)) {
+ // awt.67=subclass is not derived from AWTKeyStroke
+ throw new ClassCastException(Messages.getString("awt.67")); //$NON-NLS-1$
+ }
+ try {
+ subConstructor = subclass.getDeclaredConstructor();
+ subConstructor.setAccessible(true);
+ } catch (SecurityException e) {
+ throw new RuntimeException(e);
+ } catch (NoSuchMethodException e) {
+ // awt.68=subclass could not be instantiated
+ throw new IllegalArgumentException(Messages.getString("awt.68")); //$NON-NLS-1$
+ }
+ cache.clear(); //flush the cache
+ */
+ }
+
+ /**
+ * Parses the modifier.
+ *
+ * @param strMod the str mod
+ *
+ * @return the long
+ */
+ private static long parseModifier(String strMod) {
+ long modifiers = 0l;
+ if (strMod.equals("shift")) { //$NON-NLS-1$
+ modifiers |= InputEvent.SHIFT_DOWN_MASK;
+ } else if (strMod.equals("control") || strMod.equals("ctrl")) { //$NON-NLS-1$ //$NON-NLS-2$
+ modifiers |= InputEvent.CTRL_DOWN_MASK;
+ } else if (strMod.equals("meta")) { //$NON-NLS-1$
+ modifiers |= InputEvent.META_DOWN_MASK;
+ } else if (strMod.equals("alt")) { //$NON-NLS-1$
+ modifiers |= InputEvent.ALT_DOWN_MASK;
+ } else if (strMod.equals("altGraph")) { //$NON-NLS-1$
+ modifiers |= InputEvent.ALT_GRAPH_DOWN_MASK;
+ } else if (strMod.equals("button1")) { //$NON-NLS-1$
+ modifiers |= InputEvent.BUTTON1_DOWN_MASK;
+ } else if (strMod.equals("button2")) { //$NON-NLS-1$
+ modifiers |= InputEvent.BUTTON2_DOWN_MASK;
+ } else if (strMod.equals("button3")) { //$NON-NLS-1$
+ modifiers |= InputEvent.BUTTON3_DOWN_MASK;
+ }
+ return modifiers;
+ }
+
+ /**
+ * Parses the typed id.
+ *
+ * @param strTyped the str typed
+ *
+ * @return true, if successful
+ */
+ private static boolean parseTypedID(String strTyped) {
+ if (strTyped.equals("typed")) { //$NON-NLS-1$
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Parses the typed key.
+ *
+ * @param strChar the str char
+ *
+ * @return the char
+ */
+ private static char parseTypedKey(String strChar) {
+ char keyChar = KeyEvent.CHAR_UNDEFINED;
+
+ if (strChar.length() != 1) {
+ // awt.66=Invalid format
+ throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
+ }
+ keyChar = strChar.charAt(0);
+ return keyChar;
+ }
+
+ /**
+ * Parses the pressed released id.
+ *
+ * @param str the str
+ *
+ * @return the boolean
+ */
+ private static Boolean parsePressedReleasedID(String str) {
+
+ if (str.equals("pressed")) { //$NON-NLS-1$
+ return Boolean.FALSE;
+ } else if (str.equals("released")) { //$NON-NLS-1$
+ return Boolean.TRUE;
+ }
+ return null;
+ }
+
+ /**
+ * Parses the key.
+ *
+ * @param strCode the str code
+ *
+ * @return the int
+ */
+ private static int parseKey(String strCode) {
+ int keyCode = KeyEvent.VK_UNDEFINED;
+
+ keyCode = getKeyCode(strCode);
+
+ if (keyCode == KeyEvent.VK_UNDEFINED) {
+ // awt.66=Invalid format
+ throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
+ }
+ return keyCode;
+ }
+}
+
diff --git a/awt/java/awt/AWTListenerList.java b/awt/java/awt/AWTListenerList.java
new file mode 100644
index 0000000..3327d63
--- /dev/null
+++ b/awt/java/awt/AWTListenerList.java
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+import java.util.EventListener;
+
+import org.apache.harmony.awt.ListenerList;
+
+final class AWTListenerList<T extends EventListener> extends ListenerList<T> {
+ private static final long serialVersionUID = -2622077171532840953L;
+
+ private final Component owner;
+
+ AWTListenerList() {
+ super();
+ this.owner = null;
+ }
+
+ AWTListenerList(Component owner) {
+ super();
+ this.owner = owner;
+ }
+
+ @Override
+ public void addUserListener(T listener) {
+ super.addUserListener(listener);
+
+ if (owner != null) {
+ owner.deprecatedEventHandler = false;
+ }
+ }
+}
diff --git a/awt/java/awt/AWTPermission.java b/awt/java/awt/AWTPermission.java
new file mode 100644
index 0000000..25326ab
--- /dev/null
+++ b/awt/java/awt/AWTPermission.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.security.BasicPermission;
+
+/**
+ * The AWTPermission specifies the name of the permission and the
+ * corresponding action list.
+ */
+public final class AWTPermission extends BasicPermission {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 8890392402588814465L;
+
+ /**
+ * Instantiates a new AWTPermission with defined name and actions.
+ *
+ * @param name the name of a new AWTPermission.
+ * @param actions the actions of a new AWTPermission.
+ */
+ public AWTPermission(String name, String actions) {
+ super(name, actions);
+ }
+
+ /**
+ * Instantiates a new AWT permission with the defined name.
+ *
+ * @param name the name of a new AWTPermission.
+ */
+ public AWTPermission(String name) {
+ super(name);
+ }
+
+}
+
diff --git a/awt/java/awt/ActiveEvent.java b/awt/java/awt/ActiveEvent.java
new file mode 100644
index 0000000..4133752
--- /dev/null
+++ b/awt/java/awt/ActiveEvent.java
@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ * This interface defines events that know how to dispatch themselves.
+ * Such event can be placed upon the event queue and its dispatch method
+ * will be called when the event is dispatched.
+ */
+public interface ActiveEvent {
+
+ /**
+ * Dispatches the event to the listeners of the event's source,
+ * or does whatever it is this event is supposed to do.
+ */
+ public void dispatch();
+
+}
diff --git a/awt/java/awt/Adjustable.java b/awt/java/awt/Adjustable.java
new file mode 100644
index 0000000..3241cad
--- /dev/null
+++ b/awt/java/awt/Adjustable.java
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.event.AdjustmentListener;
+
+/**
+ * The Adjustable interface represents an adjustable numeric value
+ * contained within a bounded range of values, such as the current
+ * location in scrollable region or the value of a gauge.
+ */
+public interface Adjustable {
+
+ /**
+ * The Constant HORIZONTAL indicates that the Adjustable's orientation
+ * is horizontal.
+ */
+ public static final int HORIZONTAL = 0;
+
+ /**
+ * The Constant VERTICAL indicates that the Adjustable's orientation
+ * is vertical.
+ */
+ public static final int VERTICAL = 1;
+
+ /**
+ * The Constant NO_ORIENTATION indicates that the Adjustable
+ * has no orientation.
+ */
+ public static final int NO_ORIENTATION = 2;
+
+ /**
+ * Gets the value of the Adjustable.
+ *
+ * @return the current value of the Adjustable.
+ */
+ public int getValue();
+
+ /**
+ * Sets the value to the Adjustable object.
+ *
+ * @param a0 the new value of the Adjustable object.
+ */
+ public void setValue(int a0);
+
+ /**
+ * Adds the AdjustmentListener to current Adjustment.
+ *
+ * @param a0 the AdjustmentListener object.
+ */
+ public void addAdjustmentListener(AdjustmentListener a0);
+
+ /**
+ * Gets the block increment of the Adjustable.
+ *
+ * @return the block increment of the Adjustable.
+ */
+ public int getBlockIncrement();
+
+ /**
+ * Gets the maximum value of the Adjustable.
+ *
+ * @return the maximum value of the Adjustable.
+ */
+ public int getMaximum();
+
+ /**
+ * Gets the minimum value of the Adjustable.
+ *
+ * @return the minimum value of the Adjustable.
+ */
+ public int getMinimum();
+
+ /**
+ * Gets the orientation of the Adjustable.
+ *
+ * @return the orientation of the Adjustable.
+ */
+ public int getOrientation();
+
+ /**
+ * Gets the unit increment of the Adjustable.
+ *
+ * @return the unit increment of the Adjustable.
+ */
+ public int getUnitIncrement();
+
+ /**
+ * Gets the visible amount of the Adjustable.
+ *
+ * @return the visible amount of the Adjustable.
+ */
+ public int getVisibleAmount();
+
+ /**
+ * Removes the adjustment listener of the Adjustable.
+ *
+ * @param a0 the specified AdjustmentListener to be removed.
+ */
+ public void removeAdjustmentListener(AdjustmentListener a0);
+
+ /**
+ * Sets the block increment for the Adjustable.
+ *
+ * @param a0 the new block increment.
+ */
+ public void setBlockIncrement(int a0);
+
+ /**
+ * Sets the maximum value of the Adjustable.
+ *
+ * @param a0 the new maximum of the Adjustable.
+ */
+ public void setMaximum(int a0);
+
+ /**
+ * Sets the minimum value of the Adjustable.
+ *
+ * @param a0 the new minimum of the Adjustable.
+ */
+ public void setMinimum(int a0);
+
+ /**
+ * Sets the unit increment of the Adjustable.
+ *
+ * @param a0 the new unit increment of the Adjustable.
+ */
+ public void setUnitIncrement(int a0);
+
+ /**
+ * Sets the visible amount of the Adjustable.
+ *
+ * @param a0 the new visible amount of the Adjustable.
+ */
+ public void setVisibleAmount(int a0);
+
+}
+
diff --git a/awt/java/awt/AlphaComposite.java b/awt/java/awt/AlphaComposite.java
new file mode 100644
index 0000000..d26753c
--- /dev/null
+++ b/awt/java/awt/AlphaComposite.java
@@ -0,0 +1,315 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.Composite;
+import java.awt.CompositeContext;
+import java.awt.RenderingHints;
+import java.awt.image.ColorModel;
+
+import org.apache.harmony.awt.gl.ICompositeContext;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+
+/**
+ * The AlphaComposite class defines a basic alpha compositing rules for
+ * combining source and destination colors to achieve blending and
+ * transparency effects with graphics and images.
+ */
+public final class AlphaComposite implements Composite {
+
+ /**
+ * The Constant CLEAR indicates that both the color and the alpha of
+ * the destination are cleared (Porter-Duff Clear rule).
+ */
+ public static final int CLEAR = 1;
+
+ /**
+ * The Constant SRC indicates that the source is copied to the destination
+ * (Porter-Duff Source rule).
+ */
+ public static final int SRC = 2;
+
+ /** The Constant DST indicates that the destination is left untouched
+ * (Porter-Duff Destination rule).
+ */
+ public static final int DST = 9;
+
+ /**
+ * The Constant SRC_OVER indicates that the source is composited over
+ * the destination (Porter-Duff Source Over Destination rule).
+ */
+ public static final int SRC_OVER = 3;
+
+ /**
+ * The Constant DST_OVER indicates that The destination is composited over
+ * the source and the result replaces the destination
+ * (Porter-Duff Destination Over Source rule).
+ */
+ public static final int DST_OVER = 4;
+
+ /**
+ * The Constant SRC_IN indicates that the part of the source lying
+ * inside of the destination replaces the destination (Porter-Duff
+ * Source In Destination rule).
+ */
+ public static final int SRC_IN = 5;
+
+ /**
+ * The Constant DST_IN indicates that the part of the destination
+ * lying inside of the source replaces the destination
+ * (Porter-Duff Destination In Source rule).
+ */
+ public static final int DST_IN = 6;
+
+ /**
+ * The Constant SRC_OUT indicates that the part of the source lying
+ * outside of the destination replaces the destination (Porter-Duff
+ * Source Held Out By Destination rule).
+ */
+ public static final int SRC_OUT = 7;
+
+ /**
+ * The Constant DST_OUT indicates that the part of the destination
+ * lying outside of the source replaces the destination (Porter-Duff
+ * Destination Held Out By Source rule).
+ */
+ public static final int DST_OUT = 8;
+
+ /**
+ * The Constant SRC_ATOP indicates that the part of the source lying
+ * inside of the destination is composited onto the destination
+ * (Porter-Duff Source Atop Destination rule).
+ */
+ public static final int SRC_ATOP = 10;
+
+ /**
+ * The Constant DST_ATOP indicates that the part of the destination
+ * lying inside of the source is composited over the source and replaces
+ * the destination (Porter-Duff Destination Atop Source rule).
+ */
+ public static final int DST_ATOP = 11;
+
+ /**
+ * The Constant XOR indicates that the part of the source that lies
+ * outside of the destination is combined with the part of the destination
+ * that lies outside of the source (Porter-Duff Source Xor Destination rule).
+ */
+ public static final int XOR = 12;
+
+ /** AlphaComposite object with the opaque CLEAR rule and an alpha of 1.0f. */
+ public static final AlphaComposite Clear = new AlphaComposite(CLEAR);
+
+ /** AlphaComposite object with the opaque SRC rule and an alpha of 1.0f. */
+ public static final AlphaComposite Src = new AlphaComposite(SRC);
+
+ /** AlphaComposite object with the opaque DST rule and an alpha of 1.0f. */
+ public static final AlphaComposite Dst = new AlphaComposite(DST);
+
+ /** AlphaComposite object with the opaque SRC_OVER rule and an alpha of 1.0f. */
+ public static final AlphaComposite SrcOver = new AlphaComposite(SRC_OVER);
+
+ /** AlphaComposite object with the opaque DST_OVER rule and an alpha of 1.0f. */
+ public static final AlphaComposite DstOver = new AlphaComposite(DST_OVER);
+
+ /** AlphaComposite object with the opaque SRC_IN rule and an alpha of 1.0f. */
+ public static final AlphaComposite SrcIn = new AlphaComposite(SRC_IN);
+
+ /** AlphaComposite object with the opaque DST_IN rule and an alpha of 1.0f. */
+ public static final AlphaComposite DstIn = new AlphaComposite(DST_IN);
+
+ /** AlphaComposite object with the opaque SRC_OUT rule and an alpha of 1.0f. */
+ public static final AlphaComposite SrcOut = new AlphaComposite(SRC_OUT);
+
+ /** AlphaComposite object with the opaque DST_OUT rule and an alpha of 1.0f. */
+ public static final AlphaComposite DstOut = new AlphaComposite(DST_OUT);
+
+ /** AlphaComposite object with the opaque SRC_ATOP rule and an alpha of 1.0f. */
+ public static final AlphaComposite SrcAtop = new AlphaComposite(SRC_ATOP);
+
+ /** AlphaComposite object with the opaque DST_ATOP rule and an alpha of 1.0f. */
+ public static final AlphaComposite DstAtop = new AlphaComposite(DST_ATOP);
+
+ /** AlphaComposite object with the opaque XOR rule and an alpha of 1.0f. */
+ public static final AlphaComposite Xor = new AlphaComposite(XOR);
+
+ /** The rule. */
+ private int rule;
+
+ /** The alpha. */
+ private float alpha;
+
+ /**
+ * Instantiates a new alpha composite.
+ * Creates a context for the compositing operation. The context contains state that is used in performing the compositing operation.
+ *
+ * @param rule the rule
+ * @param alpha the alpha
+ */
+ private AlphaComposite(int rule, float alpha){
+ if(rule < CLEAR || rule > XOR) {
+ // awt.11D=Unknown rule
+ throw new IllegalArgumentException(Messages.getString("awt.11D")); //$NON-NLS-1$
+ }
+ if(alpha < 0.0f || alpha > 1.0f) {
+ // awt.11E=Wrong alpha value
+ throw new IllegalArgumentException(Messages.getString("awt.11E")); //$NON-NLS-1$
+ }
+
+ this.rule = rule;
+ this.alpha = alpha;
+ }
+
+ /**
+ * Instantiates a new alpha composite.
+ *
+ * @param rule the rule
+ */
+ private AlphaComposite(int rule){
+ this(rule, 1.0f);
+ }
+
+ /**
+ * Creates a CompositeContext object with the specified source ColorModel,
+ * destination ColorModel and RenderingHints parameters for a composing
+ * operation.
+ *
+ * @param srcColorModel the source's ColorModel.
+ * @param dstColorModel the destination's ColorModel.
+ * @param hints the RenderingHints object.
+ *
+ * @return the CompositeContext object.
+ *
+ * @see java.awt.Composite#createContext(java.awt.image.ColorModel, java.awt.image.ColorModel, java.awt.RenderingHints)
+ */
+ public CompositeContext createContext(ColorModel srcColorModel,
+ ColorModel dstColorModel, RenderingHints hints) {
+ return new ICompositeContext(this, srcColorModel, dstColorModel);
+ }
+
+ /**
+ * Compares the AlphaComposite object with the specified object.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if the AlphaComposite object is equal to the specified
+ * object.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if(!(obj instanceof AlphaComposite)) {
+ return false;
+ }
+ AlphaComposite other = (AlphaComposite)obj;
+ return (this.rule == other.getRule() && this.alpha == other.getAlpha());
+ }
+
+ /**
+ * Returns the hash code of the AlphaComposite object.
+ *
+ * @return the hash code of the AlphaComposite object.
+ */
+ @Override
+ public int hashCode() {
+ int hash = Float.floatToIntBits(alpha);
+ int tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= rule;
+ return hash;
+ }
+
+ /**
+ * Gets the compositing rule of this AlphaComposite object.
+ *
+ * @return the compositing rule of this AlphaComposite object.
+ */
+ public int getRule() {
+ return rule;
+ }
+
+ /**
+ * Gets the alpha value of this AlphaComposite object; returns 1.0 if
+ * this AlphaComposite object doesn't have alpha value.
+ *
+ * @return the alpha value of this AlphaComposite object or 1.0 if
+ * this AlphaComposite object doesn't have alpha value.
+ */
+ public float getAlpha() {
+ return alpha;
+ }
+
+ /**
+ * Gets the AlphaComposite instance with the specified rule and alpha value.
+ *
+ * @param rule the compositing rule.
+ * @param alpha the alpha value.
+ *
+ * @return AlphaComposite instance.
+ */
+ public static AlphaComposite getInstance(int rule, float alpha) {
+ if(alpha == 1.0f) {
+ return getInstance(rule);
+ }
+ return new AlphaComposite(rule, alpha);
+ }
+
+ /**
+ * Gets the AlphaComposite instance with the specified rule.
+ *
+ * @param rule the compositing rule.
+ *
+ * @return AlphaComposite instance.
+ */
+ public static AlphaComposite getInstance(int rule) {
+ switch(rule){
+ case CLEAR:
+ return Clear;
+ case SRC:
+ return Src;
+ case DST:
+ return Dst;
+ case SRC_OVER:
+ return SrcOver;
+ case DST_OVER:
+ return DstOver;
+ case SRC_IN:
+ return SrcIn;
+ case DST_IN:
+ return DstIn;
+ case SRC_OUT:
+ return SrcOut;
+ case DST_OUT:
+ return DstOut;
+ case SRC_ATOP:
+ return SrcAtop;
+ case DST_ATOP:
+ return DstAtop;
+ case XOR:
+ return Xor;
+ default:
+ // awt.11D=Unknown rule
+ throw new IllegalArgumentException(Messages.getString("awt.11D")); //$NON-NLS-1$
+ }
+ }
+
+}
+
diff --git a/awt/java/awt/BasicStroke.java b/awt/java/awt/BasicStroke.java
new file mode 100644
index 0000000..955dc6b
--- /dev/null
+++ b/awt/java/awt/BasicStroke.java
@@ -0,0 +1,2204 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.geom.GeneralPath;
+import java.awt.geom.PathIterator;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+import org.apache.harmony.misc.HashCode;
+
+/**
+ * The BasicStroke class specifies a set of rendering attributes for the outlines
+ * of graphics primitives. The BasicStroke attributes describe the shape of the
+ * pen which draws the outline of a Shape and the decorations applied at the ends
+ * and joins of path segments of the Shape. The BasicStroke has the following
+ * rendering attributes:
+ * <p>
+ * <ul>
+ * <li> line width -the pen width which draws the outlines.</li>
+ * <li> end caps - indicates the decoration applied to the ends of unclosed
+ * subpaths and dash segments. The BasicStroke defines three different decorations:
+ * CAP_BUTT, CAP_ROUND, and CAP_SQUARE.</li>
+ * <li>line joins - indicates the decoration applied at the intersection of
+ * two path segments and at the intersection of the endpoints of a subpath.
+ * The BasicStroke defines three decorations: JOIN_BEVEL, JOIN_MITER,
+ * and JOIN_ROUND.</li>
+ * <li>miter limit - the limit to trim a line join that has a JOIN_MITER
+ * decoration.</li>
+ * <li>dash attributes - the definition of how to make a dash pattern by
+ * alternating between opaque and transparent sections </li>
+ * </ul>
+ */
+public class BasicStroke implements Stroke {
+
+ /**
+ * The Constant CAP_BUTT indicates the ends of unclosed subpaths
+ * and dash segments have no added decoration.
+ */
+ public static final int CAP_BUTT = 0;
+
+ /**
+ * The Constant CAP_ROUND indicates the ends of unclosed subpaths
+ * and dash segments have a round decoration.
+ */
+ public static final int CAP_ROUND = 1;
+
+ /**
+ * The Constant CAP_SQUARE indicates the ends of unclosed subpaths
+ * and dash segments have a square projection.
+ */
+ public static final int CAP_SQUARE = 2;
+
+ /**
+ * The Constant JOIN_MITER indicates that path segments are joined by
+ * extending their outside edges until they meet.
+ */
+ public static final int JOIN_MITER = 0;
+
+ /**
+ * The Constant JOIN_ROUND indicates that path segments are joined by
+ * rounding off the corner at a radius of half the line width.
+ */
+ public static final int JOIN_ROUND = 1;
+
+ /**
+ * The Constant JOIN_BEVEL indicates that path segments are joined by
+ * connecting the outer corners of their wide outlines with
+ * a straight segment.
+ */
+ public static final int JOIN_BEVEL = 2;
+
+ /** Constants for calculating. */
+ static final int MAX_LEVEL = 20; // Maximal deepness of curve subdivision
+
+ /** The Constant CURVE_DELTA. */
+ static final double CURVE_DELTA = 2.0; // Width tolerance
+
+ /** The Constant CORNER_ANGLE. */
+ static final double CORNER_ANGLE = 4.0; // Minimum corner angle
+
+ /** The Constant CORNER_ZERO. */
+ static final double CORNER_ZERO = 0.01; // Zero angle
+
+ /** The Constant CUBIC_ARC. */
+ static final double CUBIC_ARC = 4.0 / 3.0 * (Math.sqrt(2.0) - 1);
+
+ /** Stroke width. */
+ float width;
+
+ /** Stroke cap type. */
+ int cap;
+
+ /** Stroke join type. */
+ int join;
+
+ /** Stroke miter limit. */
+ float miterLimit;
+
+ /** Stroke dashes array. */
+ float dash[];
+
+ /** Stroke dash phase. */
+ float dashPhase;
+
+ /** The temporary pre-calculated values. */
+ double curveDelta;
+
+ /** The corner delta. */
+ double cornerDelta;
+
+ /** The zero delta. */
+ double zeroDelta;
+
+ /** The w2. */
+ double w2;
+
+ /** The fmy. */
+ double fmx, fmy;
+
+ /** The smy. */
+ double scx, scy, smx, smy;
+
+ /** The cy. */
+ double mx, my, cx, cy;
+
+ /** The temporary indicators. */
+ boolean isMove;
+
+ /** The is first. */
+ boolean isFirst;
+
+ /** The check move. */
+ boolean checkMove;
+
+ /** The temporary and destination work paths. */
+ BufferedPath dst, lp, rp, sp;
+
+ /** Stroke dasher class. */
+ Dasher dasher;
+
+ /**
+ * Instantiates a new BasicStroke with default width, cap, join, limit,
+ * dash attributes parameters. The default parameters are a solid line of
+ * width 1.0, CAP_SQUARE, JOIN_MITER, a miter limit of 10.0, null dash attributes,
+ * and a dash phase of 0.0f.
+ */
+ public BasicStroke() {
+ this(1.0f, CAP_SQUARE, JOIN_MITER, 10.0f, null, 0.0f);
+ }
+
+ /**
+ * Instantiates a new BasicStroke with the specified width,
+ * caps, joins, limit, dash attributes, dash phase parameters.
+ *
+ * @param width the width of BasikStroke.
+ * @param cap the end decoration of BasikStroke.
+ * @param join the join segments decoration.
+ * @param miterLimit the limit to trim the miter join.
+ * @param dash the array with the dashing pattern.
+ * @param dashPhase the offset to start the dashing pattern.
+ */
+ public BasicStroke(float width, int cap, int join, float miterLimit, float[] dash, float dashPhase) {
+ if (width < 0.0f) {
+ // awt.133=Negative width
+ throw new IllegalArgumentException(Messages.getString("awt.133")); //$NON-NLS-1$
+ }
+ if (cap != CAP_BUTT && cap != CAP_ROUND && cap != CAP_SQUARE) {
+ // awt.134=Illegal cap
+ throw new IllegalArgumentException(Messages.getString("awt.134")); //$NON-NLS-1$
+ }
+ if (join != JOIN_MITER && join != JOIN_ROUND && join != JOIN_BEVEL) {
+ // awt.135=Illegal join
+ throw new IllegalArgumentException(Messages.getString("awt.135")); //$NON-NLS-1$
+ }
+ if (join == JOIN_MITER && miterLimit < 1.0f) {
+ // awt.136=miterLimit less than 1.0f
+ throw new IllegalArgumentException(Messages.getString("awt.136")); //$NON-NLS-1$
+ }
+ if (dash != null) {
+ if (dashPhase < 0.0f) {
+ // awt.137=Negative dashPhase
+ throw new IllegalArgumentException(Messages.getString("awt.137")); //$NON-NLS-1$
+ }
+ if (dash.length == 0) {
+ // awt.138=Zero dash length
+ throw new IllegalArgumentException(Messages.getString("awt.138")); //$NON-NLS-1$
+ }
+ ZERO: {
+ for(int i = 0; i < dash.length; i++) {
+ if (dash[i] < 0.0) {
+ // awt.139=Negative dash[{0}]
+ throw new IllegalArgumentException(Messages.getString("awt.139", i)); //$NON-NLS-1$
+ }
+ if (dash[i] > 0.0) {
+ break ZERO;
+ }
+ }
+ // awt.13A=All dash lengths zero
+ throw new IllegalArgumentException(Messages.getString("awt.13A")); //$NON-NLS-1$
+ }
+ }
+ this.width = width;
+ this.cap = cap;
+ this.join = join;
+ this.miterLimit = miterLimit;
+ this.dash = dash;
+ this.dashPhase = dashPhase;
+ }
+
+ /**
+ * Instantiates a new BasicStroke with specified width, cap, join, limit
+ * and default dash attributes parameters.
+ *
+ * @param width the width of BasikStroke.
+ * @param cap the end decoration of BasikStroke.
+ * @param join the join segments decoration.
+ * @param miterLimit the limit to trim the miter join.
+ */
+ public BasicStroke(float width, int cap, int join, float miterLimit) {
+ this(width, cap, join, miterLimit, null, 0.0f);
+ }
+
+ /**
+ * Instantiates a new BasicStroke with specified width, cap, join
+ * and default limit and dash attributes parameters.
+ *
+ * @param width the width of BasikStroke.
+ * @param cap the end decoration of BasikStroke.
+ * @param join the join segments decoration.
+ */
+ public BasicStroke(float width, int cap, int join) {
+ this(width, cap, join, 10.0f, null, 0.0f);
+ }
+
+ /**
+ * Instantiates a new BasicStroke with specified width and default cap, join,
+ * limit, dash attributes parameters.
+ *
+ * @param width the width of BasicStroke.
+ */
+ public BasicStroke(float width) {
+ this(width, CAP_SQUARE, JOIN_MITER, 10.0f, null, 0.0f);
+ }
+
+ /**
+ * Gets the line width of the BasicStroke.
+ *
+ * @return the line width of the BasicStroke.
+ */
+ public float getLineWidth() {
+ return width;
+ }
+
+ /**
+ * Gets the end cap style of the BasicStroke.
+ *
+ * @return the end cap style of the BasicStroke.
+ */
+ public int getEndCap() {
+ return cap;
+ }
+
+ /**
+ * Gets the line join style of the BasicStroke.
+ *
+ * @return the line join style of the BasicStroke.
+ */
+ public int getLineJoin() {
+ return join;
+ }
+
+ /**
+ * Gets the miter limit of the BasicStroke (the limit to trim the miter join).
+ *
+ * @return the miter limit of the BasicStroke.
+ */
+ public float getMiterLimit() {
+ return miterLimit;
+ }
+
+ /**
+ * Gets the dash attributes array of the BasicStroke.
+ *
+ * @return the dash attributes array of the BasicStroke.
+ */
+ public float[] getDashArray() {
+ return dash;
+ }
+
+ /**
+ * Gets the dash phase of the BasicStroke.
+ *
+ * @return the dash phase of the BasicStroke.
+ */
+ public float getDashPhase() {
+ return dashPhase;
+ }
+
+ /**
+ * Returns hash code of this BasicStroke.
+ *
+ * @return the hash code of this BasicStroke.
+ */
+ @Override
+ public int hashCode() {
+ HashCode hash = new HashCode();
+ hash.append(width);
+ hash.append(cap);
+ hash.append(join);
+ hash.append(miterLimit);
+ if (dash != null) {
+ hash.append(dashPhase);
+ for (float element : dash) {
+ hash.append(element);
+ }
+ }
+ return hash.hashCode();
+ }
+
+ /**
+ * Compares this BasicStroke object with the specified Object.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if the Object is a BasicStroke with the same data
+ * values as this BasicStroke; false otherwise.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (obj instanceof BasicStroke) {
+ BasicStroke bs = (BasicStroke)obj;
+ return
+ bs.width == width &&
+ bs.cap == cap &&
+ bs.join == join &&
+ bs.miterLimit == miterLimit &&
+ bs.dashPhase == dashPhase &&
+ java.util.Arrays.equals(bs.dash, dash);
+ }
+ return false;
+ }
+
+ /**
+ * Calculates allowable curve derivation.
+ *
+ * @param width the width
+ *
+ * @return the curve delta
+ */
+ double getCurveDelta(double width) {
+ double a = width + CURVE_DELTA;
+ double cos = 1.0 - 2.0 * width * width / (a * a);
+ double sin = Math.sqrt(1.0 - cos * cos);
+ return Math.abs(sin / cos);
+ }
+
+ /**
+ * Calculates the value to detect a small angle.
+ *
+ * @param width the width
+ *
+ * @return the corner delta
+ */
+ double getCornerDelta(double width) {
+ return width * width * Math.sin(Math.PI * CORNER_ANGLE / 180.0);
+ }
+
+ /**
+ * Calculates value to detect a zero angle.
+ *
+ * @param width the width
+ *
+ * @return the zero delta
+ */
+ double getZeroDelta(double width) {
+ return width * width * Math.sin(Math.PI * CORNER_ZERO / 180.0);
+ }
+
+ /**
+ * Creates a Shape from the outline of the specified shape
+ * drawn with this BasicStroke.
+ *
+ * @param s the specified Shape to be stroked.
+ *
+ * @return the Shape of the stroked outline.
+ *
+ * @see java.awt.Stroke#createStrokedShape(java.awt.Shape)
+ */
+ public Shape createStrokedShape(Shape s) {
+ w2 = width / 2.0;
+ curveDelta = getCurveDelta(w2);
+ cornerDelta = getCornerDelta(w2);
+ zeroDelta = getZeroDelta(w2);
+
+ dst = new BufferedPath();
+ lp = new BufferedPath();
+ rp = new BufferedPath();
+
+ if (dash == null) {
+ createSolidShape(s.getPathIterator(null));
+ } else {
+ createDashedShape(s.getPathIterator(null));
+ }
+
+ return dst.createGeneralPath();
+ }
+
+ /**
+ * Generates a shape with a solid (not dashed) outline.
+ *
+ * @param p - the PathIterator of source shape
+ */
+ void createSolidShape(PathIterator p) {
+ double coords[] = new double[6];
+ mx = my = cx = cy = 0.0;
+ isMove = false;
+ isFirst = false;
+ checkMove = true;
+ boolean isClosed = true;
+
+ while(!p.isDone()) {
+ switch(p.currentSegment(coords)) {
+ case PathIterator.SEG_MOVETO:
+ if (!isClosed) {
+ closeSolidShape();
+ }
+ rp.clean();
+ mx = cx = coords[0];
+ my = cy = coords[1];
+ isMove = true;
+ isClosed = false;
+ break;
+ case PathIterator.SEG_LINETO:
+ addLine(cx, cy, cx = coords[0], cy = coords[1], true);
+ break;
+ case PathIterator.SEG_QUADTO:
+ addQuad(cx, cy, coords[0], coords[1], cx = coords[2], cy = coords[3]);
+ break;
+ case PathIterator.SEG_CUBICTO:
+ addCubic(cx, cy, coords[0], coords[1], coords[2], coords[3], cx = coords[4], cy = coords[5]);
+ break;
+ case PathIterator.SEG_CLOSE:
+ addLine(cx, cy, mx, my, false);
+ addJoin(lp, mx, my, lp.xMove, lp.yMove, true);
+ addJoin(rp, mx, my, rp.xMove, rp.yMove, false);
+ lp.closePath();
+ rp.closePath();
+ lp.appendReverse(rp);
+ isClosed = true;
+ break;
+ }
+ p.next();
+ }
+ if (!isClosed) {
+ closeSolidShape();
+ }
+
+ dst = lp;
+ }
+
+ /**
+ * Closes solid shape path.
+ */
+ void closeSolidShape() {
+ addCap(lp, cx, cy, rp.xLast, rp.yLast);
+ lp.combine(rp);
+ addCap(lp, mx, my, lp.xMove, lp.yMove);
+ lp.closePath();
+ }
+
+ /**
+ * Generates dashed stroked shape.
+ *
+ * @param p - the PathIterator of source shape
+ */
+ void createDashedShape(PathIterator p) {
+ double coords[] = new double[6];
+ mx = my = cx = cy = 0.0;
+ smx = smy = scx = scy = 0.0;
+ isMove = false;
+ checkMove = false;
+ boolean isClosed = true;
+
+ while(!p.isDone()) {
+ switch(p.currentSegment(coords)) {
+ case PathIterator.SEG_MOVETO:
+
+ if (!isClosed) {
+ closeDashedShape();
+ }
+
+ dasher = new Dasher(dash, dashPhase);
+ lp.clean();
+ rp.clean();
+ sp = null;
+ isFirst = true;
+ isMove = true;
+ isClosed = false;
+ mx = cx = coords[0];
+ my = cy = coords[1];
+ break;
+ case PathIterator.SEG_LINETO:
+ addDashLine(cx, cy, cx = coords[0], cy = coords[1]);
+ break;
+ case PathIterator.SEG_QUADTO:
+ addDashQuad(cx, cy, coords[0], coords[1], cx = coords[2], cy = coords[3]);
+ break;
+ case PathIterator.SEG_CUBICTO:
+ addDashCubic(cx, cy, coords[0], coords[1], coords[2], coords[3], cx = coords[4], cy = coords[5]);
+ break;
+ case PathIterator.SEG_CLOSE:
+ addDashLine(cx, cy, cx = mx, cy = my);
+
+ if (dasher.isConnected()) {
+ // Connect current and head segments
+ addJoin(lp, fmx, fmy, sp.xMove, sp.yMove, true);
+ lp.join(sp);
+ addJoin(lp, fmx, fmy, rp.xLast, rp.yLast, true);
+ lp.combine(rp);
+ addCap(lp, smx, smy, lp.xMove, lp.yMove);
+ lp.closePath();
+ dst.append(lp);
+ sp = null;
+ } else {
+ closeDashedShape();
+ }
+
+ isClosed = true;
+ break;
+ }
+ p.next();
+ }
+
+ if (!isClosed) {
+ closeDashedShape();
+ }
+
+ }
+
+ /**
+ * Closes dashed shape path.
+ */
+ void closeDashedShape() {
+ // Add head segment
+ if (sp != null) {
+ addCap(sp, fmx, fmy, sp.xMove, sp.yMove);
+ sp.closePath();
+ dst.append(sp);
+ }
+ if (lp.typeSize > 0) {
+ // Close current segment
+ if (!dasher.isClosed()) {
+ addCap(lp, scx, scy, rp.xLast, rp.yLast);
+ lp.combine(rp);
+ addCap(lp, smx, smy, lp.xMove, lp.yMove);
+ lp.closePath();
+ }
+ dst.append(lp);
+ }
+ }
+
+ /**
+ * Adds cap to the work path.
+ *
+ * @param p - the BufferedPath object of work path
+ * @param x0 - the x coordinate of the source path
+ * @param y0 - the y coordinate on the source path
+ * @param x2 - the x coordinate of the next point on the work path
+ * @param y2 - the y coordinate of the next point on the work path
+ */
+ void addCap(BufferedPath p, double x0, double y0, double x2, double y2) {
+ double x1 = p.xLast;
+ double y1 = p.yLast;
+ double x10 = x1 - x0;
+ double y10 = y1 - y0;
+ double x20 = x2 - x0;
+ double y20 = y2 - y0;
+
+ switch(cap) {
+ case CAP_BUTT:
+ p.lineTo(x2, y2);
+ break;
+ case CAP_ROUND:
+ double mx = x10 * CUBIC_ARC;
+ double my = y10 * CUBIC_ARC;
+
+ double x3 = x0 + y10;
+ double y3 = y0 - x10;
+
+ x10 *= CUBIC_ARC;
+ y10 *= CUBIC_ARC;
+ x20 *= CUBIC_ARC;
+ y20 *= CUBIC_ARC;
+
+ p.cubicTo(x1 + y10, y1 - x10, x3 + mx, y3 + my, x3, y3);
+ p.cubicTo(x3 - mx, y3 - my, x2 - y20, y2 + x20, x2, y2);
+ break;
+ case CAP_SQUARE:
+ p.lineTo(x1 + y10, y1 - x10);
+ p.lineTo(x2 - y20, y2 + x20);
+ p.lineTo(x2, y2);
+ break;
+ }
+ }
+
+ /**
+ * Adds bevel and miter join to the work path.
+ *
+ * @param p - the BufferedPath object of work path
+ * @param x0 - the x coordinate of the source path
+ * @param y0 - the y coordinate on the source path
+ * @param x2 - the x coordinate of the next point on the work path
+ * @param y2 - the y coordinate of the next point on the work path
+ * @param isLeft - the orientation of work path, true if work path lies to the left from source path, false otherwise
+ */
+ void addJoin(BufferedPath p, double x0, double y0, double x2, double y2, boolean isLeft) {
+ double x1 = p.xLast;
+ double y1 = p.yLast;
+ double x10 = x1 - x0;
+ double y10 = y1 - y0;
+ double x20 = x2 - x0;
+ double y20 = y2 - y0;
+ double sin0 = x10 * y20 - y10 * x20;
+
+ // Small corner
+ if (-cornerDelta < sin0 && sin0 < cornerDelta) {
+ double cos0 = x10 * x20 + y10 * y20;
+ if (cos0 > 0.0) {
+ // if zero corner do nothing
+ if (-zeroDelta > sin0 || sin0 > zeroDelta) {
+ double x3 = x0 + w2 * w2 * (y20 - y10) / sin0;
+ double y3 = y0 + w2 * w2 * (x10 - x20) / sin0;
+ p.setLast(x3, y3);
+ }
+ return;
+ }
+ // Zero corner
+ if (-zeroDelta < sin0 && sin0 < zeroDelta) {
+ p.lineTo(x2, y2);
+ }
+ return;
+ }
+
+ if (isLeft ^ (sin0 < 0.0)) {
+ // Twisted corner
+ p.lineTo(x0, y0);
+ p.lineTo(x2, y2);
+ } else {
+ switch(join) {
+ case JOIN_BEVEL:
+ p.lineTo(x2, y2);
+ break;
+ case JOIN_MITER:
+ double s1 = x1 * x10 + y1 * y10;
+ double s2 = x2 * x20 + y2 * y20;
+ double x3 = (s1 * y20 - s2 * y10) / sin0;
+ double y3 = (s2 * x10 - s1 * x20) / sin0;
+ double x30 = x3 - x0;
+ double y30 = y3 - y0;
+ double miterLength = Math.sqrt(x30 * x30 + y30 * y30);
+ if (miterLength < miterLimit * w2) {
+ p.lineTo(x3, y3);
+ }
+ p.lineTo(x2, y2);
+ break;
+ case JOIN_ROUND:
+ addRoundJoin(p, x0, y0, x2, y2, isLeft);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Adds round join to the work path.
+ *
+ * @param p - the BufferedPath object of work path
+ * @param x0 - the x coordinate of the source path
+ * @param y0 - the y coordinate on the source path
+ * @param x2 - the x coordinate of the next point on the work path
+ * @param y2 - the y coordinate of the next point on the work path
+ * @param isLeft - the orientation of work path, true if work path lies to the left from source path, false otherwise
+ */
+ void addRoundJoin(BufferedPath p, double x0, double y0, double x2, double y2, boolean isLeft) {
+ double x1 = p.xLast;
+ double y1 = p.yLast;
+ double x10 = x1 - x0;
+ double y10 = y1 - y0;
+ double x20 = x2 - x0;
+ double y20 = y2 - y0;
+
+ double x30 = x10 + x20;
+ double y30 = y10 + y20;
+
+ double l30 = Math.sqrt(x30 * x30 + y30 * y30);
+
+ if (l30 < 1E-5) {
+ p.lineTo(x2, y2);
+ return;
+ }
+
+ double w = w2 / l30;
+
+ x30 *= w;
+ y30 *= w;
+
+ double x3 = x0 + x30;
+ double y3 = y0 + y30;
+
+ double cos = x10 * x20 + y10 * y20;
+ double a = Math.acos(cos / (w2 * w2));
+ if (cos >= 0.0) {
+ double k = 4.0 / 3.0 * Math.tan(a / 4.0);
+ if (isLeft) {
+ k = -k;
+ }
+
+ x10 *= k;
+ y10 *= k;
+ x20 *= k;
+ y20 *= k;
+
+ p.cubicTo(x1 - y10, y1 + x10, x2 + y20, y2 - x20, x2, y2);
+ } else {
+ double k = 4.0 / 3.0 * Math.tan(a / 8.0);
+ if (isLeft) {
+ k = -k;
+ }
+
+ x10 *= k;
+ y10 *= k;
+ x20 *= k;
+ y20 *= k;
+ x30 *= k;
+ y30 *= k;
+
+ p.cubicTo(x1 - y10, y1 + x10, x3 + y30, y3 - x30, x3, y3);
+ p.cubicTo(x3 - y30, y3 + x30, x2 + y20, y2 - x20, x2, y2);
+ }
+
+ }
+
+ /**
+ * Adds solid line segment to the work path.
+ *
+ * @param x1 - the x coordinate of the start line point
+ * @param y1 - the y coordinate of the start line point
+ * @param x2 - the x coordinate of the end line point
+ * @param y2 - the y coordinate of the end line point
+ * @param zero - if true it's allowable to add zero length line segment
+ */
+ void addLine(double x1, double y1, double x2, double y2, boolean zero) {
+ double dx = x2 - x1;
+ double dy = y2 - y1;
+
+ if (dx == 0.0 && dy == 0.0) {
+ if (!zero) {
+ return;
+ }
+ dx = w2;
+ dy = 0;
+ } else {
+ double w = w2 / Math.sqrt(dx * dx + dy * dy);
+ dx *= w;
+ dy *= w;
+ }
+
+ double lx1 = x1 - dy;
+ double ly1 = y1 + dx;
+ double rx1 = x1 + dy;
+ double ry1 = y1 - dx;
+
+ if (checkMove) {
+ if (isMove) {
+ isMove = false;
+ lp.moveTo(lx1, ly1);
+ rp.moveTo(rx1, ry1);
+ } else {
+ addJoin(lp, x1, y1, lx1, ly1, true);
+ addJoin(rp, x1, y1, rx1, ry1, false);
+ }
+ }
+
+ lp.lineTo(x2 - dy, y2 + dx);
+ rp.lineTo(x2 + dy, y2 - dx);
+ }
+
+ /**
+ * Adds solid quad segment to the work path.
+ *
+ * @param x1 - the x coordinate of the first control point
+ * @param y1 - the y coordinate of the first control point
+ * @param x2 - the x coordinate of the second control point
+ * @param y2 - the y coordinate of the second control point
+ * @param x3 - the x coordinate of the third control point
+ * @param y3 - the y coordinate of the third control point
+ */
+ void addQuad(double x1, double y1, double x2, double y2, double x3, double y3) {
+ double x21 = x2 - x1;
+ double y21 = y2 - y1;
+ double x23 = x2 - x3;
+ double y23 = y2 - y3;
+
+ double l21 = Math.sqrt(x21 * x21 + y21 * y21);
+ double l23 = Math.sqrt(x23 * x23 + y23 * y23);
+
+ if (l21 == 0.0 && l23 == 0.0) {
+ addLine(x1, y1, x3, y3, false);
+ return;
+ }
+
+ if (l21 == 0.0) {
+ addLine(x2, y2, x3, y3, false);
+ return;
+ }
+
+ if (l23 == 0.0) {
+ addLine(x1, y1, x2, y2, false);
+ return;
+ }
+
+ double w;
+ w = w2 / l21;
+ double mx1 = - y21 * w;
+ double my1 = x21 * w;
+ w = w2 / l23;
+ double mx3 = y23 * w;
+ double my3 = - x23 * w;
+
+ double lx1 = x1 + mx1;
+ double ly1 = y1 + my1;
+ double rx1 = x1 - mx1;
+ double ry1 = y1 - my1;
+
+ if (checkMove) {
+ if (isMove) {
+ isMove = false;
+ lp.moveTo(lx1, ly1);
+ rp.moveTo(rx1, ry1);
+ } else {
+ addJoin(lp, x1, y1, lx1, ly1, true);
+ addJoin(rp, x1, y1, rx1, ry1, false);
+ }
+ }
+
+ if (x21 * y23 - y21 * x23 == 0.0) {
+ // On line curve
+ if (x21 * x23 + y21 * y23 > 0.0) {
+ // Twisted curve
+ if (l21 == l23) {
+ double px = x1 + (x21 + x23) / 4.0;
+ double py = y1 + (y21 + y23) / 4.0;
+ lp.lineTo(px + mx1, py + my1);
+ rp.lineTo(px - mx1, py - my1);
+ lp.lineTo(px - mx1, py - my1);
+ rp.lineTo(px + mx1, py + my1);
+ lp.lineTo(x3 - mx1, y3 - my1);
+ rp.lineTo(x3 + mx1, y3 + my1);
+ } else {
+ double px1, py1;
+ double k = l21 / (l21 + l23);
+ double px = x1 + (x21 + x23) * k * k;
+ double py = y1 + (y21 + y23) * k * k;
+ px1 = (x1 + px) / 2.0;
+ py1 = (y1 + py) / 2.0;
+ lp.quadTo(px1 + mx1, py1 + my1, px + mx1, py + my1);
+ rp.quadTo(px1 - mx1, py1 - my1, px - mx1, py - my1);
+ lp.lineTo(px - mx1, py - my1);
+ rp.lineTo(px + mx1, py + my1);
+ px1 = (x3 + px) / 2.0;
+ py1 = (y3 + py) / 2.0;
+ lp.quadTo(px1 - mx1, py1 - my1, x3 - mx1, y3 - my1);
+ rp.quadTo(px1 + mx1, py1 + my1, x3 + mx1, y3 + my1);
+ }
+ } else {
+ // Simple curve
+ lp.quadTo(x2 + mx1, y2 + my1, x3 + mx3, y3 + my3);
+ rp.quadTo(x2 - mx1, y2 - my1, x3 - mx3, y3 - my3);
+ }
+ } else {
+ addSubQuad(x1, y1, x2, y2, x3, y3, 0);
+ }
+ }
+
+ /**
+ * Subdivides solid quad curve to make outline for source quad segment and adds it to work path.
+ *
+ * @param x1 - the x coordinate of the first control point
+ * @param y1 - the y coordinate of the first control point
+ * @param x2 - the x coordinate of the second control point
+ * @param y2 - the y coordinate of the second control point
+ * @param x3 - the x coordinate of the third control point
+ * @param y3 - the y coordinate of the third control point
+ * @param level - the maximum level of subdivision deepness
+ */
+ void addSubQuad(double x1, double y1, double x2, double y2, double x3, double y3, int level) {
+ double x21 = x2 - x1;
+ double y21 = y2 - y1;
+ double x23 = x2 - x3;
+ double y23 = y2 - y3;
+
+ double cos = x21 * x23 + y21 * y23;
+ double sin = x21 * y23 - y21 * x23;
+
+ if (level < MAX_LEVEL && (cos >= 0.0 || (Math.abs(sin / cos) > curveDelta))) {
+ double c1x = (x2 + x1) / 2.0;
+ double c1y = (y2 + y1) / 2.0;
+ double c2x = (x2 + x3) / 2.0;
+ double c2y = (y2 + y3) / 2.0;
+ double c3x = (c1x + c2x) / 2.0;
+ double c3y = (c1y + c2y) / 2.0;
+ addSubQuad(x1, y1, c1x, c1y, c3x, c3y, level + 1);
+ addSubQuad(c3x, c3y, c2x, c2y, x3, y3, level + 1);
+ } else {
+ double w;
+ double l21 = Math.sqrt(x21 * x21 + y21 * y21);
+ double l23 = Math.sqrt(x23 * x23 + y23 * y23);
+ w = w2 / sin;
+ double mx2 = (x21 * l23 + x23 * l21) * w;
+ double my2 = (y21 * l23 + y23 * l21) * w;
+ w = w2 / l23;
+ double mx3 = y23 * w;
+ double my3 = - x23 * w;
+ lp.quadTo(x2 + mx2, y2 + my2, x3 + mx3, y3 + my3);
+ rp.quadTo(x2 - mx2, y2 - my2, x3 - mx3, y3 - my3);
+ }
+ }
+
+ /**
+ * Adds solid cubic segment to the work path.
+ *
+ * @param x1 - the x coordinate of the first control point
+ * @param y1 - the y coordinate of the first control point
+ * @param x2 - the x coordinate of the second control point
+ * @param y2 - the y coordinate of the second control point
+ * @param x3 - the x coordinate of the third control point
+ * @param y3 - the y coordinate of the third control point
+ * @param x4 - the x coordinate of the fours control point
+ * @param y4 - the y coordinate of the fours control point
+ */
+ void addCubic(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
+ double x12 = x1 - x2;
+ double y12 = y1 - y2;
+ double x23 = x2 - x3;
+ double y23 = y2 - y3;
+ double x34 = x3 - x4;
+ double y34 = y3 - y4;
+
+ double l12 = Math.sqrt(x12 * x12 + y12 * y12);
+ double l23 = Math.sqrt(x23 * x23 + y23 * y23);
+ double l34 = Math.sqrt(x34 * x34 + y34 * y34);
+
+ // All edges are zero
+ if (l12 == 0.0 && l23 == 0.0 && l34 == 0.0) {
+ addLine(x1, y1, x4, y4, false);
+ return;
+ }
+
+ // One zero edge
+ if (l12 == 0.0 && l23 == 0.0) {
+ addLine(x3, y3, x4, y4, false);
+ return;
+ }
+
+ if (l23 == 0.0 && l34 == 0.0) {
+ addLine(x1, y1, x2, y2, false);
+ return;
+ }
+
+ if (l12 == 0.0 && l34 == 0.0) {
+ addLine(x2, y2, x3, y3, false);
+ return;
+ }
+
+ double w, mx1, my1, mx4, my4;
+ boolean onLine;
+
+ if (l12 == 0.0) {
+ w = w2 / l23;
+ mx1 = y23 * w;
+ my1 = - x23 * w;
+ w = w2 / l34;
+ mx4 = y34 * w;
+ my4 = - x34 * w;
+ onLine = - x23 * y34 + y23 * x34 == 0.0; // sin3
+ } else
+ if (l34 == 0.0) {
+ w = w2 / l12;
+ mx1 = y12 * w;
+ my1 = - x12 * w;
+ w = w2 / l23;
+ mx4 = y23 * w;
+ my4 = - x23 * w;
+ onLine = - x12 * y23 + y12 * x23 == 0.0; // sin2
+ } else {
+ w = w2 / l12;
+ mx1 = y12 * w;
+ my1 = - x12 * w;
+ w = w2 / l34;
+ mx4 = y34 * w;
+ my4 = - x34 * w;
+ if (l23 == 0.0) {
+ onLine = - x12 * y34 + y12 * x34 == 0.0;
+ } else {
+ onLine =
+ - x12 * y34 + y12 * x34 == 0.0 &&
+ - x12 * y23 + y12 * x23 == 0.0 && // sin2
+ - x23 * y34 + y23 * x34 == 0.0; // sin3
+ }
+ }
+
+ double lx1 = x1 + mx1;
+ double ly1 = y1 + my1;
+ double rx1 = x1 - mx1;
+ double ry1 = y1 - my1;
+
+ if (checkMove) {
+ if (isMove) {
+ isMove = false;
+ lp.moveTo(lx1, ly1);
+ rp.moveTo(rx1, ry1);
+ } else {
+ addJoin(lp, x1, y1, lx1, ly1, true);
+ addJoin(rp, x1, y1, rx1, ry1, false);
+ }
+ }
+
+ if (onLine) {
+ if ((x1 == x2 && y1 < y2) || x1 < x2) {
+ l12 = -l12;
+ }
+ if ((x2 == x3 && y2 < y3) || x2 < x3) {
+ l23 = -l23;
+ }
+ if ((x3 == x4 && y3 < y4) || x3 < x4) {
+ l34 = -l34;
+ }
+ double d = l23 * l23 - l12 * l34;
+ double roots[] = new double[3];
+ int rc = 0;
+ if (d == 0.0) {
+ double t = (l12 - l23) / (l12 + l34 - l23 - l23);
+ if (0.0 < t && t < 1.0) {
+ roots[rc++] = t;
+ }
+ } else
+ if (d > 0.0) {
+ d = Math.sqrt(d);
+ double z = l12 + l34 - l23 - l23;
+ double t;
+ t = (l12 - l23 + d) / z;
+ if (0.0 < t && t < 1.0) {
+ roots[rc++] = t;
+ }
+ t = (l12 - l23 - d) / z;
+ if (0.0 < t && t < 1.0) {
+ roots[rc++] = t;
+ }
+ }
+
+ if (rc > 0) {
+ // Sort roots
+ if (rc == 2 && roots[0] > roots[1]) {
+ double tmp = roots[0];
+ roots[0] = roots[1];
+ roots[1] = tmp;
+ }
+ roots[rc++] = 1.0;
+
+ double ax = - x34 - x12 + x23 + x23;
+ double ay = - y34 - y12 + y23 + y23;
+ double bx = 3.0 * (- x23 + x12);
+ double by = 3.0 * (- y23 + y12);
+ double cx = 3.0 * (- x12);
+ double cy = 3.0 * (- y12);
+ double xPrev = x1;
+ double yPrev = y1;
+ for(int i = 0; i < rc; i++) {
+ double t = roots[i];
+ double px = t * (t * (t * ax + bx) + cx) + x1;
+ double py = t * (t * (t * ay + by) + cy) + y1;
+ double px1 = (xPrev + px) / 2.0;
+ double py1 = (yPrev + py) / 2.0;
+ lp.cubicTo(px1 + mx1, py1 + my1, px1 + mx1, py1 + my1, px + mx1, py + my1);
+ rp.cubicTo(px1 - mx1, py1 - my1, px1 - mx1, py1 - my1, px - mx1, py - my1);
+ if (i < rc - 1) {
+ lp.lineTo(px - mx1, py - my1);
+ rp.lineTo(px + mx1, py + my1);
+ }
+ xPrev = px;
+ yPrev = py;
+ mx1 = - mx1;
+ my1 = - my1;
+ }
+ } else {
+ lp.cubicTo(x2 + mx1, y2 + my1, x3 + mx4, y3 + my4, x4 + mx4, y4 + my4);
+ rp.cubicTo(x2 - mx1, y2 - my1, x3 - mx4, y3 - my4, x4 - mx4, y4 - my4);
+ }
+ } else {
+ addSubCubic(x1, y1, x2, y2, x3, y3, x4, y4, 0);
+ }
+ }
+
+ /**
+ * Subdivides solid cubic curve to make outline for source quad segment and adds it to work path.
+ *
+ * @param x1 - the x coordinate of the first control point
+ * @param y1 - the y coordinate of the first control point
+ * @param x2 - the x coordinate of the second control point
+ * @param y2 - the y coordinate of the second control point
+ * @param x3 - the x coordinate of the third control point
+ * @param y3 - the y coordinate of the third control point
+ * @param x4 - the x coordinate of the fours control point
+ * @param y4 - the y coordinate of the fours control point
+ * @param level - the maximum level of subdivision deepness
+ */
+ void addSubCubic(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, int level) {
+ double x12 = x1 - x2;
+ double y12 = y1 - y2;
+ double x23 = x2 - x3;
+ double y23 = y2 - y3;
+ double x34 = x3 - x4;
+ double y34 = y3 - y4;
+
+ double cos2 = - x12 * x23 - y12 * y23;
+ double cos3 = - x23 * x34 - y23 * y34;
+ double sin2 = - x12 * y23 + y12 * x23;
+ double sin3 = - x23 * y34 + y23 * x34;
+ double sin0 = - x12 * y34 + y12 * x34;
+ double cos0 = - x12 * x34 - y12 * y34;
+
+ if (level < MAX_LEVEL && (sin2 != 0.0 || sin3 != 0.0 || sin0 != 0.0) &&
+ (cos2 >= 0.0 || cos3 >= 0.0 || cos0 >= 0.0 ||
+ (Math.abs(sin2 / cos2) > curveDelta) ||
+ (Math.abs(sin3 / cos3) > curveDelta) ||
+ (Math.abs(sin0 / cos0) > curveDelta)))
+ {
+ double cx = (x2 + x3) / 2.0;
+ double cy = (y2 + y3) / 2.0;
+ double lx2 = (x2 + x1) / 2.0;
+ double ly2 = (y2 + y1) / 2.0;
+ double rx3 = (x3 + x4) / 2.0;
+ double ry3 = (y3 + y4) / 2.0;
+ double lx3 = (cx + lx2) / 2.0;
+ double ly3 = (cy + ly2) / 2.0;
+ double rx2 = (cx + rx3) / 2.0;
+ double ry2 = (cy + ry3) / 2.0;
+ cx = (lx3 + rx2) / 2.0;
+ cy = (ly3 + ry2) / 2.0;
+ addSubCubic(x1, y1, lx2, ly2, lx3, ly3, cx, cy, level + 1);
+ addSubCubic(cx, cy, rx2, ry2, rx3, ry3, x4, y4, level + 1);
+ } else {
+ double w, mx1, my1, mx2, my2, mx3, my3, mx4, my4;
+ double l12 = Math.sqrt(x12 * x12 + y12 * y12);
+ double l23 = Math.sqrt(x23 * x23 + y23 * y23);
+ double l34 = Math.sqrt(x34 * x34 + y34 * y34);
+
+ if (l12 == 0.0) {
+ w = w2 / l23;
+ mx1 = y23 * w;
+ my1 = - x23 * w;
+ w = w2 / l34;
+ mx4 = y34 * w;
+ my4 = - x34 * w;
+ } else
+ if (l34 == 0.0) {
+ w = w2 / l12;
+ mx1 = y12 * w;
+ my1 = - x12 * w;
+ w = w2 / l23;
+ mx4 = y23 * w;
+ my4 = - x23 * w;
+ } else {
+ // Common case
+ w = w2 / l12;
+ mx1 = y12 * w;
+ my1 = - x12 * w;
+ w = w2 / l34;
+ mx4 = y34 * w;
+ my4 = - x34 * w;
+ }
+
+ if (sin2 == 0.0) {
+ mx2 = mx1;
+ my2 = my1;
+ } else {
+ w = w2 / sin2;
+ mx2 = -(x12 * l23 - x23 * l12) * w;
+ my2 = -(y12 * l23 - y23 * l12) * w;
+ }
+ if (sin3 == 0.0) {
+ mx3 = mx4;
+ my3 = my4;
+ } else {
+ w = w2 / sin3;
+ mx3 = -(x23 * l34 - x34 * l23) * w;
+ my3 = -(y23 * l34 - y34 * l23) * w;
+ }
+
+ lp.cubicTo(x2 + mx2, y2 + my2, x3 + mx3, y3 + my3, x4 + mx4, y4 + my4);
+ rp.cubicTo(x2 - mx2, y2 - my2, x3 - mx3, y3 - my3, x4 - mx4, y4 - my4);
+ }
+ }
+
+ /**
+ * Adds dashed line segment to the work path.
+ *
+ * @param x1 - the x coordinate of the start line point
+ * @param y1 - the y coordinate of the start line point
+ * @param x2 - the x coordinate of the end line point
+ * @param y2 - the y coordinate of the end line point
+ */
+ void addDashLine(double x1, double y1, double x2, double y2) {
+ double x21 = x2 - x1;
+ double y21 = y2 - y1;
+
+ double l21 = Math.sqrt(x21 * x21 + y21 * y21);
+
+ if (l21 == 0.0) {
+ return;
+ }
+
+ double px1, py1;
+ px1 = py1 = 0.0;
+ double w = w2 / l21;
+ double mx = - y21 * w;
+ double my = x21 * w;
+
+ dasher.init(new DashIterator.Line(l21));
+
+ while(!dasher.eof()) {
+ double t = dasher.getValue();
+ scx = x1 + t * x21;
+ scy = y1 + t * y21;
+
+ if (dasher.isOpen()) {
+ px1 = scx;
+ py1 = scy;
+ double lx1 = px1 + mx;
+ double ly1 = py1 + my;
+ double rx1 = px1 - mx;
+ double ry1 = py1 - my;
+ if (isMove) {
+ isMove = false;
+ smx = px1;
+ smy = py1;
+ rp.clean();
+ lp.moveTo(lx1, ly1);
+ rp.moveTo(rx1, ry1);
+ } else {
+ addJoin(lp, x1, y1, lx1, ly1, true);
+ addJoin(rp, x1, y1, rx1, ry1, false);
+ }
+ } else
+ if (dasher.isContinue()) {
+ double px2 = scx;
+ double py2 = scy;
+ lp.lineTo(px2 + mx, py2 + my);
+ rp.lineTo(px2 - mx, py2 - my);
+ if (dasher.close) {
+ addCap(lp, px2, py2, rp.xLast, rp.yLast);
+ lp.combine(rp);
+ if (isFirst) {
+ isFirst = false;
+ fmx = smx;
+ fmy = smy;
+ sp = lp;
+ lp = new BufferedPath();
+ } else {
+ addCap(lp, smx, smy, lp.xMove, lp.yMove);
+ lp.closePath();
+ }
+ isMove = true;
+ }
+ }
+
+ dasher.next();
+ }
+ }
+
+ /**
+ * Adds dashed quad segment to the work path.
+ *
+ * @param x1 - the x coordinate of the first control point
+ * @param y1 - the y coordinate of the first control point
+ * @param x2 - the x coordinate of the second control point
+ * @param y2 - the y coordinate of the second control point
+ * @param x3 - the x coordinate of the third control point
+ * @param y3 - the y coordinate of the third control point
+ */
+ void addDashQuad(double x1, double y1, double x2, double y2, double x3, double y3) {
+
+ double x21 = x2 - x1;
+ double y21 = y2 - y1;
+ double x23 = x2 - x3;
+ double y23 = y2 - y3;
+
+ double l21 = Math.sqrt(x21 * x21 + y21 * y21);
+ double l23 = Math.sqrt(x23 * x23 + y23 * y23);
+
+ if (l21 == 0.0 && l23 == 0.0) {
+ return;
+ }
+
+ if (l21 == 0.0) {
+ addDashLine(x2, y2, x3, y3);
+ return;
+ }
+
+ if (l23 == 0.0) {
+ addDashLine(x1, y1, x2, y2);
+ return;
+ }
+
+ double ax = x1 + x3 - x2 - x2;
+ double ay = y1 + y3 - y2 - y2;
+ double bx = x2 - x1;
+ double by = y2 - y1;
+ double cx = x1;
+ double cy = y1;
+
+ double px1, py1, dx1, dy1;
+ px1 = py1 = dx1 = dy1 = 0.0;
+ double prev = 0.0;
+
+ dasher.init(new DashIterator.Quad(x1, y1, x2, y2, x3, y3));
+
+ while(!dasher.eof()) {
+ double t = dasher.getValue();
+ double dx = t * ax + bx;
+ double dy = t * ay + by;
+ scx = t * (dx + bx) + cx; // t^2 * ax + 2.0 * t * bx + cx
+ scy = t * (dy + by) + cy; // t^2 * ay + 2.0 * t * by + cy
+ if (dasher.isOpen()) {
+ px1 = scx;
+ py1 = scy;
+ dx1 = dx;
+ dy1 = dy;
+ double w = w2 / Math.sqrt(dx1 * dx1 + dy1 * dy1);
+ double mx1 = - dy1 * w;
+ double my1 = dx1 * w;
+ double lx1 = px1 + mx1;
+ double ly1 = py1 + my1;
+ double rx1 = px1 - mx1;
+ double ry1 = py1 - my1;
+ if (isMove) {
+ isMove = false;
+ smx = px1;
+ smy = py1;
+ rp.clean();
+ lp.moveTo(lx1, ly1);
+ rp.moveTo(rx1, ry1);
+ } else {
+ addJoin(lp, x1, y1, lx1, ly1, true);
+ addJoin(rp, x1, y1, rx1, ry1, false);
+ }
+ } else
+ if (dasher.isContinue()) {
+ double px3 = scx;
+ double py3 = scy;
+ double sx = x2 - x23 * prev;
+ double sy = y2 - y23 * prev;
+ double t2 = (t - prev) / (1 - prev);
+ double px2 = px1 + (sx - px1) * t2;
+ double py2 = py1 + (sy - py1) * t2;
+
+ addQuad(px1, py1, px2, py2, px3, py3);
+ if (dasher.isClosed()) {
+ addCap(lp, px3, py3, rp.xLast, rp.yLast);
+ lp.combine(rp);
+ if (isFirst) {
+ isFirst = false;
+ fmx = smx;
+ fmy = smy;
+ sp = lp;
+ lp = new BufferedPath();
+ } else {
+ addCap(lp, smx, smy, lp.xMove, lp.yMove);
+ lp.closePath();
+ }
+ isMove = true;
+ }
+ }
+
+ prev = t;
+ dasher.next();
+ }
+ }
+
+ /**
+ * Adds dashed cubic segment to the work path.
+ *
+ * @param x1 - the x coordinate of the first control point
+ * @param y1 - the y coordinate of the first control point
+ * @param x2 - the x coordinate of the second control point
+ * @param y2 - the y coordinate of the second control point
+ * @param x3 - the x coordinate of the third control point
+ * @param y3 - the y coordinate of the third control point
+ * @param x4 - the x coordinate of the fours control point
+ * @param y4 - the y coordinate of the fours control point
+ */
+ void addDashCubic(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
+
+ double x12 = x1 - x2;
+ double y12 = y1 - y2;
+ double x23 = x2 - x3;
+ double y23 = y2 - y3;
+ double x34 = x3 - x4;
+ double y34 = y3 - y4;
+
+ double l12 = Math.sqrt(x12 * x12 + y12 * y12);
+ double l23 = Math.sqrt(x23 * x23 + y23 * y23);
+ double l34 = Math.sqrt(x34 * x34 + y34 * y34);
+
+ // All edges are zero
+ if (l12 == 0.0 && l23 == 0.0 && l34 == 0.0) {
+ // NOTHING
+ return;
+ }
+
+ // One zero edge
+ if (l12 == 0.0 && l23 == 0.0) {
+ addDashLine(x3, y3, x4, y4);
+ return;
+ }
+
+ if (l23 == 0.0 && l34 == 0.0) {
+ addDashLine(x1, y1, x2, y2);
+ return;
+ }
+
+ if (l12 == 0.0 && l34 == 0.0) {
+ addDashLine(x2, y2, x3, y3);
+ return;
+ }
+
+ double ax = x4 - x1 + 3.0 * (x2 - x3);
+ double ay = y4 - y1 + 3.0 * (y2 - y3);
+ double bx = 3.0 * (x1 + x3 - x2 - x2);
+ double by = 3.0 * (y1 + y3 - y2 - y2);
+ double cx = 3.0 * (x2 - x1);
+ double cy = 3.0 * (y2 - y1);
+ double dx = x1;
+ double dy = y1;
+
+ double px1 = 0.0;
+ double py1 = 0.0;
+ double prev = 0.0;
+
+ dasher.init(new DashIterator.Cubic(x1, y1, x2, y2, x3, y3, x4, y4));
+
+ while(!dasher.eof()) {
+
+ double t = dasher.getValue();
+ scx = t * (t * (t * ax + bx) + cx) + dx;
+ scy = t * (t * (t * ay + by) + cy) + dy;
+ if (dasher.isOpen()) {
+ px1 = scx;
+ py1 = scy;
+ double dx1 = t * (t * (ax + ax + ax) + bx + bx) + cx;
+ double dy1 = t * (t * (ay + ay + ay) + by + by) + cy;
+ double w = w2 / Math.sqrt(dx1 * dx1 + dy1 * dy1);
+ double mx1 = - dy1 * w;
+ double my1 = dx1 * w;
+ double lx1 = px1 + mx1;
+ double ly1 = py1 + my1;
+ double rx1 = px1 - mx1;
+ double ry1 = py1 - my1;
+ if (isMove) {
+ isMove = false;
+ smx = px1;
+ smy = py1;
+ rp.clean();
+ lp.moveTo(lx1, ly1);
+ rp.moveTo(rx1, ry1);
+ } else {
+ addJoin(lp, x1, y1, lx1, ly1, true);
+ addJoin(rp, x1, y1, rx1, ry1, false);
+ }
+ } else
+ if (dasher.isContinue()) {
+ double sx1 = x2 - x23 * prev;
+ double sy1 = y2 - y23 * prev;
+ double sx2 = x3 - x34 * prev;
+ double sy2 = y3 - y34 * prev;
+ double sx3 = sx1 + (sx2 - sx1) * prev;
+ double sy3 = sy1 + (sy2 - sy1) * prev;
+ double t2 = (t - prev) / (1 - prev);
+ double sx4 = sx3 + (sx2 - sx3) * t2;
+ double sy4 = sy3 + (sy2 - sy3) * t2;
+
+ double px4 = scx;
+ double py4 = scy;
+ double px2 = px1 + (sx3 - px1) * t2;
+ double py2 = py1 + (sy3 - py1) * t2;
+ double px3 = px2 + (sx4 - px2) * t2;
+ double py3 = py2 + (sy4 - py2) * t2;
+
+ addCubic(px1, py1, px2, py2, px3, py3, px4, py4);
+ if (dasher.isClosed()) {
+ addCap(lp, px4, py4, rp.xLast, rp.yLast);
+ lp.combine(rp);
+ if (isFirst) {
+ isFirst = false;
+ fmx = smx;
+ fmy = smy;
+ sp = lp;
+ lp = new BufferedPath();
+ } else {
+ addCap(lp, smx, smy, lp.xMove, lp.yMove);
+ lp.closePath();
+ }
+ isMove = true;
+ }
+ }
+
+ prev = t;
+ dasher.next();
+ }
+ }
+
+ /**
+ * Dasher class provides dashing for particular dash style.
+ */
+ class Dasher {
+
+ /** The pos. */
+ double pos;
+
+ /** The first. */
+ boolean close, visible, first;
+
+ /** The dash. */
+ float dash[];
+
+ /** The phase. */
+ float phase;
+
+ /** The index. */
+ int index;
+
+ /** The iter. */
+ DashIterator iter;
+
+ /**
+ * Instantiates a new dasher.
+ *
+ * @param dash the dash
+ * @param phase the phase
+ */
+ Dasher(float dash[], float phase) {
+ this.dash = dash;
+ this.phase = phase;
+ index = 0;
+ pos = phase;
+ visible = true;
+ while (pos >= dash[index]) {
+ visible = !visible;
+ pos -= dash[index];
+ index = (index + 1) % dash.length;
+ }
+ pos = -pos;
+ first = visible;
+ }
+
+ /**
+ * Inits the.
+ *
+ * @param iter the iter
+ */
+ void init(DashIterator iter) {
+ this.iter = iter;
+ close = true;
+ }
+
+ /**
+ * Checks if is open.
+ *
+ * @return true, if is open
+ */
+ boolean isOpen() {
+ return visible && pos < iter.length;
+ }
+
+ /**
+ * Checks if is continue.
+ *
+ * @return true, if is continue
+ */
+ boolean isContinue() {
+ return !visible && pos > 0;
+ }
+
+ /**
+ * Checks if is closed.
+ *
+ * @return true, if is closed
+ */
+ boolean isClosed() {
+ return close;
+ }
+
+ /**
+ * Checks if is connected.
+ *
+ * @return true, if is connected
+ */
+ boolean isConnected() {
+ return first && !close;
+ }
+
+ /**
+ * Eof.
+ *
+ * @return true, if successful
+ */
+ boolean eof() {
+ if (!close) {
+ pos -= iter.length;
+ return true;
+ }
+ if (pos >= iter.length) {
+ if (visible) {
+ pos -= iter.length;
+ return true;
+ }
+ close = pos == iter.length;
+ }
+ return false;
+ }
+
+ /**
+ * Next.
+ */
+ void next() {
+ if (close) {
+ pos += dash[index];
+ index = (index + 1) % dash.length;
+ } else {
+ // Go back
+ index = (index + dash.length - 1) % dash.length;
+ pos -= dash[index];
+ }
+ visible = !visible;
+ }
+
+ /**
+ * Gets the value.
+ *
+ * @return the value
+ */
+ double getValue() {
+ double t = iter.getNext(pos);
+ return t < 0 ? 0 : (t > 1 ? 1 : t);
+ }
+
+ }
+
+ /**
+ * DashIterator class provides dashing for particular segment type.
+ */
+ static abstract class DashIterator {
+
+ /** The Constant FLATNESS. */
+ static final double FLATNESS = 1.0;
+
+ /**
+ * The Class Line.
+ */
+ static class Line extends DashIterator {
+
+ /**
+ * Instantiates a new line.
+ *
+ * @param len the len
+ */
+ Line(double len) {
+ length = len;
+ }
+
+ @Override
+ double getNext(double dashPos) {
+ return dashPos / length;
+ }
+
+ }
+
+ /**
+ * The Class Quad.
+ */
+ static class Quad extends DashIterator {
+
+ /** The val size. */
+ int valSize;
+
+ /** The val pos. */
+ int valPos;
+
+ /** The cur len. */
+ double curLen;
+
+ /** The prev len. */
+ double prevLen;
+
+ /** The last len. */
+ double lastLen;
+
+ /** The values. */
+ double[] values;
+
+ /** The step. */
+ double step;
+
+ /**
+ * Instantiates a new quad.
+ *
+ * @param x1 the x1
+ * @param y1 the y1
+ * @param x2 the x2
+ * @param y2 the y2
+ * @param x3 the x3
+ * @param y3 the y3
+ */
+ Quad(double x1, double y1, double x2, double y2, double x3, double y3) {
+
+ double nx = x1 + x3 - x2 - x2;
+ double ny = y1 + y3 - y2 - y2;
+
+ int n = (int)(1 + Math.sqrt(0.75 * (Math.abs(nx) + Math.abs(ny)) * FLATNESS));
+ step = 1.0 / n;
+
+ double ax = x1 + x3 - x2 - x2;
+ double ay = y1 + y3 - y2 - y2;
+ double bx = 2.0 * (x2 - x1);
+ double by = 2.0 * (y2 - y1);
+
+ double dx1 = step * (step * ax + bx);
+ double dy1 = step * (step * ay + by);
+ double dx2 = step * (step * ax * 2.0);
+ double dy2 = step * (step * ay * 2.0);
+ double vx = x1;
+ double vy = y1;
+
+ valSize = n;
+ values = new double[valSize];
+ double pvx = vx;
+ double pvy = vy;
+ length = 0.0;
+ for(int i = 0; i < n; i++) {
+ vx += dx1;
+ vy += dy1;
+ dx1 += dx2;
+ dy1 += dy2;
+ double lx = vx - pvx;
+ double ly = vy - pvy;
+ values[i] = Math.sqrt(lx * lx + ly * ly);
+ length += values[i];
+ pvx = vx;
+ pvy = vy;
+ }
+
+ valPos = 0;
+ curLen = 0.0;
+ prevLen = 0.0;
+ }
+
+ @Override
+ double getNext(double dashPos) {
+ double t = 2.0;
+ while (curLen <= dashPos && valPos < valSize) {
+ prevLen = curLen;
+ curLen += lastLen = values[valPos++];
+ }
+ if (curLen > dashPos) {
+ t = (valPos - 1 + (dashPos - prevLen) / lastLen) * step;
+ }
+ return t;
+ }
+
+ }
+
+ /**
+ * The Class Cubic.
+ */
+ static class Cubic extends DashIterator {
+
+ /** The val size. */
+ int valSize;
+
+ /** The val pos. */
+ int valPos;
+
+ /** The cur len. */
+ double curLen;
+
+ /** The prev len. */
+ double prevLen;
+
+ /** The last len. */
+ double lastLen;
+
+ /** The values. */
+ double[] values;
+
+ /** The step. */
+ double step;
+
+ /**
+ * Instantiates a new cubic.
+ *
+ * @param x1 the x1
+ * @param y1 the y1
+ * @param x2 the x2
+ * @param y2 the y2
+ * @param x3 the x3
+ * @param y3 the y3
+ * @param x4 the x4
+ * @param y4 the y4
+ */
+ Cubic(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
+
+ double nx1 = x1 + x3 - x2 - x2;
+ double ny1 = y1 + y3 - y2 - y2;
+ double nx2 = x2 + x4 - x3 - x3;
+ double ny2 = y2 + y4 - y3 - y3;
+
+ double max = Math.max(Math.abs(nx1) + Math.abs(ny1), Math.abs(nx2) + Math.abs(ny2));
+ int n = (int)(1 + Math.sqrt(0.75 * max) * FLATNESS);
+ step = 1.0 / n;
+
+ double ax = x4 - x1 + 3.0 * (x2 - x3);
+ double ay = y4 - y1 + 3.0 * (y2 - y3);
+ double bx = 3.0 * (x1 + x3 - x2 - x2);
+ double by = 3.0 * (y1 + y3 - y2 - y2);
+ double cx = 3.0 * (x2 - x1);
+ double cy = 3.0 * (y2 - y1);
+
+ double dx1 = step * (step * (step * ax + bx) + cx);
+ double dy1 = step * (step * (step * ay + by) + cy);
+ double dx2 = step * (step * (step * ax * 6.0 + bx * 2.0));
+ double dy2 = step * (step * (step * ay * 6.0 + by * 2.0));
+ double dx3 = step * (step * (step * ax * 6.0));
+ double dy3 = step * (step * (step * ay * 6.0));
+ double vx = x1;
+ double vy = y1;
+
+ valSize = n;
+ values = new double[valSize];
+ double pvx = vx;
+ double pvy = vy;
+ length = 0.0;
+ for(int i = 0; i < n; i++) {
+ vx += dx1;
+ vy += dy1;
+ dx1 += dx2;
+ dy1 += dy2;
+ dx2 += dx3;
+ dy2 += dy3;
+ double lx = vx - pvx;
+ double ly = vy - pvy;
+ values[i] = Math.sqrt(lx * lx + ly * ly);
+ length += values[i];
+ pvx = vx;
+ pvy = vy;
+ }
+
+ valPos = 0;
+ curLen = 0.0;
+ prevLen = 0.0;
+ }
+
+ @Override
+ double getNext(double dashPos) {
+ double t = 2.0;
+ while (curLen <= dashPos && valPos < valSize) {
+ prevLen = curLen;
+ curLen += lastLen = values[valPos++];
+ }
+ if (curLen > dashPos) {
+ t = (valPos - 1 + (dashPos - prevLen) / lastLen) * step;
+ }
+ return t;
+ }
+
+ }
+
+ /** The length. */
+ double length;
+
+ /**
+ * Gets the next.
+ *
+ * @param dashPos the dash pos
+ *
+ * @return the next
+ */
+ abstract double getNext(double dashPos);
+
+ }
+
+ /**
+ * BufferedPath class provides work path storing and processing.
+ */
+ static class BufferedPath {
+
+ /** The Constant bufCapacity. */
+ private static final int bufCapacity = 10;
+
+ /** The point shift. */
+ static int pointShift[] = {
+ 2, // MOVETO
+ 2, // LINETO
+ 4, // QUADTO
+ 6, // CUBICTO
+ 0}; // CLOSE
+
+ /** The types. */
+ byte[] types;
+
+ /** The points. */
+ float[] points;
+
+ /** The type size. */
+ int typeSize;
+
+ /** The point size. */
+ int pointSize;
+
+ /** The x last. */
+ float xLast;
+
+ /** The y last. */
+ float yLast;
+
+ /** The x move. */
+ float xMove;
+
+ /** The y move. */
+ float yMove;
+
+ /**
+ * Instantiates a new buffered path.
+ */
+ public BufferedPath() {
+ types = new byte[bufCapacity];
+ points = new float[bufCapacity * 2];
+ }
+
+ /**
+ * Check buf.
+ *
+ * @param typeCount the type count
+ * @param pointCount the point count
+ */
+ void checkBuf(int typeCount, int pointCount) {
+ if (typeSize + typeCount > types.length) {
+ byte tmp[] = new byte[typeSize + Math.max(bufCapacity, typeCount)];
+ System.arraycopy(types, 0, tmp, 0, typeSize);
+ types = tmp;
+ }
+ if (pointSize + pointCount > points.length) {
+ float tmp[] = new float[pointSize + Math.max(bufCapacity * 2, pointCount)];
+ System.arraycopy(points, 0, tmp, 0, pointSize);
+ points = tmp;
+ }
+ }
+
+ /**
+ * Checks if is empty.
+ *
+ * @return true, if is empty
+ */
+ boolean isEmpty() {
+ return typeSize == 0;
+ }
+
+ /**
+ * Clean.
+ */
+ void clean() {
+ typeSize = 0;
+ pointSize = 0;
+ }
+
+ /**
+ * Move to.
+ *
+ * @param x the x
+ * @param y the y
+ */
+ void moveTo(double x, double y) {
+ checkBuf(1, 2);
+ types[typeSize++] = PathIterator.SEG_MOVETO;
+ points[pointSize++] = xMove = (float)x;
+ points[pointSize++] = yMove = (float)y;
+ }
+
+ /**
+ * Line to.
+ *
+ * @param x the x
+ * @param y the y
+ */
+ void lineTo(double x, double y) {
+ checkBuf(1, 2);
+ types[typeSize++] = PathIterator.SEG_LINETO;
+ points[pointSize++] = xLast = (float)x;
+ points[pointSize++] = yLast = (float)y;
+ }
+
+ /**
+ * Quad to.
+ *
+ * @param x1 the x1
+ * @param y1 the y1
+ * @param x2 the x2
+ * @param y2 the y2
+ */
+ void quadTo(double x1, double y1, double x2, double y2) {
+ checkBuf(1, 4);
+ types[typeSize++] = PathIterator.SEG_QUADTO;
+ points[pointSize++] = (float)x1;
+ points[pointSize++] = (float)y1;
+ points[pointSize++] = xLast = (float)x2;
+ points[pointSize++] = yLast = (float)y2;
+ }
+
+ /**
+ * Cubic to.
+ *
+ * @param x1 the x1
+ * @param y1 the y1
+ * @param x2 the x2
+ * @param y2 the y2
+ * @param x3 the x3
+ * @param y3 the y3
+ */
+ void cubicTo(double x1, double y1, double x2, double y2, double x3, double y3) {
+ checkBuf(1, 6);
+ types[typeSize++] = PathIterator.SEG_CUBICTO;
+ points[pointSize++] = (float)x1;
+ points[pointSize++] = (float)y1;
+ points[pointSize++] = (float)x2;
+ points[pointSize++] = (float)y2;
+ points[pointSize++] = xLast = (float)x3;
+ points[pointSize++] = yLast = (float)y3;
+ }
+
+ /**
+ * Close path.
+ */
+ void closePath() {
+ checkBuf(1, 0);
+ types[typeSize++] = PathIterator.SEG_CLOSE;
+ }
+
+ /**
+ * Sets the last.
+ *
+ * @param x the x
+ * @param y the y
+ */
+ void setLast(double x, double y) {
+ points[pointSize - 2] = xLast = (float)x;
+ points[pointSize - 1] = yLast = (float)y;
+ }
+
+ /**
+ * Append.
+ *
+ * @param p the p
+ */
+ void append(BufferedPath p) {
+ checkBuf(p.typeSize, p.pointSize);
+ System.arraycopy(p.points, 0, points, pointSize, p.pointSize);
+ System.arraycopy(p.types, 0, types, typeSize, p.typeSize);
+ pointSize += p.pointSize;
+ typeSize += p.typeSize;
+ xLast = points[pointSize - 2];
+ yLast = points[pointSize - 1];
+ }
+
+ /**
+ * Append reverse.
+ *
+ * @param p the p
+ */
+ void appendReverse(BufferedPath p) {
+ checkBuf(p.typeSize, p.pointSize);
+ // Skip last point, beacause it's the first point of the second path
+ for(int i = p.pointSize - 2; i >= 0; i -= 2) {
+ points[pointSize++] = p.points[i + 0];
+ points[pointSize++] = p.points[i + 1];
+ }
+ // Skip first type, beacuse it's always MOVETO
+ int closeIndex = 0;
+ for(int i = p.typeSize - 1; i >= 0; i--) {
+ byte type = p.types[i];
+ if (type == PathIterator.SEG_MOVETO) {
+ types[closeIndex] = PathIterator.SEG_MOVETO;
+ types[typeSize++] = PathIterator.SEG_CLOSE;
+ } else {
+ if (type == PathIterator.SEG_CLOSE) {
+ closeIndex = typeSize;
+ }
+ types[typeSize++] = type;
+ }
+ }
+ xLast = points[pointSize - 2];
+ yLast = points[pointSize - 1];
+ }
+
+ /**
+ * Join.
+ *
+ * @param p the p
+ */
+ void join(BufferedPath p) {
+ // Skip MOVETO
+ checkBuf(p.typeSize - 1, p.pointSize - 2);
+ System.arraycopy(p.points, 2, points, pointSize, p.pointSize - 2);
+ System.arraycopy(p.types, 1, types, typeSize, p.typeSize - 1);
+ pointSize += p.pointSize - 2;
+ typeSize += p.typeSize - 1;
+ xLast = points[pointSize - 2];
+ yLast = points[pointSize - 1];
+ }
+
+ /**
+ * Combine.
+ *
+ * @param p the p
+ */
+ void combine(BufferedPath p) {
+ checkBuf(p.typeSize - 1, p.pointSize - 2);
+ // Skip last point, beacause it's the first point of the second path
+ for(int i = p.pointSize - 4; i >= 0; i -= 2) {
+ points[pointSize++] = p.points[i + 0];
+ points[pointSize++] = p.points[i + 1];
+ }
+ // Skip first type, beacuse it's always MOVETO
+ for(int i = p.typeSize - 1; i >= 1; i--) {
+ types[typeSize++] = p.types[i];
+ }
+ xLast = points[pointSize - 2];
+ yLast = points[pointSize - 1];
+ }
+
+ /**
+ * Creates the general path.
+ *
+ * @return the general path
+ */
+ GeneralPath createGeneralPath() {
+ GeneralPath p = new GeneralPath();
+ int j = 0;
+ for(int i = 0; i < typeSize; i++) {
+ int type = types[i];
+ switch(type){
+ case PathIterator.SEG_MOVETO:
+ p.moveTo(points[j], points[j + 1]);
+ break;
+ case PathIterator.SEG_LINETO:
+ p.lineTo(points[j], points[j + 1]);
+ break;
+ case PathIterator.SEG_QUADTO:
+ p.quadTo(points[j], points[j + 1], points[j + 2], points[j + 3]);
+ break;
+ case PathIterator.SEG_CUBICTO:
+ p.curveTo(points[j], points[j + 1], points[j + 2], points[j + 3], points[j + 4], points[j + 5]);
+ break;
+ case PathIterator.SEG_CLOSE:
+ p.closePath();
+ break;
+ }
+ j += pointShift[type];
+ }
+ return p;
+ }
+
+ }
+
+}
+
diff --git a/awt/java/awt/BufferCapabilities.java b/awt/java/awt/BufferCapabilities.java
new file mode 100644
index 0000000..80e8add
--- /dev/null
+++ b/awt/java/awt/BufferCapabilities.java
@@ -0,0 +1,185 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+
+/**
+ * The BufferCapabilities class represents the capabilities
+ * and other properties of the image buffers.
+ */
+public class BufferCapabilities implements Cloneable {
+
+ /** The front buffer capabilities. */
+ private final ImageCapabilities frontBufferCapabilities;
+
+ /** The back buffer capabilities. */
+ private final ImageCapabilities backBufferCapabilities;
+
+ /** The flip contents. */
+ private final FlipContents flipContents;
+
+ /**
+ * Instantiates a new BufferCapabilities object.
+ *
+ * @param frontBufferCapabilities the front buffer capabilities,
+ * can not be null.
+ * @param backBufferCapabilities the the back and intermediate
+ * buffers capabilities, can not be null.
+ * @param flipContents the back buffer contents after page flipping,
+ * null if page flipping is not used.
+ */
+ public BufferCapabilities(ImageCapabilities frontBufferCapabilities,
+ ImageCapabilities backBufferCapabilities, FlipContents flipContents) {
+ if (frontBufferCapabilities == null || backBufferCapabilities == null) {
+ throw new IllegalArgumentException();
+ }
+
+ this.frontBufferCapabilities = frontBufferCapabilities;
+ this.backBufferCapabilities = backBufferCapabilities;
+ this.flipContents = flipContents;
+ }
+
+ /**
+ * Returns a copy of the BufferCapabilities object.
+ *
+ * @return a copy of the BufferCapabilities object.
+ */
+ @Override
+ public Object clone() {
+ return new BufferCapabilities(frontBufferCapabilities, backBufferCapabilities, flipContents);
+ }
+
+ /**
+ * Gets the image capabilities of the front buffer.
+ *
+ * @return the ImageCapabilities object represented capabilities
+ * of the front buffer.
+ */
+ public ImageCapabilities getFrontBufferCapabilities() {
+ return frontBufferCapabilities;
+ }
+
+ /**
+ * Gets the image capabilities of the back buffer.
+ *
+ * @return the ImageCapabilities object represented capabilities
+ * of the back buffer.
+ */
+ public ImageCapabilities getBackBufferCapabilities() {
+ return backBufferCapabilities;
+ }
+
+ /**
+ * Gets the flip contents of the back buffer after page-flipping.
+ *
+ * @return the FlipContents of the back buffer after page-flipping.
+ */
+ public FlipContents getFlipContents() {
+ return flipContents;
+ }
+
+ /**
+ * Checks if the buffer strategy uses page flipping.
+ *
+ * @return true, if the buffer strategy uses page flipping,
+ * false otherwise.
+ */
+ public boolean isPageFlipping() {
+ return flipContents != null;
+ }
+
+ /**
+ * Checks if page flipping is only available in full-screen mode.
+ *
+ * @return true, if page flipping is only available in full-screen mode,
+ * false otherwise.
+ */
+ public boolean isFullScreenRequired() {
+ return false;
+ }
+
+ /**
+ * Checks if page flipping can be performed using more than two buffers.
+ *
+ * @return true, if page flipping can be performed using more than two buffers,
+ * false otherwise.
+ */
+ public boolean isMultiBufferAvailable() {
+ return false;
+ }
+
+ /**
+ * The FlipContents class represents a set of possible back buffer contents
+ * after page-flipping.
+ */
+ public static final class FlipContents {
+
+ /**
+ * The back buffered contents are cleared with the background color
+ * after flipping.
+ */
+ public static final FlipContents BACKGROUND = new FlipContents();
+
+ /**
+ * The back buffered contents are copied to the front buffer before
+ * flipping.
+ */
+ public static final FlipContents COPIED = new FlipContents();
+
+ /**
+ * The back buffer contents are the prior contents of the
+ * front buffer.
+ */
+ public static final FlipContents PRIOR = new FlipContents();
+
+ /**
+ * The back buffer contents are undefined after flipping
+ */
+ public static final FlipContents UNDEFINED = new FlipContents();
+
+ /**
+ * Instantiates a new flip contents.
+ */
+ private FlipContents() {
+
+ }
+
+ /**
+ * Returns the hash code of the FlipContents object.
+ *
+ * @return the hash code of the FlipContents object.
+ */
+ @Override
+ public int hashCode() {
+ return super.hashCode();
+ }
+
+ /**
+ * Returns the String representation of the FlipContents object.
+ *
+ * @return the string
+ */
+ @Override
+ public String toString() {
+ return super.toString();
+ }
+ }
+}
diff --git a/awt/java/awt/Color.java b/awt/java/awt/Color.java
new file mode 100644
index 0000000..e1e4178
--- /dev/null
+++ b/awt/java/awt/Color.java
@@ -0,0 +1,881 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.color.ColorSpace;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.ColorModel;
+import java.awt.image.DataBufferInt;
+import java.awt.image.Raster;
+import java.awt.image.WritableRaster;
+import java.io.Serializable;
+import java.util.Arrays;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Color class defines colors in the default sRGB color
+ * space or in the specified ColorSpace. Every Color contains alpha value.
+ * The alpha value defines the transparency of a color and can be represented
+ * by a float value in the range 0.0 - 1.0 or 0 - 255.
+ */
+public class Color implements Paint, Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 118526816881161077L;
+
+ /*
+ * The values of the following colors are based on 1.5 release behavior which
+ * can be revealed using the following or similar code:
+ * Color c = Color.white;
+ * System.out.println(c);
+ */
+
+ /** The color white. */
+ public static final Color white = new Color(255, 255, 255);
+
+ /** The color white. */
+ public static final Color WHITE = white;
+
+ /** The color light gray. */
+ public static final Color lightGray = new Color(192, 192, 192);
+
+ /** The color light gray. */
+ public static final Color LIGHT_GRAY = lightGray;
+
+ /** The color gray. */
+ public static final Color gray = new Color(128, 128, 128);
+
+ /** The color gray. */
+ public static final Color GRAY = gray;
+
+ /** The color dark gray. */
+ public static final Color darkGray = new Color(64, 64, 64);
+
+ /** The color dark gray. */
+ public static final Color DARK_GRAY = darkGray;
+
+ /** The color black. */
+ public static final Color black = new Color(0, 0, 0);
+
+ /** The color black. */
+ public static final Color BLACK = black;
+
+ /** The color red. */
+ public static final Color red = new Color(255, 0, 0);
+
+ /** The color red. */
+ public static final Color RED = red;
+
+ /** The color pink. */
+ public static final Color pink = new Color(255, 175, 175);
+
+ /** The color pink. */
+ public static final Color PINK = pink;
+
+ /** The color orange. */
+ public static final Color orange = new Color(255, 200, 0);
+
+ /** The color orange. */
+ public static final Color ORANGE = orange;
+
+ /** The color yellow. */
+ public static final Color yellow = new Color(255, 255, 0);
+
+ /** The color yellow. */
+ public static final Color YELLOW = yellow;
+
+ /** The color green. */
+ public static final Color green = new Color(0, 255, 0);
+
+ /** The color green. */
+ public static final Color GREEN = green;
+
+ /** The color magenta. */
+ public static final Color magenta = new Color(255, 0, 255);
+
+ /** The color magenta. */
+ public static final Color MAGENTA = magenta;
+
+ /** The color cyan. */
+ public static final Color cyan = new Color(0, 255, 255);
+
+ /** The color cyan. */
+ public static final Color CYAN = cyan;
+
+ /** The color blue. */
+ public static final Color blue = new Color(0, 0, 255);
+
+ /** The color blue. */
+ public static final Color BLUE = blue;
+
+ /** integer RGB value. */
+ int value;
+
+ /** Float sRGB value. */
+ private float[] frgbvalue;
+
+ /** Color in an arbitrary color space with <code>float</code> components. If null, other value should be used. */
+ private float fvalue[];
+
+ /** Float alpha value. If frgbvalue is null, this is not valid data. */
+ private float falpha;
+
+ /** The color's color space if applicable. */
+ private ColorSpace cs;
+
+ /*
+ * The value of the SCALE_FACTOR is based on 1.5 release behavior which
+ * can be revealed using the following code:
+ * Color c = new Color(100, 100, 100);
+ * Color bc = c.brighter();
+ * System.out.println("Brighter factor: " + ((float)c.getRed())/((float)bc.getRed()));
+ * Color dc = c.darker();
+ * System.out.println("Darker factor: " + ((float)dc.getRed())/((float)c.getRed()));
+ * The result is the same for brighter and darker methods, so we need only
+ * one scale factor for both.
+ */
+ /** The Constant SCALE_FACTOR. */
+ private static final double SCALE_FACTOR = 0.7;
+
+ /** The Constant MIN_SCALABLE. */
+ private static final int MIN_SCALABLE = 3; // should increase when multiplied by SCALE_FACTOR
+
+ /** The current paint context. */
+ transient private PaintContext currentPaintContext;
+
+ /**
+ * Creates a color in the specified ColorSpace, the specified color
+ * components and the specified alpha.
+ *
+ * @param cspace the ColorSpace to be used to define the components.
+ * @param components the components.
+ * @param alpha the alpha.
+ */
+ public Color(ColorSpace cspace, float[] components, float alpha) {
+ int nComps = cspace.getNumComponents();
+ float comp;
+ fvalue = new float[nComps];
+
+ for(int i=0 ; i<nComps; i++) {
+ comp = components[i];
+ if(comp < 0.0f || comp > 1.0f) {
+ // awt.107=Color parameter outside of expected range: component {0}.
+ throw new IllegalArgumentException(
+ Messages.getString("awt.107", i)); //$NON-NLS-1$
+ }
+ fvalue[i] = components[i];
+ }
+
+ if (alpha < 0.0f || alpha > 1.0f) {
+ // awt.108=Alpha value outside of expected range.
+ throw new IllegalArgumentException(Messages.getString("awt.108")); //$NON-NLS-1$
+ }
+ falpha = alpha;
+
+ cs = cspace;
+
+ frgbvalue = cs.toRGB(fvalue);
+
+ value = ((int)(frgbvalue[2]*255 + 0.5)) |
+ (((int)(frgbvalue[1]*255 + 0.5)) << 8 ) |
+ (((int)(frgbvalue[0]*255 + 0.5)) << 16 ) |
+ (((int)(falpha*255 + 0.5)) << 24 );
+ }
+
+ /**
+ * Instantiates a new sRGB color with the specified combined
+ * RGBA value consisting of the alpha component in bits 24-31,
+ * the red component in bits 16-23, the green component in bits 8-15,
+ * and the blue component in bits 0-7. If the hasalpha argument is
+ * false, the alpha has default value - 255.
+ *
+ * @param rgba the RGBA components.
+ * @param hasAlpha alpha parameter is true if alpha bits are valid,
+ * false otherwise.
+ */
+ public Color(int rgba, boolean hasAlpha) {
+ if (!hasAlpha) {
+ value = rgba | 0xFF000000;
+ } else {
+ value = rgba;
+ }
+ }
+
+ /**
+ * Instantiates a new color with the specified red, green, blue and alpha
+ * components.
+ *
+ * @param r the red component.
+ * @param g the green component.
+ * @param b the blue component.
+ * @param a the alpha component.
+ */
+ public Color(int r, int g, int b, int a) {
+ if ((r & 0xFF) != r || (g & 0xFF) != g || (b & 0xFF) != b || (a & 0xFF) != a) {
+ // awt.109=Color parameter outside of expected range.
+ throw new IllegalArgumentException(Messages.getString("awt.109")); //$NON-NLS-1$
+ }
+ value = b | (g << 8) | (r << 16) | (a << 24);
+ }
+
+ /**
+ * Instantiates a new opaque sRGB color with the specified red, green,
+ * and blue values. The Alpha component is set to the default - 1.0.
+ *
+ * @param r the red component.
+ * @param g the green component.
+ * @param b the blue component.
+ */
+ public Color(int r, int g, int b) {
+ if ((r & 0xFF) != r || (g & 0xFF) != g || (b & 0xFF) != b) {
+ // awt.109=Color parameter outside of expected range.
+ throw new IllegalArgumentException(Messages.getString("awt.109")); //$NON-NLS-1$
+ }
+ // 0xFF for alpha channel
+ value = b | (g << 8) | (r << 16) | 0xFF000000;
+ }
+
+ /**
+ * Instantiates a new sRGB color with the specified
+ * RGB value consisting of the red component in bits 16-23,
+ * the green component in bits 8-15, and the blue component
+ * in bits 0-7. Alpha has default value - 255.
+ *
+ * @param rgb the RGB components.
+ */
+ public Color(int rgb) {
+ value = rgb | 0xFF000000;
+ }
+
+ /**
+ * Instantiates a new color with the specified red, green, blue and alpha
+ * components.
+ *
+ * @param r the red component.
+ * @param g the green component.
+ * @param b the blue component.
+ * @param a the alpha component.
+ */
+ public Color(float r, float g, float b, float a) {
+ this((int)(r*255+0.5),
+ (int)(g*255+0.5),
+ (int)(b*255+0.5),
+ (int)(a*255+0.5));
+ falpha = a;
+ fvalue = new float[3];
+ fvalue[0] = r;
+ fvalue[1] = g;
+ fvalue[2] = b;
+ frgbvalue = fvalue;
+ }
+
+ /**
+ * Instantiates a new color with the specified red, green, and blue
+ * components and default alfa value - 1.0.
+ *
+ * @param r the red component.
+ * @param g the green component.
+ * @param b the blue component.
+ */
+ public Color(float r, float g, float b) {
+ this(r, g, b, 1.0f);
+ }
+
+ public PaintContext createContext(
+ ColorModel cm,
+ Rectangle r,
+ Rectangle2D r2d,
+ AffineTransform xform,
+ RenderingHints rhs
+ ) {
+ if(currentPaintContext != null) {
+ return currentPaintContext;
+ }
+ currentPaintContext = new Color.ColorPaintContext(value);
+ return currentPaintContext;
+ }
+
+ /**
+ * Returns a string representation of the Color object.
+ *
+ * @return the string representation of the Color object.
+ */
+ @Override
+ public String toString() {
+ /*
+ The format of the string is based on 1.5 release behavior which
+ can be revealed using the following code:
+
+ Color c = new Color(1, 2, 3);
+ System.out.println(c);
+ */
+
+ return getClass().getName() +
+ "[r=" + getRed() + //$NON-NLS-1$
+ ",g=" + getGreen() + //$NON-NLS-1$
+ ",b=" + getBlue() + //$NON-NLS-1$
+ "]"; //$NON-NLS-1$
+ }
+
+ /**
+ * Compares the specified Object to the Color.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if the specified Object is a Color whose
+ * value is equal to this Color, false otherwise.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if(obj instanceof Color) {
+ return ((Color)obj).value == this.value;
+ }
+ return false;
+ }
+
+ /**
+ * Returns a float array containing the color and alpha components of
+ * the Color in the specified ColorSpace.
+ *
+ * @param colorSpace the specified ColorSpace.
+ * @param components the results of this method will be written to
+ * this float array. If null, a float array will be created.
+ *
+ * @return the color and alpha components in a float array.
+ */
+ public float[] getComponents(ColorSpace colorSpace, float[] components) {
+ int nComps = colorSpace.getNumComponents();
+ if(components == null) {
+ components = new float[nComps+1];
+ }
+
+ getColorComponents(colorSpace, components);
+
+ if(frgbvalue != null) {
+ components[nComps] = falpha;
+ } else {
+ components[nComps] = getAlpha()/255f;
+ }
+
+ return components;
+ }
+
+ /**
+ * Returns a float array containing the color components of
+ * the Color in the specified ColorSpace.
+ *
+ * @param colorSpace the specified ColorSpace.
+ * @param components the results of this method will be written to
+ * this float array. If null, a float array will be created.
+ *
+ * @return the color components in a float array.
+ */
+ public float[] getColorComponents(ColorSpace colorSpace, float[] components) {
+ float[] cieXYZComponents = getColorSpace().toCIEXYZ(getColorComponents(null));
+ float[] csComponents = colorSpace.fromCIEXYZ(cieXYZComponents);
+
+ if(components == null) {
+ return csComponents;
+ }
+
+ for(int i=0; i<csComponents.length; i++) {
+ components[i] = csComponents[i];
+ }
+
+ return components;
+ }
+
+ /**
+ * Gets the ColorSpace of this Color.
+ *
+ * @return the ColorSpace object.
+ */
+ public ColorSpace getColorSpace() {
+ if (cs == null) {
+ cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
+ }
+
+ return cs;
+ }
+
+ /**
+ * Creates a new Color which is a darker than this Color
+ * according to a fixed scale factor.
+ *
+ * @return the darker Color.
+ */
+ public Color darker() {
+ return new Color(
+ (int)(getRed()*SCALE_FACTOR),
+ (int)(getGreen()*SCALE_FACTOR),
+ (int)(getBlue()*SCALE_FACTOR));
+ }
+
+ /**
+ * Creates a new Color which is a brighter than this Color.
+ *
+ * @return the brighter Color.
+ */
+ public Color brighter() {
+
+ int r = getRed();
+ int b = getBlue();
+ int g = getGreen();
+
+ if(r == 0 && b == 0 && g == 0) {
+ return new Color(MIN_SCALABLE, MIN_SCALABLE, MIN_SCALABLE);
+ }
+
+ if(r < MIN_SCALABLE && r != 0) {
+ r = MIN_SCALABLE;
+ } else {
+ r = (int) (r/SCALE_FACTOR);
+ r = (r > 255) ? 255 : r;
+ }
+
+ if(b < MIN_SCALABLE && b != 0) {
+ b = MIN_SCALABLE;
+ } else {
+ b = (int) (b/SCALE_FACTOR);
+ b = (b > 255) ? 255 : b;
+ }
+
+ if(g < MIN_SCALABLE && g != 0) {
+ g = MIN_SCALABLE;
+ } else {
+ g = (int) (g/SCALE_FACTOR);
+ g = (g > 255) ? 255 : g;
+ }
+
+ return new Color(r, g, b);
+ }
+
+ /**
+ * Returns a float array containing the color and alpha components of
+ * the Color in the default sRGB color space.
+ *
+ * @param components the results of this method will be written to
+ * this float array. A new float array will be created if this
+ * argument is null.
+ *
+ * @return the RGB color and alpha components in a float array.
+ */
+ public float[] getRGBComponents(float[] components) {
+ if(components == null) {
+ components = new float[4];
+ }
+
+ if(frgbvalue != null) {
+ components[3] = falpha;
+ } else {
+ components[3] = getAlpha()/255f;
+ }
+
+ getRGBColorComponents(components);
+
+ return components;
+ }
+
+ /**
+ * Returns a float array containing the color components of
+ * the Color in the default sRGB color space.
+ *
+ * @param components the results of this method will be written to
+ * this float array. A new float array will be created if this
+ * argument is null.
+ *
+ * @return the RGB color components in a float array.
+ */
+ public float[] getRGBColorComponents(float[] components) {
+ if(components == null) {
+ components = new float[3];
+ }
+
+ if(frgbvalue != null) {
+ components[2] = frgbvalue[2];
+ components[1] = frgbvalue[1];
+ components[0] = frgbvalue[0];
+ } else {
+ components[2] = getBlue()/255f;
+ components[1] = getGreen()/255f;
+ components[0] = getRed()/255f;
+ }
+
+ return components;
+ }
+
+ /**
+ * Returns a float array which contains the color and alpha components of
+ * the Color in the ColorSpace of the Color.
+ *
+ * @param components the results of this method will be written to
+ * this float array. A new float array will be created if this
+ * argument is null.
+ *
+ * @return the color and alpha components in a float array.
+ */
+ public float[] getComponents(float[] components) {
+ if(fvalue == null) {
+ return getRGBComponents(components);
+ }
+
+ int nColorComps = fvalue.length;
+
+ if(components == null) {
+ components = new float[nColorComps+1];
+ }
+
+ getColorComponents(components);
+
+ components[nColorComps] = falpha;
+
+ return components;
+ }
+
+ /**
+ * Returns a float array which contains the color components of
+ * the Color in the ColorSpace of the Color.
+ *
+ * @param components the results of this method will be written to
+ * this float array. A new float array will be created if this
+ * argument is null.
+ *
+ * @return the color components in a float array.
+ */
+ public float[] getColorComponents(float[] components) {
+ if(fvalue == null) {
+ return getRGBColorComponents(components);
+ }
+
+ if(components == null) {
+ components = new float[fvalue.length];
+ }
+
+ for(int i=0; i<fvalue.length; i++) {
+ components[i] = fvalue[i];
+ }
+
+ return components;
+ }
+
+ /**
+ * Returns a hash code of this Color object.
+ *
+ * @return a hash code of this Color object.
+ */
+ @Override
+ public int hashCode() {
+ return value;
+ }
+
+ public int getTransparency() {
+ switch(getAlpha()) {
+ case 0xff:
+ return Transparency.OPAQUE;
+ case 0:
+ return Transparency.BITMASK;
+ default:
+ return Transparency.TRANSLUCENT;
+ }
+ }
+
+ /**
+ * Gets the red component of the Color in the range 0-255.
+ *
+ * @return the red component of the Color.
+ */
+ public int getRed() {
+ return (value >> 16) & 0xFF;
+ }
+
+ /**
+ * Gets the RGB value that represents the color in the default sRGB ColorModel.
+ *
+ * @return the RGB color value in the default sRGB ColorModel.
+ */
+ public int getRGB() {
+ return value;
+ }
+
+ /**
+ * Gets the green component of the Color in the range 0-255.
+ *
+ * @return the green component of the Color.
+ */
+ public int getGreen() {
+ return (value >> 8) & 0xFF;
+ }
+
+ /**
+ * Gets the blue component of the Color in the range 0-255.
+ *
+ * @return the blue component of the Color.
+ */
+ public int getBlue() {
+ return value & 0xFF;
+ }
+
+ /**
+ * Gets the alpha component of the Color in the range 0-255.
+ *
+ * @return the alpha component of the Color.
+ */
+ public int getAlpha() {
+ return (value >> 24) & 0xFF;
+ }
+
+ /**
+ * Gets the Color from the specified string, or returns the Color
+ * specified by the second parameter.
+ *
+ * @param nm the specified string.
+ * @param def the default Color.
+ *
+ * @return the color from the specified string, or the Color
+ * specified by the second parameter.
+ */
+ public static Color getColor(String nm, Color def) {
+ Integer integer = Integer.getInteger(nm);
+
+ if (integer == null) {
+ return def;
+ }
+
+ return new Color(integer.intValue());
+ }
+
+ /**
+ * Gets the Color from the specified string, or returns the Color converted
+ * from the second parameter.
+ *
+ * @param nm the specified string.
+ * @param def the default Color.
+ *
+ * @return the color from the specified string, or the Color
+ * converted from the second parameter.
+ */
+ public static Color getColor(String nm, int def) {
+ Integer integer = Integer.getInteger(nm);
+
+ if (integer == null) {
+ return new Color(def);
+ }
+
+ return new Color(integer.intValue());
+ }
+
+ /**
+ * Gets the Color from the specified String.
+ *
+ * @param nm the specified string.
+ *
+ * @return the Color object, or null.
+ */
+ public static Color getColor(String nm) {
+ Integer integer = Integer.getInteger(nm);
+
+ if (integer == null) {
+ return null;
+ }
+
+ return new Color(integer.intValue());
+ }
+
+ /**
+ * Decodes a String to an integer and returns the specified opaque Color.
+ *
+ * @param nm a String which represents an opaque color as a 24-bit integer.
+ *
+ * @throws NumberFormatException if the specified string can not be
+ * converted to an integer.
+ */
+ public static Color decode(String nm) throws NumberFormatException {
+ Integer integer = Integer.decode(nm);
+ return new Color(integer.intValue());
+ }
+
+ /**
+ * Gets a Color object using the specified values of the HSB color model.
+ *
+ * @param h the hue component of the Color.
+ * @param s the saturation of the Color.
+ * @param b the brightness of the Color.
+ *
+ * @return a color object with the specified hue, saturation and
+ * brightness values.
+ */
+ public static Color getHSBColor(float h, float s, float b) {
+ return new Color(HSBtoRGB(h, s, b));
+ }
+
+ /**
+ * Converts the Color specified by the RGB model to an equivalent
+ * color in the HSB model.
+ *
+ * @param r the red component.
+ * @param g the green component.
+ * @param b the blue component.
+ * @param hsbvals the array of result hue, saturation, brightness
+ * values or null.
+ *
+ * @return the float array of hue, saturation, brightness values.
+ */
+ public static float[] RGBtoHSB(int r, int g, int b, float[] hsbvals) {
+ if(hsbvals == null) {
+ hsbvals = new float[3];
+ }
+
+ int V = Math.max(b, Math.max(r, g));
+ int temp = Math.min(b, Math.min(r, g));
+
+ float H, S, B;
+
+ B = V/255.f;
+
+ if(V == temp) {
+ H = S = 0;
+ } else {
+ S = (V - temp)/((float)V);
+
+ float Cr = (V - r) / (float)(V - temp);
+ float Cg = (V - g) / (float)(V - temp);
+ float Cb = (V - b) / (float)(V - temp);
+
+ if (r == V) {
+ H = Cb - Cg;
+ } else if (g == V) {
+ H = 2 + Cr - Cb;
+ } else {
+ H = 4 + Cg - Cr;
+ }
+
+ H /= 6.f;
+ if(H < 0) {
+ H++;
+ }
+ }
+
+ hsbvals[0] = H;
+ hsbvals[1] = S;
+ hsbvals[2] = B;
+
+ return hsbvals;
+ }
+
+ /**
+ * Converts the Color specified by the HSB model to an equivalent
+ * color in the default RGB model.
+ *
+ * @param hue the hue component of the Color.
+ * @param saturation the saturation of the Color.
+ * @param brightness the brightness of the Color.
+ *
+ * @return the RGB value of the color with the specified hue,
+ * saturation and brightness.
+ */
+ public static int HSBtoRGB(float hue, float saturation, float brightness) {
+ float fr, fg, fb;
+
+ if(saturation == 0) {
+ fr = fg = fb = brightness;
+ } else {
+ float H = (hue - (float)Math.floor(hue)) * 6;
+ int I = (int) Math.floor(H);
+ float F = H - I;
+ float M = brightness * (1 - saturation);
+ float N = brightness * (1 - saturation * F);
+ float K = brightness * (1 - saturation * (1 - F));
+
+ switch(I) {
+ case 0:
+ fr = brightness; fg = K; fb = M; break;
+ case 1:
+ fr = N; fg = brightness; fb = M; break;
+ case 2:
+ fr = M; fg = brightness; fb = K; break;
+ case 3:
+ fr = M; fg = N; fb = brightness; break;
+ case 4:
+ fr = K; fg = M; fb = brightness; break;
+ case 5:
+ fr = brightness; fg = M; fb = N; break;
+ default:
+ fr = fb = fg = 0; // impossible, to supress compiler error
+ }
+ }
+
+ int r = (int) (fr * 255. + 0.5);
+ int g = (int) (fg * 255. + 0.5);
+ int b = (int) (fb * 255. + 0.5);
+
+ return (r << 16) | (g << 8) | b | 0xFF000000;
+ }
+
+ /**
+ * The Class ColorPaintContext.
+ */
+ class ColorPaintContext implements PaintContext {
+
+ /** The rgb value. */
+ int rgbValue;
+
+ /** The saved raster. */
+ WritableRaster savedRaster = null;
+
+ /**
+ * Instantiates a new color paint context.
+ *
+ * @param rgb the rgb
+ */
+ protected ColorPaintContext(int rgb) {
+ rgbValue = rgb;
+ }
+
+ public void dispose() {
+ savedRaster = null;
+ }
+
+ public ColorModel getColorModel() {
+ return ColorModel.getRGBdefault();
+ }
+
+ public Raster getRaster(int x, int y, int w, int h) {
+ if (savedRaster == null ||
+ w != savedRaster.getWidth() ||
+ h != savedRaster.getHeight()) {
+ savedRaster =
+ getColorModel().createCompatibleWritableRaster(w, h);
+
+ // Suppose we have here simple INT/RGB color/sample model
+ DataBufferInt intBuffer =
+ (DataBufferInt) savedRaster.getDataBuffer();
+ int rgbValues[] = intBuffer.getData();
+ int rgbFillValue = rgbValue;
+ Arrays.fill(rgbValues, rgbFillValue);
+ }
+
+ return savedRaster;
+ }
+ }
+}
+
diff --git a/awt/java/awt/Component.java b/awt/java/awt/Component.java
new file mode 100644
index 0000000..f19d285
--- /dev/null
+++ b/awt/java/awt/Component.java
@@ -0,0 +1,6408 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+//import java.awt.dnd.DropTarget;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ComponentListener;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import java.awt.event.HierarchyBoundsListener;
+import java.awt.event.HierarchyEvent;
+import java.awt.event.HierarchyListener;
+import java.awt.event.InputMethodEvent;
+import java.awt.event.InputMethodListener;
+import java.awt.event.InvocationEvent;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.event.MouseMotionListener;
+import java.awt.event.MouseWheelEvent;
+import java.awt.event.MouseWheelListener;
+import java.awt.event.PaintEvent;
+import java.awt.event.WindowEvent;
+import java.awt.im.InputContext;
+import java.awt.im.InputMethodRequests;
+import java.awt.image.BufferStrategy;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
+import java.awt.image.ImageObserver;
+import java.awt.image.ImageProducer;
+import java.awt.image.VolatileImage;
+import java.awt.image.WritableRaster;
+import java.awt.peer.ComponentPeer;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.Serializable;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EventListener;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+//???AWT
+//import javax.accessibility.Accessible;
+//import javax.accessibility.AccessibleComponent;
+//import javax.accessibility.AccessibleContext;
+//import javax.accessibility.AccessibleRole;
+//import javax.accessibility.AccessibleState;
+//import javax.accessibility.AccessibleStateSet;
+
+import org.apache.harmony.awt.ClipRegion;
+//import org.apache.harmony.awt.FieldsAccessor;
+import org.apache.harmony.awt.gl.MultiRectArea;
+import org.apache.harmony.awt.internal.nls.Messages;
+import org.apache.harmony.awt.state.State;
+//import org.apache.harmony.awt.text.TextFieldKit;
+//import org.apache.harmony.awt.text.TextKit;
+import org.apache.harmony.awt.wtk.NativeWindow;
+
+/**
+ * The abstract Component class specifies an object with a graphical
+ * representation that can be displayed on the screen and that can
+ * interact with the user (for example: scrollbars, buttons, checkboxes).
+ */
+public abstract class Component implements ImageObserver, MenuContainer, Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -7644114512714619750L;
+
+ /** The Constant TOP_ALIGNMENT indicates the top alignment of the component. */
+ public static final float TOP_ALIGNMENT = 0.0f;
+
+ /** The Constant CENTER_ALIGNMENT indicates the center alignment of the component. */
+ public static final float CENTER_ALIGNMENT = 0.5f;
+
+ /** The Constant BOTTOM_ALIGNMENT indicates the bottom alignment of the component. */
+ public static final float BOTTOM_ALIGNMENT = 1.0f;
+
+ /** The Constant LEFT_ALIGNMENT indicates the left alignment of the component. */
+ public static final float LEFT_ALIGNMENT = 0.0f;
+
+ /** The Constant RIGHT_ALIGNMENT indicates the right alignment of the component. */
+ public static final float RIGHT_ALIGNMENT = 1.0f;
+
+ /** The Constant childClassesFlags. */
+ private static final Hashtable<Class<?>, Boolean> childClassesFlags = new Hashtable<Class<?>, Boolean>();
+
+ /** The Constant peer. */
+ private static final ComponentPeer peer = new ComponentPeer() {
+ };
+
+ /** The Constant incrementalImageUpdate. */
+ private static final boolean incrementalImageUpdate;
+
+ /** The toolkit. */
+ final transient Toolkit toolkit = Toolkit.getDefaultToolkit();
+
+ //???AWT
+ /*
+ protected abstract class AccessibleAWTComponent extends AccessibleContext implements
+ Serializable, AccessibleComponent {
+ private static final long serialVersionUID = 642321655757800191L;
+
+ protected class AccessibleAWTComponentHandler implements ComponentListener {
+ protected AccessibleAWTComponentHandler() {
+ }
+
+ public void componentHidden(ComponentEvent e) {
+ if (behaviour.isLightweight()) {
+ return;
+ }
+ firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+ AccessibleState.VISIBLE, null);
+ }
+
+ public void componentMoved(ComponentEvent e) {
+ }
+
+ public void componentResized(ComponentEvent e) {
+ }
+
+ public void componentShown(ComponentEvent e) {
+ if (behaviour.isLightweight()) {
+ return;
+ }
+ firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY, null,
+ AccessibleState.VISIBLE);
+ }
+ }
+
+ protected class AccessibleAWTFocusHandler implements FocusListener {
+ public void focusGained(FocusEvent e) {
+ if (behaviour.isLightweight()) {
+ return;
+ }
+ firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY, null,
+ AccessibleState.FOCUSED);
+ }
+
+ public void focusLost(FocusEvent e) {
+ if (behaviour.isLightweight()) {
+ return;
+ }
+ firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+ AccessibleState.FOCUSED, null);
+ }
+ }
+
+ protected ComponentListener accessibleAWTComponentHandler;
+
+ protected FocusListener accessibleAWTFocusHandler;
+ */
+ /*
+ * Number of registered property change listeners.
+ */
+ /*
+ int listenersCount;
+
+ public void addFocusListener(FocusListener l) {
+ Component.this.addFocusListener(l);
+ }
+
+ @Override
+ public void addPropertyChangeListener(PropertyChangeListener listener) {
+ toolkit.lockAWT();
+ try {
+ super.addPropertyChangeListener(listener);
+ listenersCount++;
+ if (accessibleAWTComponentHandler == null) {
+ accessibleAWTComponentHandler = new AccessibleAWTComponentHandler();
+ Component.this.addComponentListener(accessibleAWTComponentHandler);
+ }
+ if (accessibleAWTFocusHandler == null) {
+ accessibleAWTFocusHandler = new AccessibleAWTFocusHandler();
+ Component.this.addFocusListener(accessibleAWTFocusHandler);
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public boolean contains(Point p) {
+ toolkit.lockAWT();
+ try {
+ return Component.this.contains(p);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Accessible getAccessibleAt(Point arg0) {
+ toolkit.lockAWT();
+ try {
+ return null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Color getBackground() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getBackground();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Rectangle getBounds() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getBounds();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Cursor getCursor() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getCursor();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Font getFont() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getFont();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public FontMetrics getFontMetrics(Font f) {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getFontMetrics(f);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Color getForeground() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getForeground();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Point getLocation() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getLocation();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Point getLocationOnScreen() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getLocationOnScreen();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Dimension getSize() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getSize();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public boolean isEnabled() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.isEnabled();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public boolean isFocusTraversable() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.isFocusTraversable();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public boolean isShowing() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.isShowing();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public boolean isVisible() {
+ toolkit.lockAWT();
+ try {
+ return Component.this.isVisible();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void removeFocusListener(FocusListener l) {
+ Component.this.removeFocusListener(l);
+ }
+
+ @Override
+ public void removePropertyChangeListener(PropertyChangeListener listener) {
+ toolkit.lockAWT();
+ try {
+ super.removePropertyChangeListener(listener);
+ listenersCount--;
+ if (listenersCount > 0) {
+ return;
+ }
+ // if there are no more listeners, remove handlers:
+ Component.this.removeFocusListener(accessibleAWTFocusHandler);
+ Component.this.removeComponentListener(accessibleAWTComponentHandler);
+ accessibleAWTComponentHandler = null;
+ accessibleAWTFocusHandler = null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void requestFocus() {
+ toolkit.lockAWT();
+ try {
+ Component.this.requestFocus();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void setBackground(Color color) {
+ toolkit.lockAWT();
+ try {
+ Component.this.setBackground(color);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void setBounds(Rectangle r) {
+ toolkit.lockAWT();
+ try {
+ Component.this.setBounds(r);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void setCursor(Cursor cursor) {
+ toolkit.lockAWT();
+ try {
+ Component.this.setCursor(cursor);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void setEnabled(boolean enabled) {
+ toolkit.lockAWT();
+ try {
+ Component.this.setEnabled(enabled);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void setFont(Font f) {
+ toolkit.lockAWT();
+ try {
+ Component.this.setFont(f);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void setForeground(Color color) {
+ toolkit.lockAWT();
+ try {
+ Component.this.setForeground(color);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void setLocation(Point p) {
+ toolkit.lockAWT();
+ try {
+ Component.this.setLocation(p);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void setSize(Dimension size) {
+ toolkit.lockAWT();
+ try {
+ Component.this.setSize(size);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void setVisible(boolean visible) {
+ toolkit.lockAWT();
+ try {
+ Component.this.setVisible(visible);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Override
+ public Accessible getAccessibleParent() {
+ toolkit.lockAWT();
+ try {
+ Accessible aParent = super.getAccessibleParent();
+ if (aParent != null) {
+ return aParent;
+ }
+ Container parent = getParent();
+ return (parent instanceof Accessible ? (Accessible) parent : null);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Override
+ public Accessible getAccessibleChild(int i) {
+ toolkit.lockAWT();
+ try {
+ return null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Override
+ public int getAccessibleChildrenCount() {
+ toolkit.lockAWT();
+ try {
+ return 0;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Override
+ public AccessibleComponent getAccessibleComponent() {
+ return this;
+ }
+
+ @Override
+ public String getAccessibleDescription() {
+ return super.getAccessibleDescription(); // why override?
+ }
+
+ @Override
+ public int getAccessibleIndexInParent() {
+ toolkit.lockAWT();
+ try {
+ if (getAccessibleParent() == null) {
+ return -1;
+ }
+ int count = 0;
+ Container parent = getParent();
+ for (int i = 0; i < parent.getComponentCount(); i++) {
+ Component aComp = parent.getComponent(i);
+ if (aComp instanceof Accessible) {
+ if (aComp == Component.this) {
+ return count;
+ }
+ ++count;
+ }
+ }
+ return -1;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Override
+ public AccessibleRole getAccessibleRole() {
+ toolkit.lockAWT();
+ try {
+ return AccessibleRole.AWT_COMPONENT;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Override
+ public AccessibleStateSet getAccessibleStateSet() {
+ toolkit.lockAWT();
+ try {
+ AccessibleStateSet set = new AccessibleStateSet();
+ if (isEnabled()) {
+ set.add(AccessibleState.ENABLED);
+ }
+ if (isFocusable()) {
+ set.add(AccessibleState.FOCUSABLE);
+ }
+ if (hasFocus()) {
+ set.add(AccessibleState.FOCUSED);
+ }
+ if (isOpaque()) {
+ set.add(AccessibleState.OPAQUE);
+ }
+ if (isShowing()) {
+ set.add(AccessibleState.SHOWING);
+ }
+ if (isVisible()) {
+ set.add(AccessibleState.VISIBLE);
+ }
+ return set;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Override
+ public Locale getLocale() throws IllegalComponentStateException {
+ toolkit.lockAWT();
+ try {
+ return Component.this.getLocale();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ }
+ */
+ /**
+ * The BltBufferStrategy class provides opportunity of blitting
+ * offscreen surfaces to a component. For more information on
+ * blitting, see <a href="http://en.wikipedia.org/wiki/Bit_blit">Bit blit</a>.
+ */
+ protected class BltBufferStrategy extends BufferStrategy {
+
+ /** The back buffers. */
+ protected VolatileImage[] backBuffers;
+
+ /** The caps. */
+ protected BufferCapabilities caps;
+
+ /** The width. */
+ protected int width;
+
+ /** The height. */
+ protected int height;
+
+ /** The validated contents. */
+ protected boolean validatedContents;
+
+ /**
+ * Instantiates a new BltBufferStrategy buffer strategy.
+ *
+ * @param numBuffers the number of buffers.
+ * @param caps the BufferCapabilities.
+ *
+ * @throws NotImplementedException the not implemented exception.
+ */
+ protected BltBufferStrategy(int numBuffers, BufferCapabilities caps) throws org.apache.harmony.luni.util.NotImplementedException {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Returns true if the drawing buffer has been lost since the last call
+ * to getDrawGraphics.
+ *
+ * @return true if the drawing buffer has been lost since the last call
+ * to getDrawGraphics, false otherwise.
+ *
+ * @see java.awt.image.BufferStrategy#contentsLost()
+ */
+ @Override
+ public boolean contentsLost() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ return false;
+ }
+
+ /**
+ * Returns true if the drawing buffer has been restored from a lost
+ * state and reinitialized to the default background color.
+ *
+ * @return true if the drawing buffer has been restored from a lost
+ * state and reinitialized to the default background color,
+ * false otherwise.
+ *
+ * @see java.awt.image.BufferStrategy#contentsRestored()
+ */
+ @Override
+ public boolean contentsRestored() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ return false;
+ }
+
+ /**
+ * Creates the back buffers.
+ *
+ * @param numBuffers the number of buffers.
+ */
+ protected void createBackBuffers(int numBuffers) {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Returns the BufferCapabilities of the buffer strategy.
+ *
+ * @return the BufferCapabilities.
+ *
+ * @see java.awt.image.BufferStrategy#getCapabilities()
+ */
+ @Override
+ public BufferCapabilities getCapabilities() {
+ return (BufferCapabilities) caps.clone();
+ }
+
+ /**
+ * Gets Graphics of current buffer strategy.
+ *
+ * @return the Graphics of current buffer strategy.
+ *
+ * @see java.awt.image.BufferStrategy#getDrawGraphics()
+ */
+ @Override
+ public Graphics getDrawGraphics() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ return null;
+ }
+
+ /**
+ * Revalidates the lost drawing buffer.
+ */
+ protected void revalidate() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Shows the next available buffer.
+ *
+ * @see java.awt.image.BufferStrategy#show()
+ */
+ @Override
+ public void show() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ }
+ }
+
+ /**
+ * The FlipBufferStrategy class is for flipping buffers on a component.
+ */
+ protected class FlipBufferStrategy extends BufferStrategy {
+
+ /** The Buffer Capabilities. */
+ protected BufferCapabilities caps;
+
+ /** The drawing buffer. */
+ protected Image drawBuffer;
+
+ /** The drawing VolatileImage buffer. */
+ protected VolatileImage drawVBuffer;
+
+ /** The number of buffers. */
+ protected int numBuffers;
+
+ /** The validated contents indicates if the drawing buffer is restored from
+ * lost state. */
+ protected boolean validatedContents;
+
+ /**
+ * Instantiates a new flip buffer strategy.
+ *
+ * @param numBuffers the number of buffers.
+ * @param caps the BufferCapabilities.
+ *
+ * @throws AWTException if the capabilities supplied could not
+ * be supported or met.
+ */
+ protected FlipBufferStrategy(int numBuffers, BufferCapabilities caps)
+ throws AWTException {
+ //???AWT
+ /*
+ if (!(Component.this instanceof Window) && !(Component.this instanceof Canvas)) {
+ // awt.14B=Only Canvas or Window is allowed
+ throw new ClassCastException(Messages.getString("awt.14B")); //$NON-NLS-1$
+ }
+ */
+ // TODO: throw new AWTException("Capabilities are not supported");
+ this.numBuffers = numBuffers;
+ this.caps = (BufferCapabilities) caps.clone();
+ }
+
+ /**
+ * Returns true if the drawing buffer has been lost since the last call
+ * to getDrawGraphics.
+ *
+ * @return true if the drawing buffer has been lost since the last call
+ * to getDrawGraphics, false otherwise.
+ *
+ * @see java.awt.image.BufferStrategy#contentsLost()
+ */
+ @Override
+ public boolean contentsLost() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ return false;
+ }
+
+ /**
+ * Returns true if the drawing buffer has been restored from a lost
+ * state and reinitialized to the default background color.
+ *
+ * @return true if the drawing buffer has been restored from a lost
+ * state and reinitialized to the default background color,
+ * false otherwise.
+ *
+ * @see java.awt.image.BufferStrategy#contentsRestored()
+ */
+ @Override
+ public boolean contentsRestored() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ return false;
+ }
+
+ /**
+ * Creates flipping buffers with the specified buffer capabilities.
+ *
+ * @param numBuffers the number of buffers.
+ * @param caps the BufferCapabilities.
+ *
+ * @throws AWTException if the capabilities could not be
+ * supported or met.
+ */
+ protected void createBuffers(int numBuffers, BufferCapabilities caps)
+ throws AWTException {
+ if (numBuffers < 2) {
+ // awt.14C=Number of buffers must be greater than one
+ throw new IllegalArgumentException(Messages.getString("awt.14C")); //$NON-NLS-1$
+ }
+ if (!caps.isPageFlipping()) {
+ // awt.14D=Buffer capabilities should support flipping
+ throw new IllegalArgumentException(Messages.getString("awt.14D")); //$NON-NLS-1$
+ }
+ if (!Component.this.behaviour.isDisplayable()) {
+ // awt.14E=Component should be displayable
+ throw new IllegalStateException(Messages.getString("awt.14E")); //$NON-NLS-1$
+ }
+ // TODO: throw new AWTException("Capabilities are not supported");
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Destroy buffers.
+ */
+ protected void destroyBuffers() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Flips the contents of the back buffer to the front buffer.
+ *
+ * @param flipAction the flip action.
+ */
+ protected void flip(BufferCapabilities.FlipContents flipAction) {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Gets the back buffer as Image.
+ *
+ * @return the back buffer as Image.
+ */
+ protected Image getBackBuffer() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ return null;
+ }
+
+ /**
+ * Returns the BufferCapabilities of the buffer strategy.
+ *
+ * @return the BufferCapabilities.
+ *
+ * @see java.awt.image.BufferStrategy#getCapabilities()
+ */
+ @Override
+ public BufferCapabilities getCapabilities() {
+ return (BufferCapabilities) caps.clone();
+ }
+
+ /**
+ * Gets Graphics of current buffer strategy.
+ *
+ * @return the Graphics of current buffer strategy.
+ *
+ * @see java.awt.image.BufferStrategy#getDrawGraphics()
+ */
+ @Override
+ public Graphics getDrawGraphics() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ return null;
+ }
+
+ /**
+ * Revalidates the lost drawing buffer.
+ */
+ protected void revalidate() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Shows the next available buffer.
+ *
+ * @see java.awt.image.BufferStrategy#show()
+ */
+ @Override
+ public void show() {
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
+ }
+ }
+ }
+
+ /**
+ * The internal component's state utilized by the visual theme.
+ */
+ class ComponentState implements State {
+
+ /** The default minimum size. */
+ private Dimension defaultMinimumSize = new Dimension();
+
+ /**
+ * Checks if the component is enabled.
+ *
+ * @return true, if the component is enabled
+ */
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ /**
+ * Checks if the component is visible.
+ *
+ * @return true, if the component is visible
+ */
+ public boolean isVisible() {
+ return visible;
+ }
+
+ /**
+ * Checks if is focused.
+ *
+ * @return true, if is focused
+ */
+ public boolean isFocused() {
+ //???AWT: return isFocusOwner();
+ return false;
+ }
+
+ /**
+ * Gets the font.
+ *
+ * @return the font
+ */
+ public Font getFont() {
+ return Component.this.getFont();
+ }
+
+ /**
+ * Checks if the font has been set.
+ *
+ * @return true, if the font has been set
+ */
+ public boolean isFontSet() {
+ return font != null;
+ }
+
+ /**
+ * Gets the background color.
+ *
+ * @return the background color
+ */
+ public Color getBackground() {
+ Color c = Component.this.getBackground();
+ return (c != null) ? c : getDefaultBackground();
+ }
+
+ /**
+ * Checks if the background is set.
+ *
+ * @return true, if the background is set
+ */
+ public boolean isBackgroundSet() {
+ return backColor != null;
+ }
+
+ /**
+ * Gets the text color.
+ *
+ * @return the text color
+ */
+ public Color getTextColor() {
+ Color c = getForeground();
+ return (c != null) ? c : getDefaultForeground();
+ }
+
+ /**
+ * Checks if the text color is set.
+ *
+ * @return true, if the text color is set
+ */
+ public boolean isTextColorSet() {
+ return foreColor != null;
+ }
+
+ /**
+ * Gets the font metrics.
+ *
+ * @return the font metrics
+ */
+ @SuppressWarnings("deprecation")
+ public FontMetrics getFontMetrics() {
+ return toolkit.getFontMetrics(Component.this.getFont());
+ }
+
+ /**
+ * Gets the bounding rectangle.
+ *
+ * @return the bounding rectangle
+ */
+ public Rectangle getBounds() {
+ return new Rectangle(x, y, w, h);
+ }
+
+ /**
+ * Gets the size of the bounding rectangle.
+ *
+ * @return the size of the bounding rectangle
+ */
+ public Dimension getSize() {
+ return new Dimension(w, h);
+ }
+
+ /**
+ * Gets the window id.
+ *
+ * @return the window id
+ */
+ public long getWindowId() {
+ NativeWindow win = getNativeWindow();
+ return (win != null) ? win.getId() : 0;
+ }
+
+ /**
+ * Gets the default minimum size.
+ *
+ * @return the default minimum size
+ */
+ public Dimension getDefaultMinimumSize() {
+ if (defaultMinimumSize == null) {
+ calculate();
+ }
+ return defaultMinimumSize;
+ }
+
+ /**
+ * Sets the default minimum size.
+ *
+ * @param size the new default minimum size
+ */
+ public void setDefaultMinimumSize(Dimension size) {
+ defaultMinimumSize = size;
+ }
+
+ /**
+ * Reset the default minimum size to null.
+ */
+ public void reset() {
+ defaultMinimumSize = null;
+ }
+
+ /**
+ * Calculate the default minimum size: to be overridden.
+ */
+ public void calculate() {
+ // to be overridden
+ }
+ }
+
+ //???AWT: private transient AccessibleContext accessibleContext;
+
+ /** The behaviour. */
+ final transient ComponentBehavior behaviour;
+
+ //???AWT: Container parent;
+
+ /** The name. */
+ private String name;
+
+ /** The auto name. */
+ private boolean autoName = true;
+
+ /** The font. */
+ private Font font;
+
+ /** The back color. */
+ private Color backColor;
+
+ /** The fore color. */
+ private Color foreColor;
+
+ /** The deprecated event handler. */
+ boolean deprecatedEventHandler = true;
+
+ /** The enabled events. */
+ private long enabledEvents;
+
+ /** The enabled awt events. */
+ private long enabledAWTEvents;
+
+ /** The component listeners. */
+ private final AWTListenerList<ComponentListener> componentListeners = new AWTListenerList<ComponentListener>(
+ this);
+
+ /** The focus listeners. */
+ private final AWTListenerList<FocusListener> focusListeners = new AWTListenerList<FocusListener>(
+ this);
+
+ /** The hierarchy listeners. */
+ private final AWTListenerList<HierarchyListener> hierarchyListeners = new AWTListenerList<HierarchyListener>(
+ this);
+
+ /** The hierarchy bounds listeners. */
+ private final AWTListenerList<HierarchyBoundsListener> hierarchyBoundsListeners = new AWTListenerList<HierarchyBoundsListener>(
+ this);
+
+ /** The key listeners. */
+ private final AWTListenerList<KeyListener> keyListeners = new AWTListenerList<KeyListener>(
+ this);
+
+ /** The mouse listeners. */
+ private final AWTListenerList<MouseListener> mouseListeners = new AWTListenerList<MouseListener>(
+ this);
+
+ /** The mouse motion listeners. */
+ private final AWTListenerList<MouseMotionListener> mouseMotionListeners = new AWTListenerList<MouseMotionListener>(
+ this);
+
+ /** The mouse wheel listeners. */
+ private final AWTListenerList<MouseWheelListener> mouseWheelListeners = new AWTListenerList<MouseWheelListener>(
+ this);
+
+ /** The input method listeners. */
+ private final AWTListenerList<InputMethodListener> inputMethodListeners = new AWTListenerList<InputMethodListener>(
+ this);
+
+ /** The x. */
+ int x;
+
+ /** The y. */
+ int y;
+
+ /** The w. */
+ int w;
+
+ /** The h. */
+ int h;
+
+ /** The maximum size. */
+ private Dimension maximumSize;
+
+ /** The minimum size. */
+ private Dimension minimumSize;
+
+ /** The preferred size. */
+ private Dimension preferredSize;
+
+ /** The bounds mask param. */
+ private int boundsMaskParam;
+
+ /** The ignore repaint. */
+ private boolean ignoreRepaint;
+
+ /** The enabled. */
+ private boolean enabled = true;
+
+ /** The input methods enabled. */
+ private boolean inputMethodsEnabled = true;
+
+ /** The dispatch to im. */
+ transient boolean dispatchToIM = true;
+
+ /** The focusable. */
+ private boolean focusable = true; // By default, all Components return
+
+ // true from isFocusable() method
+ /** The visible. */
+ boolean visible = true;
+
+ /** The called set focusable. */
+ private boolean calledSetFocusable;
+
+ /** The overriden is focusable. */
+ private boolean overridenIsFocusable = true;
+
+ /** The focus traversal keys enabled. */
+ private boolean focusTraversalKeysEnabled = true;
+
+ /** Possible keys are: FORWARD_TRAVERSAL_KEYS, BACKWARD_TRAVERSAL_KEYS, UP_CYCLE_TRAVERSAL_KEYS. */
+ private final Map<Integer, Set<? extends AWTKeyStroke>> traversalKeys = new HashMap<Integer, Set<? extends AWTKeyStroke>>();
+
+ /** The traversal i ds. */
+ int[] traversalIDs;
+
+ /** The locale. */
+ private Locale locale;
+
+ /** The orientation. */
+ private ComponentOrientation orientation;
+
+ /** The property change support. */
+ private PropertyChangeSupport propertyChangeSupport;
+
+ //???AWT: private ArrayList<PopupMenu> popups;
+
+ /** The coalescer. */
+ private boolean coalescer;
+
+ /** The events table. */
+ private Hashtable<Integer, LinkedList<AWTEvent>> eventsTable;
+
+ /** Cashed reference used during EventQueue.postEvent() */
+ private LinkedList<AWTEvent> eventsList;
+
+ /** The hierarchy changing counter. */
+ private int hierarchyChangingCounter;
+
+ /** The was showing. */
+ private boolean wasShowing;
+
+ /** The was displayable. */
+ private boolean wasDisplayable;
+
+ /** The cursor. */
+ Cursor cursor;
+
+ //???AWT: DropTarget dropTarget;
+
+ /** The mouse exited expected. */
+ private boolean mouseExitedExpected;
+
+ /** The repaint region. */
+ transient MultiRectArea repaintRegion;
+
+ //???AWT: transient RedrawManager redrawManager;
+ /** The redraw manager. */
+ transient Object redrawManager;
+
+ /** The valid. */
+ private boolean valid;
+
+ /** The updated images. */
+ private HashMap<Image, ImageParameters> updatedImages;
+
+ /**
+ * The lock object for private component's data which don't affect the
+ * component hierarchy.
+ */
+ private class ComponentLock {
+ }
+
+ /** The component lock. */
+ private final transient Object componentLock = new ComponentLock();
+ static {
+ PrivilegedAction<String[]> action = new PrivilegedAction<String[]>() {
+ public String[] run() {
+ String properties[] = new String[2];
+ properties[0] = System.getProperty("awt.image.redrawrate", "100"); //$NON-NLS-1$ //$NON-NLS-2$
+ properties[1] = System.getProperty("awt.image.incrementaldraw", "true"); //$NON-NLS-1$ //$NON-NLS-2$
+ return properties;
+ }
+ };
+ String properties[] = AccessController.doPrivileged(action);
+ // FIXME: rate is never used, can this code and the get property above
+ // be removed?
+ // int rate;
+ //
+ // try {
+ // rate = Integer.decode(properties[0]).intValue();
+ // } catch (NumberFormatException e) {
+ // rate = 100;
+ // }
+ incrementalImageUpdate = properties[1].equals("true"); //$NON-NLS-1$
+ }
+
+ /**
+ * Instantiates a new component.
+ */
+ protected Component() {
+ toolkit.lockAWT();
+ try {
+ orientation = ComponentOrientation.UNKNOWN;
+ redrawManager = null;
+ //???AWT
+ /*
+ traversalIDs = this instanceof Container ? KeyboardFocusManager.contTraversalIDs
+ : KeyboardFocusManager.compTraversalIDs;
+ for (int element : traversalIDs) {
+ traversalKeys.put(new Integer(element), null);
+ }
+ behaviour = createBehavior();
+ */
+ behaviour = null;
+
+ deriveCoalescerFlag();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Determine that the class inherited from Component declares the method
+ * coalesceEvents(), and put the results to the childClassesFlags map.
+ */
+ private void deriveCoalescerFlag() {
+ Class<?> thisClass = getClass();
+ boolean flag = true;
+ synchronized (childClassesFlags) {
+ Boolean flagWrapper = childClassesFlags.get(thisClass);
+ if (flagWrapper == null) {
+ Method coalesceMethod = null;
+ for (Class<?> c = thisClass; c != Component.class; c = c.getSuperclass()) {
+ try {
+ coalesceMethod = c.getDeclaredMethod("coalesceEvents", new Class[] { //$NON-NLS-1$
+ Class.forName("java.awt.AWTEvent"), //$NON-NLS-1$
+ Class.forName("java.awt.AWTEvent") }); //$NON-NLS-1$
+ } catch (Exception e) {
+ }
+ if (coalesceMethod != null) {
+ break;
+ }
+ }
+ flag = (coalesceMethod != null);
+ childClassesFlags.put(thisClass, Boolean.valueOf(flag));
+ } else {
+ flag = flagWrapper.booleanValue();
+ }
+ }
+ coalescer = flag;
+ if (flag) {
+ eventsTable = new Hashtable<Integer, LinkedList<AWTEvent>>();
+ } else {
+ eventsTable = null;
+ }
+ }
+
+ /**
+ * Sets the name of the Component.
+ *
+ * @param name the new name of the Component.
+ */
+ public void setName(String name) {
+ String oldName;
+ toolkit.lockAWT();
+ try {
+ autoName = false;
+ oldName = this.name;
+ this.name = name;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("name", oldName, name); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the name of this Component.
+ *
+ * @return the name of this Component.
+ */
+ public String getName() {
+ toolkit.lockAWT();
+ try {
+ if ((name == null) && autoName) {
+ name = autoName();
+ }
+ return name;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Auto name.
+ *
+ * @return the string
+ */
+ String autoName() {
+ String name = getClass().getName();
+ if (name.indexOf("$") != -1) { //$NON-NLS-1$
+ return null;
+ }
+ //???AWT
+ //int number = toolkit.autoNumber.nextComponent++;
+ int number = 0;
+ name = name.substring(name.lastIndexOf(".") + 1) + Integer.toString(number); //$NON-NLS-1$
+ return name;
+ }
+
+ /**
+ * Returns the string representation of the Component.
+ *
+ * @return the string representation of the Component.
+ */
+ @Override
+ public String toString() {
+ /*
+ * The format is based on 1.5 release behavior which can be revealed by
+ * the following code:
+ *
+ * Component c = new Component(){}; c.setVisible(false);
+ * System.out.println(c);
+ */
+ toolkit.lockAWT();
+ try {
+ return getClass().getName() + "[" + paramString() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ //???AWT
+ /*
+ public void add(PopupMenu popup) {
+ toolkit.lockAWT();
+ try {
+ if (popup.getParent() == this) {
+ return;
+ }
+ if (popups == null) {
+ popups = new ArrayList<PopupMenu>();
+ }
+ popup.setParent(this);
+ popups.add(popup);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Returns true, if the component contains the specified Point.
+ *
+ * @param p the Point.
+ *
+ * @return true, if the component contains the specified Point,
+ * false otherwise.
+ */
+ public boolean contains(Point p) {
+ toolkit.lockAWT();
+ try {
+ return contains(p.x, p.y);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Returns true, if the component contains the point with
+ * the specified coordinates.
+ *
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ *
+ * @return true, if the component contains the point with
+ * the specified coordinates, false otherwise.
+ */
+ public boolean contains(int x, int y) {
+ toolkit.lockAWT();
+ try {
+ return inside(x, y);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by replaced by getSize() method.
+ *
+ * @return the dimension.
+ *
+ * @deprecated Replaced by getSize() method.
+ */
+ @Deprecated
+ public Dimension size() {
+ toolkit.lockAWT();
+ try {
+ return new Dimension(w, h);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ //???AWT
+ /*
+ public Container getParent() {
+ toolkit.lockAWT();
+ try {
+ return parent;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * List.
+ *
+ * @param out the out
+ * @param indent the indent
+ *
+ * @return the nearest heavyweight ancestor in hierarchy or
+ * <code>null</code> if not found
+ */
+ //???AWT
+ /*
+ Component getHWAncestor() {
+ return (parent != null ? parent.getHWSurface() : null);
+ }
+ */
+
+ /**
+ * @return heavyweight component that is equal to or is a nearest
+ * heavyweight container of the current component, or
+ * <code>null</code> if not found
+ */
+ //???AWT
+ /*
+ Component getHWSurface() {
+ Component parent;
+ for (parent = this; (parent != null) && (parent.isLightweight()); parent = parent
+ .getParent()) {
+ ;
+ }
+ return parent;
+ }
+
+ Window getWindowAncestor() {
+ Component par;
+ for (par = this; par != null && !(par instanceof Window); par = par.getParent()) {
+ ;
+ }
+ return (Window) par;
+ }
+ */
+
+ /** To be called by container */
+ //???AWT
+ /*
+ void setParent(Container parent) {
+ this.parent = parent;
+ setRedrawManager();
+ }
+
+ void setRedrawManager() {
+ redrawManager = getRedrawManager();
+ }
+
+ public void remove(MenuComponent menu) {
+ toolkit.lockAWT();
+ try {
+ if (menu.getParent() == this) {
+ menu.setParent(null);
+ popups.remove(menu);
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+ /**
+ * Prints a list of this component with the specified number of
+ * leading whitespace characters to the specified PrintStream.
+ *
+ * @param out the output PrintStream object.
+ * @param indent how many leading whitespace characters to prepend
+ */
+ public void list(PrintStream out, int indent) {
+ toolkit.lockAWT();
+ try {
+ out.println(getIndentStr(indent) + this);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Prints a list of this component to the specified PrintWriter.
+ *
+ * @param out the output PrintWriter object.
+ */
+ public void list(PrintWriter out) {
+ toolkit.lockAWT();
+ try {
+ list(out, 1);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Prints a list of this component with the specified number of
+ * leading whitespace characters to the specified PrintWriter.
+ *
+ * @param out the output PrintWriter object.
+ * @param indent how many leading whitespace characters to prepend
+ */
+ public void list(PrintWriter out, int indent) {
+ toolkit.lockAWT();
+ try {
+ out.println(getIndentStr(indent) + this);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets a string composed of the desired number of
+ * whitespace characters.
+ *
+ * @param indent the length of the String to return
+ *
+ * @return the string composed of the desired number of
+ * whitespace characters
+ */
+ String getIndentStr(int indent) {
+ char[] ind = new char[indent];
+ for (int i = 0; i < indent; ind[i++] = ' ') {
+ ;
+ }
+ return new String(ind);
+ }
+
+ /**
+ * Prints a list of this component to the specified PrintStream
+ *
+ * @param out the output PrintStream object.
+ */
+ public void list(PrintStream out) {
+ toolkit.lockAWT();
+ try {
+ // default indent = 1
+ list(out, 1);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Prints a list of this component to the standard system
+ * output stream.
+ */
+ public void list() {
+ toolkit.lockAWT();
+ try {
+ list(System.out);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Prints this component.
+ *
+ * @param g the Graphics to be used for painting.
+ */
+ public void print(Graphics g) {
+ toolkit.lockAWT();
+ try {
+ paint(g);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Prints the component and all of its subcomponents.
+ *
+ * @param g the Graphics to be used for painting.
+ */
+ public void printAll(Graphics g) {
+ toolkit.lockAWT();
+ try {
+ paintAll(g);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the size of the Component specified by width and height
+ * parameters.
+ *
+ * @param width the width of the Component.
+ * @param height the height of the Component.
+ */
+ public void setSize(int width, int height) {
+ toolkit.lockAWT();
+ try {
+ resize(width, height);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the size of the Component specified by Dimension object.
+ *
+ * @param d the new size of the Component.
+ */
+ public void setSize(Dimension d) {
+ toolkit.lockAWT();
+ try {
+ resize(d);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by setSize(int, int) method.
+ *
+ * @param width the width.
+ * @param height the height.
+ *
+ * @deprecated Replaced by setSize(int, int) method.
+ */
+ @Deprecated
+ public void resize(int width, int height) {
+ toolkit.lockAWT();
+ try {
+ boundsMaskParam = NativeWindow.BOUNDS_NOMOVE;
+ setBounds(x, y, width, height);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by setSize(int, int) method.
+ *
+ * @param size the size.
+ *
+ * @deprecated Replaced by setSize(int, int) method.
+ */
+ @Deprecated
+ public void resize(Dimension size) {
+ toolkit.lockAWT();
+ try {
+ setSize(size.width, size.height);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not this component is completely opaque.
+ *
+ * @return true, if this component is completely opaque,
+ * false by default.
+ */
+ public boolean isOpaque() {
+ toolkit.lockAWT();
+ try {
+ return behaviour.isOpaque();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Disables.
+ *
+ * @deprecated Replaced by setEnabled(boolean) method.
+ */
+ @Deprecated
+ public void disable() {
+ toolkit.lockAWT();
+ try {
+ setEnabledImpl(false);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ //???AWT: fireAccessibleStateChange(AccessibleState.ENABLED, false);
+ }
+
+ /**
+ * Enables this component.
+ *
+ * @deprecated Replaced by setEnabled(boolean) method.
+ */
+ @Deprecated
+ public void enable() {
+ toolkit.lockAWT();
+ try {
+ setEnabledImpl(true);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ //???AWT: fireAccessibleStateChange(AccessibleState.ENABLED, true);
+ }
+
+ /**
+ * Enables or disable this component.
+ *
+ * @param b the boolean parameter.
+ *
+ * @deprecated Replaced by setEnabled(boolean) method.
+ */
+ @Deprecated
+ public void enable(boolean b) {
+ toolkit.lockAWT();
+ try {
+ if (b) {
+ enable();
+ } else {
+ disable();
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Stores the location of this component to the specified Point object;
+ * returns the point of the component's top-left corner.
+ *
+ * @param rv the Point object where the component's top-left corner
+ * position will be stored.
+ *
+ * @return the Point which specifies the component's top-left corner.
+ */
+ public Point getLocation(Point rv) {
+ toolkit.lockAWT();
+ try {
+ if (rv == null) {
+ rv = new Point();
+ }
+ rv.setLocation(getX(), getY());
+ return rv;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the location of this component on the form;
+ * returns the point of the component's top-left corner.
+ *
+ * @return the Point which specifies the component's top-left corner.
+ */
+ public Point getLocation() {
+ toolkit.lockAWT();
+ try {
+ return location();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the size of this Component.
+ *
+ * @return the size of this Component.
+ */
+ public Dimension getSize() {
+ toolkit.lockAWT();
+ try {
+ return size();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Stores the size of this Component to the specified Dimension
+ * object.
+ *
+ * @param rv the Dimension object where the size of the Component
+ * will be stored.
+ *
+ * @return the Dimension of this Component.
+ */
+ public Dimension getSize(Dimension rv) {
+ toolkit.lockAWT();
+ try {
+ if (rv == null) {
+ rv = new Dimension();
+ }
+ rv.setSize(getWidth(), getHeight());
+ return rv;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not this Component is valid. A component is valid
+ * if it is correctly sized and positioned within its parent container
+ * and all its children are also valid.
+ *
+ * @return true, if the Component is valid, false otherwise.
+ */
+ public boolean isValid() {
+ toolkit.lockAWT();
+ try {
+ return valid && behaviour.isDisplayable();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by getComponentAt(int, int) method.
+ *
+ * @return the Point.
+ *
+ * @deprecated Replaced by getComponentAt(int, int) method.
+ */
+ @Deprecated
+ public Point location() {
+ toolkit.lockAWT();
+ try {
+ return new Point(x, y);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Connects this Component to a native screen resource and makes it
+ * displayable. This method not be called directly by user applications.
+ */
+ public void addNotify() {
+ toolkit.lockAWT();
+ try {
+ prepare4HierarchyChange();
+ behaviour.addNotify();
+ //???AWT
+// finishHierarchyChange(this, parent, 0);
+// if (dropTarget != null) {
+// dropTarget.addNotify(peer);
+// }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Map to display.
+ *
+ * @param b the b
+ */
+ void mapToDisplay(boolean b) {
+ //???AWT
+ /*
+ if (b && !isDisplayable()) {
+ if ((this instanceof Window) || ((parent != null) && parent.isDisplayable())) {
+ addNotify();
+ }
+ } else if (!b && isDisplayable()) {
+ removeNotify();
+ }
+ */
+ }
+
+ /**
+ * Gets the toolkit.
+ *
+ * @return accessible context specific for particular component
+ */
+ //???AWT
+ /*
+ AccessibleContext createAccessibleContext() {
+ return null;
+ }
+
+ public AccessibleContext getAccessibleContext() {
+ toolkit.lockAWT();
+ try {
+ if (accessibleContext == null) {
+ accessibleContext = createAccessibleContext();
+ }
+ return accessibleContext;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Gets Toolkit for the current Component.
+ *
+ * @return the Toolkit of this Component.
+ */
+ public Toolkit getToolkit() {
+ return toolkit;
+ }
+
+ /**
+ * Gets this component's locking object for AWT component tree
+ * and layout operations.
+ *
+ * @return the tree locking object.
+ */
+ public final Object getTreeLock() {
+ return toolkit.awtTreeLock;
+ }
+
+ /**
+ * @param evt the Event.
+ * @param what the event's key.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Use ActionListener class for registering event listener.
+ */
+ @Deprecated
+ public boolean action(Event evt, Object what) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+
+ /**
+ * Gets the property change support.
+ *
+ * @return the property change support
+ */
+ private PropertyChangeSupport getPropertyChangeSupport() {
+ synchronized (componentLock) {
+ if (propertyChangeSupport == null) {
+ propertyChangeSupport = new PropertyChangeSupport(this);
+ }
+ return propertyChangeSupport;
+ }
+ }
+
+ //???AWT
+ /*
+ public void addPropertyChangeListener(PropertyChangeListener listener) {
+ getPropertyChangeSupport().addPropertyChangeListener(listener);
+ }
+
+ public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
+ getPropertyChangeSupport().addPropertyChangeListener(propertyName, listener);
+ }
+
+ public void applyComponentOrientation(ComponentOrientation orientation) {
+ toolkit.lockAWT();
+ try {
+ setComponentOrientation(orientation);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Returns true if the set of focus traversal keys for the given focus
+ * traversal operation has been explicitly defined for this Component.
+ *
+ * @param id the ID of traversal key.
+ *
+ * @return true, if the set of focus traversal keys for the given focus
+ * traversal operation has been explicitly defined for this Component,
+ * false otherwise.
+ */
+ public boolean areFocusTraversalKeysSet(int id) {
+ toolkit.lockAWT();
+ try {
+ Integer Id = new Integer(id);
+ if (traversalKeys.containsKey(Id)) {
+ return traversalKeys.get(Id) != null;
+ }
+ // awt.14F=invalid focus traversal key identifier
+ throw new IllegalArgumentException(Messages.getString("awt.14F")); //$NON-NLS-1$
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the bounds of the Component.
+ *
+ * @return the rectangle bounds of the Component.
+ *
+ * @deprecated Use getBounds() methood.
+ */
+ @Deprecated
+ public Rectangle bounds() {
+ toolkit.lockAWT();
+ try {
+ return new Rectangle(x, y, w, h);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Returns the construction status of a specified image
+ * with the specified width and height that is being created.
+ *
+ *
+ * @param image the image to be checked.
+ * @param width the width of scaled image which status is being checked, or -1.
+ * @param height the height of scaled image which status is being checked, or -1.
+ * @param observer the ImageObserver object to be notified while
+ * the image is being prepared.
+ *
+ * @return the ImageObserver flags of the current state of the image data.
+ */
+ public int checkImage(Image image, int width, int height, ImageObserver observer) {
+ toolkit.lockAWT();
+ try {
+ return toolkit.checkImage(image, width, height, observer);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Returns the construction status of a specified image that is being created.
+ *
+ *
+ * @param image the image to be checked.
+ * @param observer the ImageObserver object to be notified while
+ * the image is being prepared.
+ *
+ * @return the ImageObserver flags of the current state of the image data.
+ */
+ public int checkImage(Image image, ImageObserver observer) {
+ toolkit.lockAWT();
+ try {
+ return toolkit.checkImage(image, -1, -1, observer);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Coalesces the existed event with new event.
+ *
+ * @param existingEvent the existing event in the EventQueue.
+ * @param newEvent the new event to be posted to the EventQueue.
+ *
+ * @return the coalesced AWTEvent, or null if there is no coalescing done.
+ */
+ protected AWTEvent coalesceEvents(AWTEvent existingEvent, AWTEvent newEvent) {
+ toolkit.lockAWT();
+ try {
+ // Nothing to do:
+ // 1. Mouse events coalesced at WTK level
+ // 2. Paint events handled by RedrawManager
+ // This method is for overriding only
+ return null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks if this Component is a coalescer.
+ *
+ * @return true, if is coalescer
+ */
+ boolean isCoalescer() {
+ return coalescer;
+ }
+
+ /**
+ * Gets the relative event.
+ *
+ * @param id the id
+ *
+ * @return the relative event
+ */
+ AWTEvent getRelativeEvent(int id) {
+ Integer idWrapper = new Integer(id);
+ eventsList = eventsTable.get(idWrapper);
+ if (eventsList == null) {
+ eventsList = new LinkedList<AWTEvent>();
+ eventsTable.put(idWrapper, eventsList);
+ return null;
+ }
+ if (eventsList.isEmpty()) {
+ return null;
+ }
+ return eventsList.getLast();
+ }
+
+ /**
+ * Adds the new event.
+ *
+ * @param event the event
+ */
+ void addNewEvent(AWTEvent event) {
+ eventsList.addLast(event);
+ }
+
+ /**
+ * Removes the relative event.
+ */
+ void removeRelativeEvent() {
+ eventsList.removeLast();
+ }
+
+ /**
+ * Removes the next event.
+ *
+ * @param id the id
+ */
+ void removeNextEvent(int id) {
+ eventsTable.get(new Integer(id)).removeFirst();
+ }
+
+ /**
+ * Creates the image with the specified ImageProducer.
+ *
+ * @param producer the ImageProducer to be used for image creation.
+ *
+ * @return the image with the specified ImageProducer.
+ */
+ public Image createImage(ImageProducer producer) {
+ toolkit.lockAWT();
+ try {
+ return toolkit.createImage(producer);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Creates an off-screen drawable image to be used for double buffering.
+ *
+ * @param width the width of the image.
+ * @param height the height of the image.
+ *
+ * @return the off-screen drawable image or null if the component is not
+ * displayable or GraphicsEnvironment.isHeadless() method returns true.
+ */
+ public Image createImage(int width, int height) {
+ toolkit.lockAWT();
+ try {
+ if (!isDisplayable()) {
+ return null;
+ }
+ GraphicsConfiguration gc = getGraphicsConfiguration();
+ if (gc == null) {
+ return null;
+ }
+ ColorModel cm = gc.getColorModel(Transparency.OPAQUE);
+ WritableRaster wr = cm.createCompatibleWritableRaster(width, height);
+ Image image = new BufferedImage(cm, wr, cm.isAlphaPremultiplied(), null);
+ fillImageBackground(image, width, height);
+ return image;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Creates an off-screen drawable image with the specified width,
+ * height and ImageCapabilities.
+ *
+ * @param width the width
+ * @param height the height
+ * @param caps the ImageCapabilities.
+ *
+ * @return the volatile image
+ *
+ * @throws AWTException if an image with the specified capabilities
+ * cannot be created.
+ */
+ public VolatileImage createVolatileImage(int width, int height, ImageCapabilities caps)
+ throws AWTException {
+ toolkit.lockAWT();
+ try {
+ if (!isDisplayable()) {
+ return null;
+ }
+ GraphicsConfiguration gc = getGraphicsConfiguration();
+ if (gc == null) {
+ return null;
+ }
+ VolatileImage image = gc.createCompatibleVolatileImage(width, height, caps);
+ fillImageBackground(image, width, height);
+ return image;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Creates a volatile off-screen drawable image which is used
+ * for double buffering.
+ *
+ * @param width the width of image.
+ * @param height the height of image.
+ *
+ * @return the volatile image a volatile off-screen drawable image
+ * which is used for double buffering or null if the component
+ * is not displayable, or GraphicsEnvironment.isHeadless() method
+ * returns true.
+ */
+ public VolatileImage createVolatileImage(int width, int height) {
+ toolkit.lockAWT();
+ try {
+ if (!isDisplayable()) {
+ return null;
+ }
+ GraphicsConfiguration gc = getGraphicsConfiguration();
+ if (gc == null) {
+ return null;
+ }
+ VolatileImage image = gc.createCompatibleVolatileImage(width, height);
+ fillImageBackground(image, width, height);
+ return image;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Fill the image being created by createImage() or createVolatileImage()
+ * with the component's background color to prepare it for double-buffered
+ * painting.
+ *
+ * @param image the image
+ * @param width the width
+ * @param height the height
+ */
+ private void fillImageBackground(Image image, int width, int height) {
+ Graphics gr = image.getGraphics();
+ gr.setColor(getBackground());
+ gr.fillRect(0, 0, width, height);
+ gr.dispose();
+ }
+
+ /**
+ * Delivers event.
+ *
+ * @param evt the event.
+ *
+ * @deprecated Replaced by dispatchEvent(AWTEvent e) method.
+ */
+ @Deprecated
+ public void deliverEvent(Event evt) {
+ postEvent(evt);
+ }
+
+ /**
+ * Prompts the layout manager to lay out this component.
+ */
+ public void doLayout() {
+ toolkit.lockAWT();
+ try {
+ layout();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ // Implemented in Container
+ }
+
+ /**
+ * Fire property change impl.
+ *
+ * @param propertyName the property name
+ * @param oldValue the old value
+ * @param newValue the new value
+ */
+ private void firePropertyChangeImpl(String propertyName, Object oldValue, Object newValue) {
+ PropertyChangeSupport pcs;
+ synchronized (componentLock) {
+ if (propertyChangeSupport == null) {
+ return;
+ }
+ pcs = propertyChangeSupport;
+ }
+ pcs.firePropertyChange(propertyName, oldValue, newValue);
+ }
+
+ /**
+ * Reports a bound property changes for int properties.
+ *
+ * @param propertyName the property name.
+ * @param oldValue the old property's value.
+ * @param newValue the new property's value.
+ */
+ protected void firePropertyChange(String propertyName, int oldValue, int newValue) {
+ firePropertyChangeImpl(propertyName, new Integer(oldValue), new Integer(newValue));
+ }
+
+ /**
+ * Report a bound property change for a boolean-valued property.
+ *
+ * @param propertyName the property name.
+ * @param oldValue the property's old value.
+ * @param newValue the property's new value.
+ */
+ protected void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+ firePropertyChangeImpl(propertyName, Boolean.valueOf(oldValue), Boolean
+ .valueOf(newValue));
+ }
+
+ /**
+ * Reports a bound property change for an Object-valued property.
+ *
+ * @param propertyName the property name.
+ * @param oldValue the property's old value
+ * @param newValue the property's new value
+ */
+ protected void firePropertyChange(final String propertyName, final Object oldValue,
+ final Object newValue) {
+ firePropertyChangeImpl(propertyName, oldValue, newValue);
+ }
+
+ /**
+ * Report a bound property change for a byte-valued property.
+ *
+ * @param propertyName the property name.
+ * @param oldValue the property's old value.
+ * @param newValue the property's new value.
+ */
+ public void firePropertyChange(String propertyName, byte oldValue, byte newValue) {
+ firePropertyChangeImpl(propertyName, new Byte(oldValue), new Byte(newValue));
+ }
+
+ /**
+ * Report a bound property change for a char-valued property.
+ *
+ * @param propertyName the property name.
+ * @param oldValue the old property's value.
+ * @param newValue the new property's value.
+ */
+ public void firePropertyChange(String propertyName, char oldValue, char newValue) {
+ firePropertyChangeImpl(propertyName, new Character(oldValue), new Character(newValue));
+ }
+
+ /**
+ * Report a bound property change for a short-valued property.
+ *
+ * @param propertyName the property name.
+ * @param oldValue the old property's value.
+ * @param newValue the new property's value.
+ */
+ public void firePropertyChange(String propertyName, short oldValue, short newValue) {
+ firePropertyChangeImpl(propertyName, new Short(oldValue), new Short(newValue));
+ }
+
+ /**
+ * Report a bound property change for a long-valued property.
+ *
+ * @param propertyName the property name.
+ * @param oldValue the old property's value.
+ * @param newValue the new property's value.
+ */
+ public void firePropertyChange(String propertyName, long oldValue, long newValue) {
+ firePropertyChangeImpl(propertyName, new Long(oldValue), new Long(newValue));
+ }
+
+ /**
+ * Report a bound property change for a float-valued property.
+ *
+ * @param propertyName the property name.
+ * @param oldValue the old property's value.
+ * @param newValue the new property's value.
+ */
+ public void firePropertyChange(String propertyName, float oldValue, float newValue) {
+ firePropertyChangeImpl(propertyName, new Float(oldValue), new Float(newValue));
+ }
+
+ /**
+ * Report a bound property change for a double-valued property.
+ *
+ * @param propertyName the property name.
+ * @param oldValue the old property's value.
+ * @param newValue the new property's value.
+ */
+ public void firePropertyChange(String propertyName, double oldValue, double newValue) {
+ firePropertyChangeImpl(propertyName, new Double(oldValue), new Double(newValue));
+ }
+
+ /**
+ * Gets the alignment along the x axis.
+ *
+ * @return the alignment along the x axis.
+ */
+ public float getAlignmentX() {
+ toolkit.lockAWT();
+ try {
+ return CENTER_ALIGNMENT;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the alignment along the y axis.
+ *
+ * @return the alignment along y axis.
+ */
+ public float getAlignmentY() {
+ toolkit.lockAWT();
+ try {
+ return CENTER_ALIGNMENT;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the background color for this component.
+ *
+ * @return the background color for this component.
+ */
+ public Color getBackground() {
+ toolkit.lockAWT();
+ try {
+ //???AWT
+ /*
+ if ((backColor == null) && (parent != null)) {
+ return parent.getBackground();
+ }
+ */
+ return backColor;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the bounding rectangle of this component.
+ *
+ * @return the bounding rectangle of this component.
+ */
+ public Rectangle getBounds() {
+ toolkit.lockAWT();
+ try {
+ return bounds();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Writes the data of the bounding rectangle to the specified
+ * Rectangle object.
+ *
+ * @param rv the Rectangle object where the bounding rectangle's data is stored.
+ *
+ * @return the bounding rectangle.
+ */
+ public Rectangle getBounds(Rectangle rv) {
+ toolkit.lockAWT();
+ try {
+ if (rv == null) {
+ rv = new Rectangle();
+ }
+ rv.setBounds(x, y, w, h);
+ return rv;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the color model of the Component.
+ *
+ * @return the color model of the Component.
+ */
+ public ColorModel getColorModel() {
+ toolkit.lockAWT();
+ try {
+ return getToolkit().getColorModel();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the Component which contains the specified Point.
+ *
+ * @param p the Point.
+ *
+ * @return the Component which contains the specified Point.
+ */
+ public Component getComponentAt(Point p) {
+ toolkit.lockAWT();
+ try {
+ return getComponentAt(p.x, p.y);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the Component which contains the point with the
+ * specified coordinates.
+ *
+ * @param x the x coordinate of the point.
+ * @param y the y coordinate of the point.
+ *
+ * @return the Component which contains the point with the
+ * specified coordinates.
+ */
+ public Component getComponentAt(int x, int y) {
+ toolkit.lockAWT();
+ try {
+ return locate(x, y);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the component's orientation.
+ *
+ * @return the component's orientation.
+ */
+ public ComponentOrientation getComponentOrientation() {
+ toolkit.lockAWT();
+ try {
+ return orientation;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the cursor of the Component.
+ *
+ * @return the Cursor.
+ */
+ public Cursor getCursor() {
+ toolkit.lockAWT();
+ try {
+ if (cursor != null) {
+ return cursor;
+ //???AWT
+ /*
+ } else if (parent != null) {
+ return parent.getCursor();
+ */
+ }
+ return Cursor.getDefaultCursor();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ //???AWT
+ /*
+ public DropTarget getDropTarget() {
+ toolkit.lockAWT();
+ try {
+ return dropTarget;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public Container getFocusCycleRootAncestor() {
+ toolkit.lockAWT();
+ try {
+ for (Container c = parent; c != null; c = c.getParent()) {
+ if (c.isFocusCycleRoot()) {
+ return c;
+ }
+ }
+ return null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public Set<AWTKeyStroke> getFocusTraversalKeys(int id) {
+ toolkit.lockAWT();
+ try {
+ Integer kId = new Integer(id);
+ KeyboardFocusManager.checkTraversalKeysID(traversalKeys, kId);
+ Set<? extends AWTKeyStroke> keys = traversalKeys.get(kId);
+ if (keys == null && parent != null) {
+ keys = parent.getFocusTraversalKeys(id);
+ }
+ if (keys == null) {
+ keys = KeyboardFocusManager.getCurrentKeyboardFocusManager()
+ .getDefaultFocusTraversalKeys(id);
+ }
+ return (Set<AWTKeyStroke>) keys;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Checks if the the focus traversal keys are enabled for this component.
+ *
+ * @return true, if the the focus traversal keys are enabled for
+ * this component, false otherwise.
+ */
+ public boolean getFocusTraversalKeysEnabled() {
+ toolkit.lockAWT();
+ try {
+ return focusTraversalKeysEnabled;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the font metrics of the specified Font.
+ *
+ * @param f the Font.
+ *
+ * @return the FontMetrics of the specified Font.
+ */
+ @SuppressWarnings("deprecation")
+ public FontMetrics getFontMetrics(Font f) {
+ return toolkit.getFontMetrics(f);
+ }
+
+ /**
+ * Gets the foreground color of the Component.
+ *
+ * @return the foreground color of the Component.
+ */
+ public Color getForeground() {
+ toolkit.lockAWT();
+ try {
+ //???AWT
+ /*
+ if (foreColor == null && parent != null) {
+ return parent.getForeground();
+ }
+ */
+ return foreColor;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the Graphics of the Component or null if this Component
+ * is not displayable.
+ *
+ * @return the Graphics of the Component or null if this Component
+ * is not displayable.
+ */
+ public Graphics getGraphics() {
+ toolkit.lockAWT();
+ try {
+ if (!isDisplayable()) {
+ return null;
+ }
+ Graphics g = behaviour.getGraphics(0, 0, w, h);
+ g.setColor(foreColor);
+ g.setFont(font);
+ return g;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+
+ /**
+ * Gets the GraphicsConfiguration associated with this Component.
+ *
+ * @return the GraphicsConfiguration associated with this Component.
+ */
+ public GraphicsConfiguration getGraphicsConfiguration() {
+ //???AWT
+ /*
+ toolkit.lockAWT();
+ try {
+ Window win = getWindowAncestor();
+ if (win == null) {
+ return null;
+ }
+ return win.getGraphicsConfiguration();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ */
+ return null;
+ }
+
+ /**
+ * Gets the height of the Component.
+ *
+ * @return the height of the Component.
+ */
+ public int getHeight() {
+ toolkit.lockAWT();
+ try {
+ return h;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Returns true if paint messages received from the operating system
+ * should be ignored.
+ *
+ * @return true if paint messages received from the operating system
+ * should be ignored, false otherwise.
+ */
+ public boolean getIgnoreRepaint() {
+ toolkit.lockAWT();
+ try {
+ return ignoreRepaint;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the input context of this component for handling
+ * the communication with input methods when text is entered
+ * in this component.
+ *
+ * @return the InputContext used by this Component or
+ * null if no context is specifined.
+ */
+ public InputContext getInputContext() {
+ toolkit.lockAWT();
+ try {
+ //???AWT
+ /*
+ Container parent = getParent();
+ if (parent != null) {
+ return parent.getInputContext();
+ }
+ */
+ return null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the input method request handler which supports requests
+ * from input methods for this component, or null for default.
+ *
+ * @return the input method request handler which supports requests
+ * from input methods for this component, or null for default.
+ */
+ public InputMethodRequests getInputMethodRequests() {
+ return null;
+ }
+
+ /**
+ * Gets the locale of this Component.
+ *
+ * @return the locale of this Component.
+ */
+ public Locale getLocale() {
+ toolkit.lockAWT();
+ try {
+ //???AWT
+ /*
+ if (locale == null) {
+ if (parent == null) {
+ if (this instanceof Window) {
+ return Locale.getDefault();
+ }
+ // awt.150=no parent
+ throw new IllegalComponentStateException(Messages.getString("awt.150")); //$NON-NLS-1$
+ }
+ return getParent().getLocale();
+ }
+ */
+ return locale;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the location of this component in the form of a point
+ * specifying the component's top-left corner in the
+ * screen's coordinate space.
+ *
+ * @return the Point giving the component's location in the
+ * screen's coordinate space.
+ *
+ * @throws IllegalComponentStateException if the component is
+ * not shown on the screen.
+ */
+ public Point getLocationOnScreen() throws IllegalComponentStateException {
+ toolkit.lockAWT();
+ try {
+ Point p = new Point();
+ if (isShowing()) {
+ //???AWT
+ /*
+ Component comp;
+ for (comp = this; comp != null && !(comp instanceof Window); comp = comp
+ .getParent()) {
+ p.translate(comp.getX(), comp.getY());
+ }
+ if (comp instanceof Window) {
+ p.translate(comp.getX(), comp.getY());
+ }
+ */
+ return p;
+ }
+ // awt.151=component must be showing on the screen to determine its location
+ throw new IllegalComponentStateException(Messages.getString("awt.151")); //$NON-NLS-1$
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the peer. This method should not be called directly by
+ * user applications.
+ *
+ * @return the ComponentPeer.
+ *
+ * @deprecated Replaced by isDisplayable().
+ */
+ @Deprecated
+ public ComponentPeer getPeer() {
+ toolkit.lockAWT();
+ try {
+ if (behaviour.isDisplayable()) {
+ return peer;
+ }
+ return null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets an array of the property change listeners registered to
+ * this Component.
+ *
+ * @return an array of the PropertyChangeListeners registered to
+ * this Component.
+ */
+ public PropertyChangeListener[] getPropertyChangeListeners() {
+ return getPropertyChangeSupport().getPropertyChangeListeners();
+ }
+
+ /**
+ * Gets an array of PropertyChangeListener objects registered
+ * to this Component for the specified property.
+ *
+ * @param propertyName the property name.
+ *
+ * @return an array of PropertyChangeListener objects registered
+ * to this Component for the specified property.
+ */
+ public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
+ return getPropertyChangeSupport().getPropertyChangeListeners(propertyName);
+ }
+
+ /**
+ * Gets the width of the Component.
+ *
+ * @return the width of the Component.
+ */
+ public int getWidth() {
+ toolkit.lockAWT();
+ try {
+ return w;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the x coordinate of the component's top-left corner.
+ *
+ * @return the x coordinate of the component's top-left corner.
+ */
+ public int getX() {
+ toolkit.lockAWT();
+ try {
+ return x;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the y coordinate of the component's top-left corner.
+ *
+ * @return the y coordinate of the component's top-left corner.
+ */
+ public int getY() {
+ toolkit.lockAWT();
+ try {
+ return y;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Got the focus.
+ *
+ * @param evt the Event.
+ * @param what the Object.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Replaced by processFocusEvent(FocusEvent) method.
+ */
+ @Deprecated
+ public boolean gotFocus(Event evt, Object what) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Handles event.
+ *
+ * @param evt the Event.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Replaced by processEvent(AWTEvent) method.
+ */
+ @Deprecated
+ public boolean handleEvent(Event evt) {
+ switch (evt.id) {
+ case Event.ACTION_EVENT:
+ return action(evt, evt.arg);
+ case Event.GOT_FOCUS:
+ return gotFocus(evt, null);
+ case Event.LOST_FOCUS:
+ return lostFocus(evt, null);
+ case Event.MOUSE_DOWN:
+ return mouseDown(evt, evt.x, evt.y);
+ case Event.MOUSE_DRAG:
+ return mouseDrag(evt, evt.x, evt.y);
+ case Event.MOUSE_ENTER:
+ return mouseEnter(evt, evt.x, evt.y);
+ case Event.MOUSE_EXIT:
+ return mouseExit(evt, evt.x, evt.y);
+ case Event.MOUSE_MOVE:
+ return mouseMove(evt, evt.x, evt.y);
+ case Event.MOUSE_UP:
+ return mouseUp(evt, evt.x, evt.y);
+ case Event.KEY_ACTION:
+ case Event.KEY_PRESS:
+ return keyDown(evt, evt.key);
+ case Event.KEY_ACTION_RELEASE:
+ case Event.KEY_RELEASE:
+ return keyUp(evt, evt.key);
+ }
+ return false;// event not handled
+ }
+
+ /**
+ * Checks whether the Component is the focus owner or not.
+ *
+ * @return true, if the Component is the focus owner, false otherwise.
+ */
+ public boolean hasFocus() {
+ toolkit.lockAWT();
+ try {
+ //???AWT: return isFocusOwner();
+ return false;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Hides the Component.
+ *
+ * @deprecated Replaced by setVisible(boolean) method.
+ */
+ @Deprecated
+ public void hide() {
+ toolkit.lockAWT();
+ try {
+ if (!visible) {
+ return;
+ }
+ prepare4HierarchyChange();
+ visible = false;
+ moveFocusOnHide();
+ behaviour.setVisible(false);
+ postEvent(new ComponentEvent(this, ComponentEvent.COMPONENT_HIDDEN));
+ //???AWT: finishHierarchyChange(this, parent, 0);
+ notifyInputMethod(null);
+ //???AWT: invalidateRealParent();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not the point with the specified coordinates
+ * belongs to the Commponent.
+ *
+ * @param x the x coordinate of the Point.
+ * @param y the y coordinate of the Point.
+ *
+ * @return true, if the point with the specified coordinates
+ * belongs to the Commponent, false otherwise.
+ *
+ * @deprecated Replaced by contains(int, int) method.
+ */
+ @Deprecated
+ public boolean inside(int x, int y) {
+ toolkit.lockAWT();
+ try {
+ return x >= 0 && x < getWidth() && y >= 0 && y < getHeight();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Invalidates the component, this component and all parents
+ * above it are marked as needing to be laid out.
+ */
+ public void invalidate() {
+ toolkit.lockAWT();
+ try {
+ valid = false;
+ resetDefaultSize();
+ //???AWT: invalidateRealParent();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not the background color is set to this Component.
+ *
+ * @return true, if the background color is set to this Component,
+ * false otherwise.
+ */
+ public boolean isBackgroundSet() {
+ toolkit.lockAWT();
+ try {
+ return backColor != null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not a cursor is set for the Component.
+ *
+ * @return true, if a cursor is set for the Component,
+ * false otherwise.
+ */
+ public boolean isCursorSet() {
+ toolkit.lockAWT();
+ try {
+ return cursor != null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not this Component is displayable.
+ *
+ * @return true, if this Component is displayable, false otherwise.
+ */
+ public boolean isDisplayable() {
+ toolkit.lockAWT();
+ try {
+ return behaviour.isDisplayable();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not this component is painted to an buffer
+ * which is copied to the screen later.
+ *
+ * @return true, if this component is painted to an buffer
+ * which is copied to the screen later, false otherwise.
+ */
+ public boolean isDoubleBuffered() {
+ toolkit.lockAWT();
+ try {
+ // false by default
+ return false;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not this Component is enabled.
+ *
+ * @return true, if this Component is enabled, false otherwise.
+ */
+ public boolean isEnabled() {
+ toolkit.lockAWT();
+ try {
+ return enabled;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * "Recursive" isEnabled().
+ *
+ * @return true if not only component itself is enabled but its heavyweight
+ * parent is also "indirectly" enabled
+ */
+ boolean isIndirectlyEnabled() {
+ Component comp = this;
+ while (comp != null) {
+ if (!comp.isLightweight() && !comp.isEnabled()) {
+ return false;
+ }
+ //???AWT: comp = comp.getRealParent();
+ }
+ return true;
+ }
+
+ /**
+ * Checks if the component is key enabled.
+ *
+ * @return true, if the component is enabled and indirectly enabled
+ */
+ boolean isKeyEnabled() {
+ if (!isEnabled()) {
+ return false;
+ }
+ return isIndirectlyEnabled();
+ }
+
+ /**
+ * Gets only parent of a child component, but not owner of a window.
+ *
+ * @return parent of child component, null if component is a top-level
+ * (Window instance)
+ */
+ //???AWT
+ /*
+ Container getRealParent() {
+ return (!(this instanceof Window) ? getParent() : null);
+ }
+
+ public boolean isFocusCycleRoot(Container container) {
+ toolkit.lockAWT();
+ try {
+ return getFocusCycleRootAncestor() == container;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public boolean isFocusOwner() {
+ toolkit.lockAWT();
+ try {
+ return KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() == this;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Checks whether or not this Component can be focusable.
+ *
+ * @return true, if this Component can be focusable, false otherwise.
+ *
+ * @deprecated Replaced by isFocusable().
+ */
+ @Deprecated
+ public boolean isFocusTraversable() {
+ toolkit.lockAWT();
+ try {
+ overridenIsFocusable = false;
+ return focusable; // a Component must either be both focusable and
+ // focus traversable, or neither
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks if this Component can be focusable or not.
+ *
+ * @return true, if this Component can be focusable, false otherwise.
+ */
+ public boolean isFocusable() {
+ toolkit.lockAWT();
+ try {
+ return isFocusTraversable();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks if the Font is set for this Component or not.
+ *
+ * @return true, if the Font is set, false otherwise.
+ */
+ public boolean isFontSet() {
+ toolkit.lockAWT();
+ try {
+ return font != null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks if foreground color is set for the Component or not.
+ *
+ * @return true, if is foreground color is set for the Component,
+ * false otherwise.
+ */
+ public boolean isForegroundSet() {
+ toolkit.lockAWT();
+ try {
+ return foreColor != null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Returns true if this component has a lightweight peer.
+ *
+ * @return true, if this component has a lightweight peer,
+ * false if it has a native peer or no peer.
+ */
+ public boolean isLightweight() {
+ toolkit.lockAWT();
+ try {
+ return behaviour.isLightweight();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+
+ /**
+ * Checks whether or not this Component is shown.
+ *
+ * @return true, if this Component is shown, false otherwise.
+ */
+ public boolean isShowing() {
+ //???AWT
+ /*
+ toolkit.lockAWT();
+ try {
+ return (isVisible() && isDisplayable() && (parent != null) && parent.isShowing());
+ } finally {
+ toolkit.unlockAWT();
+ }
+ */
+ return false;
+ }
+
+ /**
+ * Checks whether or not this Component is visible.
+ *
+ * @return true, if the Component is visible, false otherwise.
+ */
+ public boolean isVisible() {
+ toolkit.lockAWT();
+ try {
+ return visible;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by processKeyEvent(KeyEvent) method.
+ *
+ * @param evt the Event.
+ * @param key the key code.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Replaced by replaced by processKeyEvent(KeyEvent) method.
+ */
+ @Deprecated
+ public boolean keyDown(Event evt, int key) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Deprecated: replaced by processKeyEvent(KeyEvent) method.
+ *
+ * @param evt the Event.
+ * @param key the key code.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Replaced by processKeyEvent(KeyEvent) method.
+ */
+ @Deprecated
+ public boolean keyUp(Event evt, int key) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Deprecated: Replaced by doLayout() method.
+ *
+ * @deprecated Replaced by doLayout() method.
+ */
+ @Deprecated
+ public void layout() {
+ toolkit.lockAWT();
+ try {
+ // Implemented in Container
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by getComponentAt(int, int) method.
+ *
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ *
+ * @return The component.
+ *
+ * @deprecated Replaced by getComponentAt(int, int) method.
+ */
+ @Deprecated
+ public Component locate(int x, int y) {
+ toolkit.lockAWT();
+ try {
+ if (contains(x, y)) {
+ return this;
+ }
+ return null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by processFocusEvent(FocusEvent).
+ *
+ * @param evt the Event.
+ * @param what the Object.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Replaced by processFocusEvent(FocusEvent).
+ */
+ @Deprecated
+ public boolean lostFocus(Event evt, Object what) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Deprecated: replaced by processMouseEvent(MouseEvent) method.
+ *
+ * @param evt the MouseEvent.
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Replaced by processMouseEvent(MouseEvent) method.
+ */
+ @Deprecated
+ public boolean mouseDown(Event evt, int x, int y) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Deprecated: replaced by getMinimumSize() method.
+ *
+ * @param evt the Event.
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Replaced by getMinimumSize() method.
+ */
+ @Deprecated
+ public boolean mouseDrag(Event evt, int x, int y) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Replaced by processMouseEvent(MouseEvent) method.
+ *
+ * @param evt the Event.
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated replaced by processMouseEvent(MouseEvent) method.
+ */
+ @Deprecated
+ public boolean mouseEnter(Event evt, int x, int y) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Replaced by processMouseEvent(MouseEvent) method.
+ *
+ * @param evt the Event.
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Replaced by processMouseEvent(MouseEvent) method.
+ */
+ @Deprecated
+ public boolean mouseExit(Event evt, int x, int y) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Replaced by processMouseEvent(MouseEvent) method.
+ *
+ * @param evt the Event.
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ *
+ * @deprecated Replaced by processMouseEvent(MouseEvent) method.
+ *
+ * @return true, if successful.
+ */
+ @Deprecated
+ public boolean mouseMove(Event evt, int x, int y) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Replaced by processMouseEvent(MouseEvent) method.
+ *
+ * @param evt the Event.
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ *
+ * @return true, if successful.
+ *
+ * @deprecated Replaced by processMouseEvent(MouseEvent) method.
+ */
+ @Deprecated
+ public boolean mouseUp(Event evt, int x, int y) {
+ // to be overridden: do nothing,
+ // just return false to propagate event up to the parent container
+ return false;
+ }
+
+ /**
+ * Deprecated: replaced by setLocation(int, int) method.
+ *
+ * @param x the x coordinates.
+ * @param y the y coordinates.
+ *
+ * @deprecated Replaced by setLocation(int, int) method.
+ */
+ @Deprecated
+ public void move(int x, int y) {
+ toolkit.lockAWT();
+ try {
+ boundsMaskParam = NativeWindow.BOUNDS_NOSIZE;
+ setBounds(x, y, w, h);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ //???AWT
+ /*
+ @Deprecated
+ public void nextFocus() {
+ toolkit.lockAWT();
+ try {
+ transferFocus(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Returns a string representation of the component's state.
+ *
+ * @return the string representation of the component's state.
+ */
+ protected String paramString() {
+ /*
+ * The format is based on 1.5 release behavior which can be revealed by
+ * the following code:
+ *
+ * Component c = new Component(){}; c.setVisible(false);
+ * System.out.println(c);
+ */
+ toolkit.lockAWT();
+ try {
+ return getName() + "," + getX() + "," + getY() + "," + getWidth() + "x" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ + getHeight() + (!isVisible() ? ",hidden" : ""); //$NON-NLS-1$ //$NON-NLS-2$
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Deprecated
+ @SuppressWarnings("deprecation")
+ public boolean postEvent(Event evt) {
+ boolean handled = handleEvent(evt);
+ if (handled) {
+ return true;
+ }
+ //???AWT
+ /*
+
+ // propagate non-handled events up to parent
+ Component par = parent;
+ // try to call postEvent only on components which
+ // override any of deprecated method handlers
+ // while (par != null && !par.deprecatedEventHandler) {
+ // par = par.parent;
+ // }
+ // translate event coordinates before posting it to parent
+ if (par != null) {
+ evt.translate(x, y);
+ par.postEvent(evt);
+ }
+
+ */
+ return false;
+ }
+
+ /**
+ * Prepares an image for rendering on the Component.
+ *
+ * @param image the Image to be prepared.
+ * @param observer the ImageObserver object to be notified as soon as
+ * the image is prepared.
+ *
+ * @return true if the image has been fully prepared,
+ * false otherwise.
+ */
+ public boolean prepareImage(Image image, ImageObserver observer) {
+ toolkit.lockAWT();
+ try {
+ return toolkit.prepareImage(image, -1, -1, observer);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Prepares an image for rendering on the Component with the
+ * specified width, height, and ImageObserver.
+ *
+ * @param image the Image to be prepared.
+ * @param width the width of scaled image.
+ * @param height the height of scaled height.
+ * @param observer the ImageObserver object to be notified as soon as
+ * the image is prepared.
+ *
+ * @return true if the image is been fully prepared,
+ * false otherwise.
+ */
+ public boolean prepareImage(Image image, int width, int height, ImageObserver observer) {
+ toolkit.lockAWT();
+ try {
+ return toolkit.prepareImage(image, width, height, observer);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Makes this Component undisplayable.
+ */
+ public void removeNotify() {
+ toolkit.lockAWT();
+ try {
+ //???AWT
+ /*
+ if (dropTarget != null) {
+ dropTarget.removeNotify(peer);
+ }
+ */
+ prepare4HierarchyChange();
+ ///???AWT: moveFocus();
+ behaviour.removeNotify();
+ //???AWT: finishHierarchyChange(this, parent, 0);
+ removeNotifyInputContext();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Calls InputContext.removeNotify
+ */
+ private void removeNotifyInputContext() {
+ if (!inputMethodsEnabled) {
+ return;
+ }
+ InputContext ic = getInputContext();
+ if (ic != null) {
+ //???AWT: ic.removeNotify(this);
+ }
+ }
+
+ /**
+ * This method is called when some property of a component changes, making
+ * it unfocusable, e. g. hide(), removeNotify(), setEnabled(false),
+ * setFocusable(false) is called, and therefore automatic forward focus
+ * traversal is necessary
+ */
+ //???AWT
+ /*
+ void moveFocus() {
+ // don't use transferFocus(), but query focus traversal policy directly
+ // and if it returns null, transfer focus up cycle
+ // and find next focusable component there
+ KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
+ Container root = kfm.getCurrentFocusCycleRoot();
+ Component nextComp = this;
+ boolean success = !isFocusOwner();
+ while (!success) {
+ if (root != nextComp.getFocusCycleRootAncestor()) {
+ // component was probably removed from container
+ // so focus will be lost in some time
+ return;
+ }
+ nextComp = root.getFocusTraversalPolicy().getComponentAfter(root, nextComp);
+ if (nextComp == this) {
+ nextComp = null; // avoid looping
+ }
+ if (nextComp != null) {
+ success = nextComp.requestFocusInWindow();
+ } else {
+ nextComp = root;
+ root = root.getFocusCycleRootAncestor();
+ // if no acceptable component is found at all - clear global
+ // focus owner
+ if (root == null) {
+ if (nextComp instanceof Window) {
+ Window wnd = (Window) nextComp;
+ wnd.setFocusOwner(null);
+ wnd.setRequestedFocus(null);
+ }
+ kfm.clearGlobalFocusOwner();
+ return;
+ }
+ }
+ }
+ }
+ */
+
+ /**
+ * For Container there's a difference between moving focus when being made
+ * invisible or made unfocusable in some other way, because when container
+ * is made invisible, component still remains visible, i. e. its hide() or
+ * setVisible() is not called.
+ */
+ void moveFocusOnHide() {
+ //???AWT: moveFocus();
+ }
+
+ /**
+ * Removes the property change listener registered for this component.
+ *
+ * @param listener the PropertyChangeListener.
+ */
+ public void removePropertyChangeListener(PropertyChangeListener listener) {
+ getPropertyChangeSupport().removePropertyChangeListener(listener);
+ }
+
+ /**
+ * Removes the property change listener registered fot this component
+ * for the specified propertyy.
+ *
+ * @param propertyName the property name.
+ * @param listener the PropertyChangeListener.
+ */
+ public void removePropertyChangeListener(String propertyName,
+ PropertyChangeListener listener) {
+ getPropertyChangeSupport().removePropertyChangeListener(propertyName, listener);
+ }
+
+
+ /**
+ * Repaints the specified rectangle of this component within
+ * tm milliseconds.
+ *
+ * @param tm the time in milliseconds before updating.
+ * @param x the x coordinate of Rectangle.
+ * @param y the y coordinate of Rectangle.
+ * @param width the width of Rectangle.
+ * @param height the height of Rectangle.
+ */
+ public void repaint(long tm, int x, int y, int width, int height) {
+ //???AWT
+ /*
+ toolkit.lockAWT();
+ try {
+ if (width <= 0 || height <= 0 || (redrawManager == null) || !isShowing()) {
+ return;
+ }
+ if (behaviour instanceof LWBehavior) {
+ if (parent == null || !parent.visible || !parent.behaviour.isDisplayable()) {
+ return;
+ }
+ if (repaintRegion == null) {
+ repaintRegion = new MultiRectArea(new Rectangle(x, y, width, height));
+ }
+ repaintRegion.intersect(new Rectangle(0, 0, this.w, this.h));
+ repaintRegion.translate(this.x, this.y);
+ parent.repaintRegion = repaintRegion;
+ repaintRegion = null;
+ parent.repaint(tm, x + this.x, y + this.y, width, height);
+ } else {
+ if (repaintRegion != null) {
+ redrawManager.addUpdateRegion(this, repaintRegion);
+ repaintRegion = null;
+ } else {
+ redrawManager.addUpdateRegion(this, new Rectangle(x, y, width, height));
+ }
+ toolkit.getSystemEventQueueCore().notifyEventMonitor(toolkit);
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ */
+ }
+
+ /**
+ * Post event.
+ *
+ * @param e the e
+ */
+ void postEvent(AWTEvent e) {
+ getToolkit().getSystemEventQueueImpl().postEvent(e);
+ }
+
+ /**
+ * Repaints the specified Rectangle of this Component.
+ *
+ * @param x the x coordinate of Rectangle.
+ * @param y the y coordinate of Rectangle.
+ * @param width the width of Rectangle.
+ * @param height the height of Rectangle.
+ */
+ public void repaint(int x, int y, int width, int height) {
+ toolkit.lockAWT();
+ try {
+ repaint(0, x, y, width, height);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Repaints this component.
+ */
+ public void repaint() {
+ toolkit.lockAWT();
+ try {
+ if (w > 0 && h > 0) {
+ repaint(0, 0, 0, w, h);
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Repaints the component within tm milliseconds.
+ *
+ * @param tm the time in milliseconds before updating.
+ */
+ public void repaint(long tm) {
+ toolkit.lockAWT();
+ try {
+ repaint(tm, 0, 0, w, h);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Requests that this Component get the input focus temporarily.
+ * This component must be displayable, visible, and focusable.
+ *
+ * @param temporary this parameter is true if the focus change
+ * is temporary, when the window loses the focus.
+ *
+ * @return true if the focus change request is succeeded,
+ * false otherwise.
+ */
+ protected boolean requestFocus(boolean temporary) {
+ toolkit.lockAWT();
+ try {
+ //???AWT: return requestFocusImpl(temporary, true, false);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ //???AWT
+ return false;
+ }
+
+ /**
+ * Requests that this Component get the input focus.
+ * This component must be displayable, visible, and focusable.
+ */
+ public void requestFocus() {
+ toolkit.lockAWT();
+ try {
+ requestFocus(false);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ //???AWT
+ /*
+ protected boolean requestFocusInWindow(boolean temporary) {
+ toolkit.lockAWT();
+ try {
+ Window wnd = getWindowAncestor();
+ if ((wnd == null) || !wnd.isFocused()) {
+ return false;
+ }
+ return requestFocusImpl(temporary, false, false);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ boolean requestFocusImpl(boolean temporary, boolean crossWindow, boolean rejectionRecovery) {
+ if (!rejectionRecovery && isFocusOwner()) {
+ return true;
+ }
+ Window wnd = getWindowAncestor();
+ Container par = getRealParent();
+ if ((par != null) && par.isRemoved) {
+ return false;
+ }
+ if (!isShowing() || !isFocusable() || !wnd.isFocusableWindow()) {
+ return false;
+ }
+ return KeyboardFocusManager.getCurrentKeyboardFocusManager().requestFocus(this,
+ temporary, crossWindow, true);
+ }
+
+ public boolean requestFocusInWindow() {
+ toolkit.lockAWT();
+ try {
+ return requestFocusInWindow(false);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Deprecated: replaced by setBounds(int, int, int, int) method.
+ *
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ * @param w the width.
+ * @param h the height.
+ *
+ * @deprecated Replaced by setBounds(int, int, int, int) method.
+ */
+ @Deprecated
+ public void reshape(int x, int y, int w, int h) {
+ toolkit.lockAWT();
+ try {
+ setBounds(x, y, w, h, boundsMaskParam, true);
+ boundsMaskParam = 0;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets rectangle for this Component to be the rectangle with the specified
+ * x,y coordinates of the top-left corner and the width and height.
+ *
+ * @param x the x coordinate of the rectangle's top-left corner.
+ * @param y the y coordinate of the rectangle's top-left corner.
+ * @param w the width of rectangle.
+ * @param h the height of rectangle.
+ */
+ public void setBounds(int x, int y, int w, int h) {
+ toolkit.lockAWT();
+ try {
+ reshape(x, y, w, h);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets rectangle for this Component to be the rectangle with the specified
+ * x,y coordinates of the top-left corner and the width and height
+ * and posts the appropriate events.
+ *
+ * @param x the x coordinate of the rectangle's top-left corner.
+ * @param y the y coordinate of the rectangle's top-left corner.
+ * @param w the width of rectangle.
+ * @param h the height of rectangle.
+ * @param bMask the bitmask of bounds options
+ * @param updateBehavior the whether to update the behavoir's bounds as well
+ */
+ void setBounds(int x, int y, int w, int h, int bMask, boolean updateBehavior) {
+ int oldX = this.x;
+ int oldY = this.y;
+ int oldW = this.w;
+ int oldH = this.h;
+ setBoundsFields(x, y, w, h, bMask);
+ // Moved
+ if ((oldX != this.x) || (oldY != this.y)) {
+ //???AWT: invalidateRealParent();
+ postEvent(new ComponentEvent(this, ComponentEvent.COMPONENT_MOVED));
+ spreadHierarchyBoundsEvents(this, HierarchyEvent.ANCESTOR_MOVED);
+ }
+ // Resized
+ if ((oldW != this.w) || (oldH != this.h)) {
+ invalidate();
+ postEvent(new ComponentEvent(this, ComponentEvent.COMPONENT_RESIZED));
+ spreadHierarchyBoundsEvents(this, HierarchyEvent.ANCESTOR_RESIZED);
+ }
+ if (updateBehavior) {
+ behaviour.setBounds(this.x, this.y, this.w, this.h, bMask);
+ }
+ notifyInputMethod(new Rectangle(x, y, w, h));
+ }
+
+ /**
+ * Calls InputContextImpl.notifyClientWindowChanged.
+ *
+ * @param bounds the bounds
+ */
+ void notifyInputMethod(Rectangle bounds) {
+ // only Window actually notifies IM of bounds change
+ }
+
+ /**
+ * Sets the bounds fields.
+ *
+ * @param x the x
+ * @param y the y
+ * @param w the w
+ * @param h the h
+ * @param bMask the b mask
+ */
+ private void setBoundsFields(int x, int y, int w, int h, int bMask) {
+ if ((bMask & NativeWindow.BOUNDS_NOSIZE) == 0) {
+ this.w = w;
+ this.h = h;
+ }
+ if ((bMask & NativeWindow.BOUNDS_NOMOVE) == 0) {
+ this.x = x;
+ this.y = y;
+ }
+ }
+
+ /**
+ * Gets the native insets.
+ *
+ * @return the native insets
+ */
+ Insets getNativeInsets() {
+ return new Insets(0, 0, 0, 0);
+ }
+
+ /**
+ * Gets the insets.
+ *
+ * @return the insets
+ */
+ Insets getInsets() {
+ return new Insets(0, 0, 0, 0);
+ }
+
+ /**
+ * Checks if is mouse exited expected.
+ *
+ * @return true, if is mouse exited expected
+ */
+ boolean isMouseExitedExpected() {
+ return mouseExitedExpected;
+ }
+
+ /**
+ * Sets the mouse exited expected.
+ *
+ * @param expected the new mouse exited expected
+ */
+ void setMouseExitedExpected(boolean expected) {
+ mouseExitedExpected = expected;
+ }
+
+ /**
+ * Sets the new bounding rectangle for this Component.
+ *
+ * @param r the new bounding rectangle.
+ */
+ public void setBounds(Rectangle r) {
+ toolkit.lockAWT();
+ try {
+ setBounds(r.x, r.y, r.width, r.height);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the component orientation which affects the component's
+ * elements and text within this component.
+ *
+ * @param o the ComponentOrientation object.
+ */
+ public void setComponentOrientation(ComponentOrientation o) {
+ ComponentOrientation oldOrientation;
+ toolkit.lockAWT();
+ try {
+ oldOrientation = orientation;
+ orientation = o;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("componentOrientation", oldOrientation, orientation); //$NON-NLS-1$
+ invalidate();
+ }
+
+ /**
+ * Sets the specified cursor for this Component.
+ *
+ * @param cursor the new Cursor.
+ */
+ public void setCursor(Cursor cursor) {
+ toolkit.lockAWT();
+ try {
+ this.cursor = cursor;
+ setCursor();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Set current cursor shape to Component's Cursor.
+ */
+ void setCursor() {
+ if (isDisplayable() && isShowing()) {
+ Rectangle absRect = new Rectangle(getLocationOnScreen(), getSize());
+ Point absPointerPos = toolkit.dispatcher.mouseDispatcher.getPointerPos();
+ //???AWT
+ /*
+ if (absRect.contains(absPointerPos)) {
+ // set Cursor only on top-level Windows(on X11)
+ Window topLevelWnd = getWindowAncestor();
+ if (topLevelWnd != null) {
+ Point pointerPos = MouseDispatcher.convertPoint(null, absPointerPos,
+ topLevelWnd);
+ Component compUnderCursor = topLevelWnd.findComponentAt(pointerPos);
+ // if (compUnderCursor == this ||
+ // compUnderCursor.getCursorAncestor() == this) {
+ NativeWindow wnd = topLevelWnd.getNativeWindow();
+ if (compUnderCursor != null && wnd != null) {
+ compUnderCursor.getRealCursor().getNativeCursor()
+ .setCursor(wnd.getId());
+ }
+ // }
+ }
+ }
+ */
+ }
+ }
+
+ /**
+ * Gets the ancestor Cursor if Component is disabled (directly or via an
+ * ancestor) even if Cursor is explicitly set.
+ *
+ * @param value the value
+ *
+ * @return actual Cursor to be displayed
+ */
+ //???AWT
+ /*
+ Cursor getRealCursor() {
+ Component cursorAncestor = getCursorAncestor();
+ return cursorAncestor != null ? cursorAncestor.getCursor() : Cursor.getDefaultCursor();
+ }
+ */
+
+ /**
+ * Gets the ancestor(or component itself) whose cursor is set when pointer
+ * is inside component
+ *
+ * @return actual Cursor to be displayed
+ */
+ //???AWT
+ /*
+ Component getCursorAncestor() {
+ Component comp;
+ for (comp = this; comp != null; comp = comp.getParent()) {
+ if (comp instanceof Window || comp.isCursorSet() && comp.isKeyEnabled()) {
+ return comp;
+ }
+ }
+ return null;
+ }
+
+ public void setDropTarget(DropTarget dt) {
+ toolkit.lockAWT();
+ try {
+ if (dropTarget == dt) {
+ return;
+ }
+ DropTarget oldDropTarget = dropTarget;
+ dropTarget = dt;
+ if (oldDropTarget != null) {
+ if (behaviour.isDisplayable()) {
+ oldDropTarget.removeNotify(peer);
+ }
+ oldDropTarget.setComponent(null);
+ }
+ if (dt != null) {
+ dt.setComponent(this);
+ if (behaviour.isDisplayable()) {
+ dt.addNotify(peer);
+ }
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Sets this component to the "enabled" or "disabled" state depending
+ * on the specified boolean parameter.
+ *
+ * @param value true if this component should be enabled; false
+ * if this component should be disabled.
+ */
+ public void setEnabled(boolean value) {
+ toolkit.lockAWT();
+ try {
+ enable(value);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the enabled impl.
+ *
+ * @param value the new enabled impl
+ */
+ void setEnabledImpl(boolean value) {
+ if (enabled != value) {
+ enabled = value;
+ setCursor();
+ if (!enabled) {
+ moveFocusOnHide();
+ }
+ behaviour.setEnabled(value);
+ }
+ }
+
+ //???AWT
+ /*
+ private void fireAccessibleStateChange(AccessibleState state, boolean value) {
+ if (behaviour.isLightweight()) {
+ return;
+ }
+ AccessibleContext ac = getAccessibleContext();
+ if (ac != null) {
+ AccessibleState oldValue = null;
+ AccessibleState newValue = null;
+ if (value) {
+ newValue = state;
+ } else {
+ oldValue = state;
+ }
+ ac.firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY, oldValue,
+ newValue);
+ }
+ }
+ */
+
+ //???AWT
+ /*
+ public void setFocusTraversalKeys(int id, Set<? extends AWTKeyStroke> keystrokes) {
+ Set<? extends AWTKeyStroke> oldTraversalKeys;
+ String propName = "FocusTraversalKeys"; //$NON-NLS-1$
+ toolkit.lockAWT();
+ try {
+ Integer kId = new Integer(id);
+ KeyboardFocusManager.checkTraversalKeysID(traversalKeys, kId);
+ Map<Integer, Set<? extends AWTKeyStroke>> keys = new HashMap<Integer, Set<? extends AWTKeyStroke>>();
+ for (int kid : traversalIDs) {
+ Integer key = new Integer(kid);
+ keys.put(key, getFocusTraversalKeys(kid));
+ }
+ KeyboardFocusManager.checkKeyStrokes(traversalIDs, keys, kId, keystrokes);
+ oldTraversalKeys = traversalKeys.get(new Integer(id));
+ // put a copy of keystrokes object into map:
+ Set<? extends AWTKeyStroke> newKeys = keystrokes;
+ if (keystrokes != null) {
+ newKeys = new HashSet<AWTKeyStroke>(keystrokes);
+ }
+ traversalKeys.put(kId, newKeys);
+ String direction = ""; //$NON-NLS-1$
+ switch (id) {
+ case KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS:
+ direction = "forward"; //$NON-NLS-1$
+ break;
+ case KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS:
+ direction = "backward"; //$NON-NLS-1$
+ break;
+ case KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS:
+ direction = "upCycle"; //$NON-NLS-1$
+ break;
+ case KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS:
+ direction = "downCycle"; //$NON-NLS-1$
+ break;
+ }
+ propName = direction + propName;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange(propName, oldTraversalKeys, keystrokes);
+ }
+ */
+
+ /**
+ * Sets the focus traversal keys state for this component.
+ *
+ * @param value true if the focus traversal keys state is enabled,
+ * false if the focus traversal keys state is disabled.
+ */
+ public void setFocusTraversalKeysEnabled(boolean value) {
+ boolean oldFocusTraversalKeysEnabled;
+ toolkit.lockAWT();
+ try {
+ oldFocusTraversalKeysEnabled = focusTraversalKeysEnabled;
+ focusTraversalKeysEnabled = value;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("focusTraversalKeysEnabled", oldFocusTraversalKeysEnabled, //$NON-NLS-1$
+ focusTraversalKeysEnabled);
+ }
+
+ //???AWT
+ /*
+ public void setFocusable(boolean focusable) {
+ boolean oldFocusable;
+ toolkit.lockAWT();
+ try {
+ calledSetFocusable = true;
+ oldFocusable = this.focusable;
+ this.focusable = focusable;
+ if (!focusable) {
+ moveFocus();
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("focusable", oldFocusable, focusable); //$NON-NLS-1$
+ }
+
+ public Font getFont() {
+ toolkit.lockAWT();
+ try {
+ return (font == null) && (parent != null) ? parent.getFont() : font;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Sets the font for this Component.
+ *
+ * @param f the new font of the Component.
+ */
+ public void setFont(Font f) {
+ Font oldFont;
+ toolkit.lockAWT();
+ try {
+ oldFont = font;
+ setFontImpl(f);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("font", oldFont, font); //$NON-NLS-1$
+ }
+
+ /**
+ * Sets the font impl.
+ *
+ * @param f the new font impl
+ */
+ void setFontImpl(Font f) {
+ font = f;
+ invalidate();
+ if (isShowing()) {
+ repaint();
+ }
+ }
+
+
+ /**
+ * Invalidate the component if it inherits the font from the parent. This
+ * method is overridden in Container.
+ *
+ * @return true if the component was invalidated, false otherwise
+ */
+ boolean propagateFont() {
+ if (font == null) {
+ invalidate();
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Sets the foreground color for this Component.
+ *
+ * @param c the new foreground color.
+ */
+ public void setForeground(Color c) {
+ Color oldFgColor;
+ toolkit.lockAWT();
+ try {
+ oldFgColor = foreColor;
+ foreColor = c;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("foreground", oldFgColor, foreColor); //$NON-NLS-1$
+ repaint();
+ }
+
+ /**
+ * Sets the background color for the Component.
+ *
+ * @param c the new background color for this component.
+ */
+ public void setBackground(Color c) {
+ Color oldBkColor;
+ toolkit.lockAWT();
+ try {
+ oldBkColor = backColor;
+ backColor = c;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("background", oldBkColor, backColor); //$NON-NLS-1$
+ repaint();
+ }
+
+ /**
+ * Sets the flag for whether paint messages received from the operating
+ * system should be ignored or not.
+ *
+ * @param value true if paint messages received from the operating
+ * system should be ignored, false otherwise.
+ */
+ public void setIgnoreRepaint(boolean value) {
+ toolkit.lockAWT();
+ try {
+ ignoreRepaint = value;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the locale of the component.
+ *
+ * @param locale the new Locale.
+ */
+ public void setLocale(Locale locale) {
+ Locale oldLocale;
+ toolkit.lockAWT();
+ try {
+ oldLocale = this.locale;
+ this.locale = locale;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("locale", oldLocale, locale); //$NON-NLS-1$
+ }
+
+ /**
+ * Sets the location of the Component to the specified point.
+ *
+ * @param p the new location of the Component
+ */
+ public void setLocation(Point p) {
+ toolkit.lockAWT();
+ try {
+ setLocation(p.x, p.y);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the location of the Component to the specified x, y coordinates.
+ *
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ */
+ public void setLocation(int x, int y) {
+ toolkit.lockAWT();
+ try {
+ move(x, y);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the visibility state of the component.
+ *
+ * @param b true if the component is visible, false if the component
+ * is not shown.
+ */
+ public void setVisible(boolean b) {
+ // show() & hide() are not deprecated for Window,
+ // so have to call them from setVisible()
+ show(b);
+ }
+
+ /**
+ * Deprecated: replaced by setVisible(boolean) method.
+ *
+ * @deprecated Replaced by setVisible(boolean) method.
+ */
+ @Deprecated
+ public void show() {
+ toolkit.lockAWT();
+ try {
+ if (visible) {
+ return;
+ }
+ prepare4HierarchyChange();
+ mapToDisplay(true);
+ validate();
+ visible = true;
+ behaviour.setVisible(true);
+ postEvent(new ComponentEvent(this, ComponentEvent.COMPONENT_SHOWN));
+ //???AWT: finishHierarchyChange(this, parent, 0);
+ notifyInputMethod(new Rectangle(x, y, w, h));
+ //???AWT: invalidateRealParent();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by setVisible(boolean) method.
+ *
+ * @param b the visibility's state.
+ *
+ * @deprecated Replaced by setVisible(boolean) method.
+ */
+ @Deprecated
+ public void show(boolean b) {
+ if (b) {
+ show();
+ } else {
+ hide();
+ }
+ }
+
+ //???AWT
+ /*
+ void transferFocus(int dir) {
+ Container root = null;
+ if (this instanceof Container) {
+ Container cont = (Container) this;
+ if (cont.isFocusCycleRoot()) {
+ root = cont.getFocusTraversalRoot();
+ }
+ }
+ if (root == null) {
+ root = getFocusCycleRootAncestor();
+ }
+ // transfer focus up cycle if root is unreachable
+ Component comp = this;
+ while ((root != null)
+ && !(root.isFocusCycleRoot() && root.isShowing() && root.isEnabled() && root
+ .isFocusable())) {
+ comp = root;
+ root = root.getFocusCycleRootAncestor();
+ }
+ if (root == null) {
+ return;
+ }
+ FocusTraversalPolicy policy = root.getFocusTraversalPolicy();
+ Component nextComp = null;
+ switch (dir) {
+ case KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS:
+ nextComp = policy.getComponentAfter(root, comp);
+ break;
+ case KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS:
+ nextComp = policy.getComponentBefore(root, comp);
+ break;
+ }
+ if (nextComp != null) {
+ nextComp.requestFocus(false);
+ }
+ }
+
+ public void transferFocus() {
+ toolkit.lockAWT();
+ try {
+ nextFocus();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void transferFocusBackward() {
+ toolkit.lockAWT();
+ try {
+ transferFocus(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ public void transferFocusUpCycle() {
+ toolkit.lockAWT();
+ try {
+ KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
+ Container root = kfm.getCurrentFocusCycleRoot();
+
+ if(root == null) {
+ return;
+ }
+
+ boolean success = false;
+ Component nextComp = null;
+ Container newRoot = root;
+ do {
+ nextComp = newRoot instanceof Window ? newRoot.getFocusTraversalPolicy()
+ .getDefaultComponent(newRoot) : newRoot;
+ newRoot = newRoot.getFocusCycleRootAncestor();
+ if (nextComp == null) {
+ break;
+ }
+ success = nextComp.requestFocusInWindow();
+ if (newRoot == null) {
+ break;
+ }
+ kfm.setGlobalCurrentFocusCycleRoot(newRoot);
+ } while (!success);
+ if (!success && root != newRoot) {
+ kfm.setGlobalCurrentFocusCycleRoot(root);
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Validates that this component has a valid layout.
+ */
+ public void validate() {
+ toolkit.lockAWT();
+ try {
+ if (!behaviour.isDisplayable()) {
+ return;
+ }
+ validateImpl();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Validate impl.
+ */
+ void validateImpl() {
+ valid = true;
+ }
+
+ /**
+ * Gets the native window.
+ *
+ * @return the native window
+ */
+ NativeWindow getNativeWindow() {
+ return behaviour.getNativeWindow();
+ }
+
+ /**
+ * Checks whether or not a maximum size is set for the Component.
+ *
+ * @return true, if the maximum size is set for the Component,
+ * false otherwise.
+ */
+ public boolean isMaximumSizeSet() {
+ toolkit.lockAWT();
+ try {
+ return maximumSize != null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not the minimum size is set for the component.
+ *
+ * @return true, if the minimum size is set for the component,
+ * false otherwise.
+ */
+ public boolean isMinimumSizeSet() {
+ toolkit.lockAWT();
+ try {
+ return minimumSize != null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks whether or not the preferred size is set for the Component.
+ *
+ * @return true, if the preferred size is set for the Component,
+ * false otherwise.
+ */
+ public boolean isPreferredSizeSet() {
+ toolkit.lockAWT();
+ try {
+ return preferredSize != null;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the maximum size of the Component.
+ *
+ * @return the maximum size of the Component.
+ */
+ public Dimension getMaximumSize() {
+ toolkit.lockAWT();
+ try {
+ return isMaximumSizeSet() ? new Dimension(maximumSize) : new Dimension(
+ Short.MAX_VALUE, Short.MAX_VALUE);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the minimum size of the Component.
+ *
+ * @return the minimum size of the Component.
+ */
+ public Dimension getMinimumSize() {
+ toolkit.lockAWT();
+ try {
+ return minimumSize();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by getMinimumSize() method.
+ *
+ * @return the Dimension.
+ *
+ * @deprecated Replaced by getMinimumSize() method.
+ */
+ @Deprecated
+ public Dimension minimumSize() {
+ toolkit.lockAWT();
+ try {
+ if (isMinimumSizeSet()) {
+ return (Dimension)minimumSize.clone();
+ }
+ Dimension defSize = getDefaultMinimumSize();
+ if (defSize != null) {
+ return (Dimension)defSize.clone();
+ }
+ return isDisplayable()? new Dimension(1, 1) : new Dimension(w, h);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the preferred size of the Component.
+ *
+ * @return the preferred size of the Component.
+ */
+ public Dimension getPreferredSize() {
+ toolkit.lockAWT();
+ try {
+ return preferredSize();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Deprecated: replaced by getPreferredSize() method.
+ *
+ * @return the Dimension.
+ *
+ * @deprecated Replaced by getPreferredSize() method.
+ */
+ @Deprecated
+ public Dimension preferredSize() {
+ toolkit.lockAWT();
+ try {
+ if (isPreferredSizeSet()) {
+ return new Dimension(preferredSize);
+ }
+ Dimension defSize = getDefaultPreferredSize();
+ if (defSize != null) {
+ return new Dimension(defSize);
+ }
+ return new Dimension(getMinimumSize());
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the maximum size of the Component.
+ *
+ * @param maximumSize the new maximum size of the Component.
+ */
+ public void setMaximumSize(Dimension maximumSize) {
+ Dimension oldMaximumSize;
+ toolkit.lockAWT();
+ try {
+ oldMaximumSize = this.maximumSize;
+ if (oldMaximumSize != null) {
+ oldMaximumSize = oldMaximumSize.getSize();
+ }
+ if (this.maximumSize == null) {
+ if (maximumSize != null) {
+ this.maximumSize = new Dimension(maximumSize);
+ }
+ } else {
+ if (maximumSize != null) {
+ this.maximumSize.setSize(maximumSize);
+ } else {
+ this.maximumSize = null;
+ }
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("maximumSize", oldMaximumSize, this.maximumSize); //$NON-NLS-1$
+ toolkit.lockAWT();
+ try {
+ //???AWT: invalidateRealParent();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the minimum size of the Component.
+ *
+ * @param minimumSize the new minimum size of the Component.
+ */
+ public void setMinimumSize(Dimension minimumSize) {
+ Dimension oldMinimumSize;
+ toolkit.lockAWT();
+ try {
+ oldMinimumSize = this.minimumSize;
+ if (oldMinimumSize != null) {
+ oldMinimumSize = oldMinimumSize.getSize();
+ }
+ if (this.minimumSize == null) {
+ if (minimumSize != null) {
+ this.minimumSize = new Dimension(minimumSize);
+ }
+ } else {
+ if (minimumSize != null) {
+ this.minimumSize.setSize(minimumSize);
+ } else {
+ this.minimumSize = null;
+ }
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("minimumSize", oldMinimumSize, this.minimumSize); //$NON-NLS-1$
+ toolkit.lockAWT();
+ try {
+ //???AWT: invalidateRealParent();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the preferred size of the Component.
+ *
+ * @param preferredSize the new preferred size of the Component.
+ */
+ public void setPreferredSize(Dimension preferredSize) {
+ Dimension oldPreferredSize;
+ toolkit.lockAWT();
+ try {
+ oldPreferredSize = this.preferredSize;
+ if (oldPreferredSize != null) {
+ oldPreferredSize = oldPreferredSize.getSize();
+ }
+ if (this.preferredSize == null) {
+ if (preferredSize != null) {
+ this.preferredSize = new Dimension(preferredSize);
+ }
+ } else {
+ if (preferredSize != null) {
+ this.preferredSize.setSize(preferredSize);
+ } else {
+ this.preferredSize = null;
+ }
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ firePropertyChange("preferredSize", oldPreferredSize, this.preferredSize); //$NON-NLS-1$
+ toolkit.lockAWT();
+ try {
+ //???AWT: invalidateRealParent();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ //???AWT
+ /*
+ RedrawManager getRedrawManager() {
+ if (parent == null) {
+ return null;
+ }
+ return parent.getRedrawManager();
+ }
+ */
+
+ /**
+ * Checks if is focusability explicitly set.
+ *
+ * @return true if component has a focusable peer
+ */
+ //???AWT
+ /*
+ boolean isPeerFocusable() {
+ // The recommendations for Windows and Unix are that
+ // Canvases, Labels, Panels, Scrollbars, ScrollPanes, Windows,
+ // and lightweight Components have non-focusable peers,
+ // and all other Components have focusable peers.
+ if (this instanceof Canvas || this instanceof Label || this instanceof Panel
+ || this instanceof Scrollbar || this instanceof ScrollPane
+ || this instanceof Window || isLightweight()) {
+ return false;
+ }
+ return true;
+ }
+ */
+
+ /**
+ * @return true if focusability was explicitly set via a call to
+ * setFocusable() or via overriding isFocusable() or
+ * isFocusTraversable()
+ */
+ boolean isFocusabilityExplicitlySet() {
+ return calledSetFocusable || overridenIsFocusable;
+ }
+
+ /**
+ * Paints the component and all of its subcomponents.
+ *
+ * @param g the Graphics to be used for painting.
+ */
+ public void paintAll(Graphics g) {
+ toolkit.lockAWT();
+ try {
+ paint(g);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Updates this Component.
+ *
+ * @param g the Graphics to be used for updating.
+ */
+ public void update(Graphics g) {
+ toolkit.lockAWT();
+ try {
+ if (!isLightweight() && !isPrepainter()) {
+ g.setColor(getBackground());
+ g.fillRect(0, 0, w, h);
+ g.setColor(getForeground());
+ }
+ paint(g);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Paints this component.
+ *
+ * @param g the Graphics to be used for painting.
+ */
+ public void paint(Graphics g) {
+ toolkit.lockAWT();
+ try {
+ // Just to nothing
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Prepares the component to be painted.
+ *
+ * @param g the Graphics to be used for painting.
+ */
+ void prepaint(Graphics g) {
+ // Just to nothing. For overriding.
+ }
+
+ /**
+ * Checks if is prepainter.
+ *
+ * @return true, if is prepainter
+ */
+ boolean isPrepainter() {
+ return false;
+ }
+
+ /**
+ * Prepare4 hierarchy change.
+ */
+ void prepare4HierarchyChange() {
+ if (hierarchyChangingCounter++ == 0) {
+ wasShowing = isShowing();
+ wasDisplayable = isDisplayable();
+ prepareChildren4HierarchyChange();
+ }
+ }
+
+ /**
+ * Prepare children4 hierarchy change.
+ */
+ void prepareChildren4HierarchyChange() {
+ // To be inherited by Container
+ }
+
+ //???AWT
+ /*
+ void finishHierarchyChange(Component changed, Container changedParent, int ancestorFlags) {
+ if (--hierarchyChangingCounter == 0) {
+ int changeFlags = ancestorFlags;
+ if (wasShowing != isShowing()) {
+ changeFlags |= HierarchyEvent.SHOWING_CHANGED;
+ }
+ if (wasDisplayable != isDisplayable()) {
+ changeFlags |= HierarchyEvent.DISPLAYABILITY_CHANGED;
+ }
+ if (changeFlags > 0) {
+ postEvent(new HierarchyEvent(this, HierarchyEvent.HIERARCHY_CHANGED, changed,
+ changedParent, changeFlags));
+ }
+ finishChildrenHierarchyChange(changed, changedParent, ancestorFlags);
+ }
+ }
+
+
+ void finishChildrenHierarchyChange(Component changed, Container changedParent,
+ int ancestorFlags) {
+ // To be inherited by Container
+ }
+
+ void postHierarchyBoundsEvents(Component changed, int id) {
+ postEvent(new HierarchyEvent(this, id, changed, null, 0));
+ }
+ */
+
+ /**
+ * Spread hierarchy bounds events.
+ *
+ * @param changed the changed
+ * @param id the id
+ */
+ void spreadHierarchyBoundsEvents(Component changed, int id) {
+ // To be inherited by Container
+ }
+
+ /**
+ * Dispatches an event to this component.
+ *
+ * @param e the Event.
+ */
+ public final void dispatchEvent(AWTEvent e) {
+ //???AWT
+ /*
+ if (e.isConsumed()) {
+ return;
+ }
+ if (e instanceof PaintEvent) {
+ toolkit.dispatchAWTEvent(e);
+ processPaintEvent((PaintEvent) e);
+ return;
+ }
+ KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
+ if (!e.dispatchedByKFM && kfm.dispatchEvent(e)) {
+ return;
+ }
+ if (e instanceof KeyEvent) {
+ KeyEvent ke = (KeyEvent) e;
+ // consumes KeyEvent which represents a focus traversal key
+ if (getFocusTraversalKeysEnabled()) {
+ kfm.processKeyEvent(this, ke);
+ if (ke.isConsumed()) {
+ return;
+ }
+ }
+ }
+ if (inputMethodsEnabled && dispatchToIM && e.isPosted && dispatchEventToIM(e)) {
+ return;
+ }
+ if (e.getID() == WindowEvent.WINDOW_ICONIFIED) {
+ notifyInputMethod(null);
+ }
+ AWTEvent.EventDescriptor descriptor = toolkit.eventTypeLookup.getEventDescriptor(e);
+ toolkit.dispatchAWTEvent(e);
+ if (descriptor != null) {
+ if (isEventEnabled(descriptor.eventMask)
+ || (getListeners(descriptor.listenerType).length > 0)) {
+ processEvent(e);
+ }
+ // input events can be consumed by user listeners:
+ if (!e.isConsumed() && ((enabledAWTEvents & descriptor.eventMask) != 0)) {
+ postprocessEvent(e, descriptor.eventMask);
+ }
+ }
+ postDeprecatedEvent(e);
+ */
+ }
+
+ /**
+ * Post deprecated event.
+ *
+ * @param e the e
+ */
+ private void postDeprecatedEvent(AWTEvent e) {
+ if (deprecatedEventHandler) {
+ Event evt = e.getEvent();
+ if (evt != null) {
+ postEvent(evt);
+ }
+ }
+ }
+
+ /**
+ * Postprocess event.
+ *
+ * @param e the e
+ * @param eventMask the event mask
+ */
+ void postprocessEvent(AWTEvent e, long eventMask) {
+ toolkit.lockAWT();
+ try {
+ // call system listeners under AWT lock
+ if (eventMask == AWTEvent.FOCUS_EVENT_MASK) {
+ preprocessFocusEvent((FocusEvent) e);
+ } else if (eventMask == AWTEvent.KEY_EVENT_MASK) {
+ preprocessKeyEvent((KeyEvent) e);
+ } else if (eventMask == AWTEvent.MOUSE_EVENT_MASK) {
+ preprocessMouseEvent((MouseEvent) e);
+ } else if (eventMask == AWTEvent.MOUSE_MOTION_EVENT_MASK) {
+ preprocessMouseMotionEvent((MouseEvent) e);
+ } else if (eventMask == AWTEvent.COMPONENT_EVENT_MASK) {
+ preprocessComponentEvent((ComponentEvent) e);
+ } else if (eventMask == AWTEvent.MOUSE_WHEEL_EVENT_MASK) {
+ preprocessMouseWheelEvent((MouseWheelEvent) e);
+ } else if (eventMask == AWTEvent.INPUT_METHOD_EVENT_MASK) {
+ preprocessInputMethodEvent((InputMethodEvent) e);
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Preprocess input method event.
+ *
+ * @param e the e
+ */
+ private void preprocessInputMethodEvent(InputMethodEvent e) {
+ processInputMethodEventImpl(e, inputMethodListeners.getSystemListeners());
+ }
+
+ /**
+ * Preprocess mouse wheel event.
+ *
+ * @param e the e
+ */
+ private void preprocessMouseWheelEvent(MouseWheelEvent e) {
+ processMouseWheelEventImpl(e, mouseWheelListeners.getSystemListeners());
+ }
+
+ /**
+ * Process mouse wheel event impl.
+ *
+ * @param e the e
+ * @param c the c
+ */
+ private void processMouseWheelEventImpl(MouseWheelEvent e, Collection<MouseWheelListener> c) {
+ for (MouseWheelListener listener : c) {
+ switch (e.getID()) {
+ case MouseEvent.MOUSE_WHEEL:
+ listener.mouseWheelMoved(e);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Preprocess component event.
+ *
+ * @param e the e
+ */
+ private void preprocessComponentEvent(ComponentEvent e) {
+ processComponentEventImpl(e, componentListeners.getSystemListeners());
+ }
+
+ /**
+ * Preprocess mouse motion event.
+ *
+ * @param e the e
+ */
+ void preprocessMouseMotionEvent(MouseEvent e) {
+ processMouseMotionEventImpl(e, mouseMotionListeners.getSystemListeners());
+ }
+
+ /**
+ * Preprocess mouse event.
+ *
+ * @param e the e
+ */
+ void preprocessMouseEvent(MouseEvent e) {
+ processMouseEventImpl(e, mouseListeners.getSystemListeners());
+ }
+
+ /**
+ * Preprocess key event.
+ *
+ * @param e the e
+ */
+ void preprocessKeyEvent(KeyEvent e) {
+ processKeyEventImpl(e, keyListeners.getSystemListeners());
+ }
+
+ /**
+ * Preprocess focus event.
+ *
+ * @param e the e
+ */
+ void preprocessFocusEvent(FocusEvent e) {
+ processFocusEventImpl(e, focusListeners.getSystemListeners());
+ }
+
+ /**
+ * Processes AWTEvent occurred on this component.
+ *
+ * @param e the AWTEvent.
+ */
+ protected void processEvent(AWTEvent e) {
+ long eventMask = toolkit.eventTypeLookup.getEventMask(e);
+ if (eventMask == AWTEvent.COMPONENT_EVENT_MASK) {
+ processComponentEvent((ComponentEvent) e);
+ } else if (eventMask == AWTEvent.FOCUS_EVENT_MASK) {
+ processFocusEvent((FocusEvent) e);
+ } else if (eventMask == AWTEvent.KEY_EVENT_MASK) {
+ processKeyEvent((KeyEvent) e);
+ } else if (eventMask == AWTEvent.MOUSE_EVENT_MASK) {
+ processMouseEvent((MouseEvent) e);
+ } else if (eventMask == AWTEvent.MOUSE_WHEEL_EVENT_MASK) {
+ processMouseWheelEvent((MouseWheelEvent) e);
+ } else if (eventMask == AWTEvent.MOUSE_MOTION_EVENT_MASK) {
+ processMouseMotionEvent((MouseEvent) e);
+ } else if (eventMask == AWTEvent.HIERARCHY_EVENT_MASK) {
+ processHierarchyEvent((HierarchyEvent) e);
+ } else if (eventMask == AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) {
+ processHierarchyBoundsEvent((HierarchyEvent) e);
+ } else if (eventMask == AWTEvent.INPUT_METHOD_EVENT_MASK) {
+ processInputMethodEvent((InputMethodEvent) e);
+ }
+ }
+
+ /**
+ * Gets an array of all listener's objects based on the specified
+ * listener type and registered to this Component.
+ *
+ * @param listenerType the listener type.
+ *
+ * @return an array of all listener's objects based on the specified
+ * listener type and registered to this Component.
+ */
+ @SuppressWarnings("unchecked")
+ public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+ if (ComponentListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getComponentListeners();
+ } else if (FocusListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getFocusListeners();
+ } else if (HierarchyBoundsListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getHierarchyBoundsListeners();
+ } else if (HierarchyListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getHierarchyListeners();
+ } else if (InputMethodListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getInputMethodListeners();
+ } else if (KeyListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getKeyListeners();
+ } else if (MouseWheelListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getMouseWheelListeners();
+ } else if (MouseMotionListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getMouseMotionListeners();
+ } else if (MouseListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getMouseListeners();
+ } else if (PropertyChangeListener.class.isAssignableFrom(listenerType)) {
+ return (T[]) getPropertyChangeListeners();
+ }
+ return (T[]) Array.newInstance(listenerType, 0);
+ }
+
+ /**
+ * Process paint event.
+ *
+ * @param event the event
+ */
+ private void processPaintEvent(PaintEvent event) {
+ if (redrawManager == null) {
+ return;
+ }
+ Rectangle clipRect = event.getUpdateRect();
+ if ((clipRect.width <= 0) || (clipRect.height <= 0)) {
+ return;
+ }
+ Graphics g = getGraphics();
+ if (g == null) {
+ return;
+ }
+ initGraphics(g, event);
+ if (!getIgnoreRepaint()) {
+ if (event.getID() == PaintEvent.PAINT) {
+ paint(g);
+ } else {
+ update(g);
+ }
+ }
+ g.dispose();
+ }
+
+ /**
+ * Inits the graphics.
+ *
+ * @param g the g
+ * @param e the e
+ */
+ void initGraphics(Graphics g, PaintEvent e) {
+ Rectangle clip = e.getUpdateRect();
+ if (clip instanceof ClipRegion) {
+ g.setClip(((ClipRegion) clip).getClip());
+ } else {
+ g.setClip(clip);
+ }
+ if (isPrepainter()) {
+ prepaint(g);
+ } else if (!isLightweight() && (e.getID() == PaintEvent.PAINT)) {
+ g.setColor(getBackground());
+ g.fillRect(0, 0, w, h);
+ }
+ g.setFont(getFont());
+ g.setColor(getForeground());
+ }
+
+ /**
+ * Enables the events with the specified event mask to be delivered to
+ * this component.
+ *
+ * @param eventsToEnable the events mask which specifies the types
+ * of events to enable.
+ */
+ protected final void enableEvents(long eventsToEnable) {
+ toolkit.lockAWT();
+ try {
+ enabledEvents |= eventsToEnable;
+ deprecatedEventHandler = false;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Enable awt events.
+ *
+ * @param eventsToEnable the events to enable
+ */
+ private void enableAWTEvents(long eventsToEnable) {
+ enabledAWTEvents |= eventsToEnable;
+ }
+
+ /**
+ * Disables the events with types specified by the specified event mask
+ * from being delivered to this component.
+ *
+ * @param eventsToDisable the event mask specifying the event types.
+ */
+ protected final void disableEvents(long eventsToDisable) {
+ toolkit.lockAWT();
+ try {
+ enabledEvents &= ~eventsToDisable;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /*
+ * For use in MouseDispatcher only. Really it checks not only mouse events.
+ */
+ /**
+ * Checks if is mouse event enabled.
+ *
+ * @param eventMask the event mask
+ *
+ * @return true, if is mouse event enabled
+ */
+ boolean isMouseEventEnabled(long eventMask) {
+ return (isEventEnabled(eventMask) || (enabledAWTEvents & eventMask) != 0);
+ }
+
+ /**
+ * Checks if is event enabled.
+ *
+ * @param eventMask the event mask
+ *
+ * @return true, if is event enabled
+ */
+ boolean isEventEnabled(long eventMask) {
+ return ((enabledEvents & eventMask) != 0);
+ }
+
+ /**
+ * Enables or disables input method support for this component.
+ *
+ * @param enable true to enable input method support, false to disable it.
+ */
+ public void enableInputMethods(boolean enable) {
+ toolkit.lockAWT();
+ try {
+ if (!enable) {
+ removeNotifyInputContext();
+ }
+ inputMethodsEnabled = enable;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets an array of all component's listeners registered for this
+ * component.
+ *
+ * @return an array of all component's listeners registered for this
+ * component.
+ */
+ public ComponentListener[] getComponentListeners() {
+ return componentListeners.getUserListeners(new ComponentListener[0]);
+ }
+
+ /**
+ * Adds the specified component listener to the Component for receiving
+ * component's event.
+ *
+ * @param l the ComponentListener.
+ */
+ public void addComponentListener(ComponentListener l) {
+ componentListeners.addUserListener(l);
+ }
+
+ /**
+ * Removes the component listener registered for this Component.
+ *
+ * @param l the ComponentListener.
+ */
+ public void removeComponentListener(ComponentListener l) {
+ componentListeners.removeUserListener(l);
+ }
+
+ /**
+ * Processes a component event that has occurred on this component
+ * by dispatching them to any registered ComponentListener objects.
+ *
+ * @param e the ComponentEvent.
+ */
+ protected void processComponentEvent(ComponentEvent e) {
+ processComponentEventImpl(e, componentListeners.getUserListeners());
+ }
+
+ /**
+ * Process component event impl.
+ *
+ * @param e the e
+ * @param c the c
+ */
+ private void processComponentEventImpl(ComponentEvent e, Collection<ComponentListener> c) {
+ for (ComponentListener listener : c) {
+ switch (e.getID()) {
+ case ComponentEvent.COMPONENT_HIDDEN:
+ listener.componentHidden(e);
+ break;
+ case ComponentEvent.COMPONENT_MOVED:
+ listener.componentMoved(e);
+ break;
+ case ComponentEvent.COMPONENT_RESIZED:
+ listener.componentResized(e);
+ break;
+ case ComponentEvent.COMPONENT_SHOWN:
+ listener.componentShown(e);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Gets an array of focus listeners registered for this Component.
+ *
+ * @return the array of focus listeners registered for this Component.
+ */
+ public FocusListener[] getFocusListeners() {
+ return focusListeners.getUserListeners(new FocusListener[0]);
+ }
+
+ /**
+ * Adds the specified focus listener to the Component for receiving
+ * focus events.
+ *
+ * @param l the FocusListener.
+ */
+ public void addFocusListener(FocusListener l) {
+ focusListeners.addUserListener(l);
+ }
+
+ /**
+ * Adds the awt focus listener.
+ *
+ * @param l the l
+ */
+ void addAWTFocusListener(FocusListener l) {
+ enableAWTEvents(AWTEvent.FOCUS_EVENT_MASK);
+ focusListeners.addSystemListener(l);
+ }
+
+ /**
+ * Removes the focus listener registered for this Component.
+ *
+ * @param l the FocusListener.
+ */
+ public void removeFocusListener(FocusListener l) {
+ focusListeners.removeUserListener(l);
+ }
+
+ /**
+ * Processes a FocusEvent that has occurred on this component
+ * by dispatching it to the registered listeners.
+ *
+ * @param e the FocusEvent.
+ */
+ protected void processFocusEvent(FocusEvent e) {
+ processFocusEventImpl(e, focusListeners.getUserListeners());
+ }
+
+ /**
+ * Process focus event impl.
+ *
+ * @param e the e
+ * @param c the c
+ */
+ private void processFocusEventImpl(FocusEvent e, Collection<FocusListener> c) {
+ for (FocusListener listener : c) {
+ switch (e.getID()) {
+ case FocusEvent.FOCUS_GAINED:
+ listener.focusGained(e);
+ break;
+ case FocusEvent.FOCUS_LOST:
+ listener.focusLost(e);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Gets an array of registered HierarchyListeners for
+ * this Component.
+ *
+ * @return an array of registered HierarchyListeners for
+ * this Component.
+ */
+ public HierarchyListener[] getHierarchyListeners() {
+ return hierarchyListeners.getUserListeners(new HierarchyListener[0]);
+ }
+
+ /**
+ * Adds the specified hierarchy listener.
+ *
+ * @param l the HierarchyListener.
+ */
+ public void addHierarchyListener(HierarchyListener l) {
+ hierarchyListeners.addUserListener(l);
+ }
+
+ /**
+ * Removes the hierarchy listener registered for this component.
+ *
+ * @param l the HierarchyListener.
+ */
+ public void removeHierarchyListener(HierarchyListener l) {
+ hierarchyListeners.removeUserListener(l);
+ }
+
+ /**
+ * Processes a hierarchy event that has occurred on this component
+ * by dispatching it to the registered listeners.
+ *
+ * @param e the HierarchyEvent.
+ */
+ protected void processHierarchyEvent(HierarchyEvent e) {
+ for (HierarchyListener listener : hierarchyListeners.getUserListeners()) {
+ switch (e.getID()) {
+ case HierarchyEvent.HIERARCHY_CHANGED:
+ listener.hierarchyChanged(e);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Gets an array of HierarchyBoundsListener objects registered
+ * to this Component.
+ *
+ * @return an array of HierarchyBoundsListener objects.
+ */
+ public HierarchyBoundsListener[] getHierarchyBoundsListeners() {
+ return hierarchyBoundsListeners.getUserListeners(new HierarchyBoundsListener[0]);
+ }
+
+ /**
+ * Adds the specified hierarchy bounds listener.
+ *
+ * @param l the HierarchyBoundsListener.
+ */
+ public void addHierarchyBoundsListener(HierarchyBoundsListener l) {
+ hierarchyBoundsListeners.addUserListener(l);
+ }
+
+ /**
+ * Removes the hierarchy bounds listener registered for this Component.
+ *
+ * @param l the HierarchyBoundsListener.
+ */
+ public void removeHierarchyBoundsListener(HierarchyBoundsListener l) {
+ hierarchyBoundsListeners.removeUserListener(l);
+ }
+
+ /**
+ * Processes a hierarchy bounds event that has occurred on this component
+ * by dispatching it to the registered listeners.
+ *
+ * @param e the HierarchyBoundsEvent.
+ */
+ protected void processHierarchyBoundsEvent(HierarchyEvent e) {
+ for (HierarchyBoundsListener listener : hierarchyBoundsListeners.getUserListeners()) {
+ switch (e.getID()) {
+ case HierarchyEvent.ANCESTOR_MOVED:
+ listener.ancestorMoved(e);
+ break;
+ case HierarchyEvent.ANCESTOR_RESIZED:
+ listener.ancestorResized(e);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Gets an array of the key listeners registered to the Component.
+ *
+ * @return an array of the key listeners registered to the Component.
+ */
+ public KeyListener[] getKeyListeners() {
+ return keyListeners.getUserListeners(new KeyListener[0]);
+ }
+
+ /**
+ * Adds the specified key listener.
+ *
+ * @param l the KeyListener.
+ */
+ public void addKeyListener(KeyListener l) {
+ keyListeners.addUserListener(l);
+ }
+
+ /**
+ * Adds the awt key listener.
+ *
+ * @param l the l
+ */
+ void addAWTKeyListener(KeyListener l) {
+ enableAWTEvents(AWTEvent.KEY_EVENT_MASK);
+ keyListeners.addSystemListener(l);
+ }
+
+ /**
+ * Removes the key listener registered for this Component.
+ *
+ * @param l the KeyListener.
+ */
+ public void removeKeyListener(KeyListener l) {
+ keyListeners.removeUserListener(l);
+ }
+
+ /**
+ * Processes a key event that has occurred on this component
+ * by dispatching it to the registered listeners.
+ *
+ * @param e the KeyEvent.
+ */
+ protected void processKeyEvent(KeyEvent e) {
+ processKeyEventImpl(e, keyListeners.getUserListeners());
+ }
+
+ /**
+ * Process key event impl.
+ *
+ * @param e the e
+ * @param c the c
+ */
+ private void processKeyEventImpl(KeyEvent e, Collection<KeyListener> c) {
+ for (KeyListener listener : c) {
+ switch (e.getID()) {
+ case KeyEvent.KEY_PRESSED:
+ listener.keyPressed(e);
+ break;
+ case KeyEvent.KEY_RELEASED:
+ listener.keyReleased(e);
+ break;
+ case KeyEvent.KEY_TYPED:
+ listener.keyTyped(e);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Gets an array of the mouse listeners registered to the Component.
+ *
+ * @return an array of the mouse listeners registered to the Component.
+ */
+ public MouseListener[] getMouseListeners() {
+ return mouseListeners.getUserListeners(new MouseListener[0]);
+ }
+
+ /**
+ * Adds the specified mouse listener.
+ *
+ * @param l the MouseListener.
+ */
+ public void addMouseListener(MouseListener l) {
+ mouseListeners.addUserListener(l);
+ }
+
+ /**
+ * Adds the awt mouse listener.
+ *
+ * @param l the l
+ */
+ void addAWTMouseListener(MouseListener l) {
+ enableAWTEvents(AWTEvent.MOUSE_EVENT_MASK);
+ mouseListeners.addSystemListener(l);
+ }
+
+ /**
+ * Adds the awt mouse motion listener.
+ *
+ * @param l the l
+ */
+ void addAWTMouseMotionListener(MouseMotionListener l) {
+ enableAWTEvents(AWTEvent.MOUSE_MOTION_EVENT_MASK);
+ mouseMotionListeners.addSystemListener(l);
+ }
+
+ /**
+ * Adds the awt component listener.
+ *
+ * @param l the l
+ */
+ void addAWTComponentListener(ComponentListener l) {
+ enableAWTEvents(AWTEvent.COMPONENT_EVENT_MASK);
+ componentListeners.addSystemListener(l);
+ }
+
+ /**
+ * Adds the awt input method listener.
+ *
+ * @param l the l
+ */
+ void addAWTInputMethodListener(InputMethodListener l) {
+ enableAWTEvents(AWTEvent.INPUT_METHOD_EVENT_MASK);
+ inputMethodListeners.addSystemListener(l);
+ }
+
+ /**
+ * Adds the awt mouse wheel listener.
+ *
+ * @param l the l
+ */
+ void addAWTMouseWheelListener(MouseWheelListener l) {
+ enableAWTEvents(AWTEvent.MOUSE_WHEEL_EVENT_MASK);
+ mouseWheelListeners.addSystemListener(l);
+ }
+
+ /**
+ * Removes the mouse listener registered for this Component.
+ *
+ * @param l the MouseListener.
+ */
+ public void removeMouseListener(MouseListener l) {
+ mouseListeners.removeUserListener(l);
+ }
+
+ /**
+ * Processes a mouse event that has occurred on this component
+ * by dispatching it to the registered listeners.
+ *
+ * @param e the MouseEvent.
+ */
+ protected void processMouseEvent(MouseEvent e) {
+ processMouseEventImpl(e, mouseListeners.getUserListeners());
+ }
+
+ /**
+ * Process mouse event impl.
+ *
+ * @param e the e
+ * @param c the c
+ */
+ private void processMouseEventImpl(MouseEvent e, Collection<MouseListener> c) {
+ for (MouseListener listener : c) {
+ switch (e.getID()) {
+ case MouseEvent.MOUSE_CLICKED:
+ listener.mouseClicked(e);
+ break;
+ case MouseEvent.MOUSE_ENTERED:
+ listener.mouseEntered(e);
+ break;
+ case MouseEvent.MOUSE_EXITED:
+ listener.mouseExited(e);
+ break;
+ case MouseEvent.MOUSE_PRESSED:
+ listener.mousePressed(e);
+ break;
+ case MouseEvent.MOUSE_RELEASED:
+ listener.mouseReleased(e);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Process mouse motion event impl.
+ *
+ * @param e the e
+ * @param c the c
+ */
+ private void processMouseMotionEventImpl(MouseEvent e, Collection<MouseMotionListener> c) {
+ for (MouseMotionListener listener : c) {
+ switch (e.getID()) {
+ case MouseEvent.MOUSE_DRAGGED:
+ listener.mouseDragged(e);
+ break;
+ case MouseEvent.MOUSE_MOVED:
+ listener.mouseMoved(e);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Gets an array of the mouse motion listeners registered to
+ * the Component.
+ *
+ * @return an array of the MouseMotionListeners registered to
+ * the Component.
+ */
+ public MouseMotionListener[] getMouseMotionListeners() {
+ return mouseMotionListeners.getUserListeners(new MouseMotionListener[0]);
+ }
+
+ /**
+ * Adds the specified mouse motion listener.
+ *
+ * @param l the MouseMotionListener.
+ */
+ public void addMouseMotionListener(MouseMotionListener l) {
+ mouseMotionListeners.addUserListener(l);
+ }
+
+ /**
+ * Removes the mouse motion listener registered for this component.
+ *
+ * @param l the MouseMotionListener.
+ */
+ public void removeMouseMotionListener(MouseMotionListener l) {
+ mouseMotionListeners.removeUserListener(l);
+ }
+
+ /**
+ * Processes a mouse motion event that has occurred on this component
+ * by dispatching it to the registered listeners.
+ *
+ * @param e the MouseEvent.
+ */
+ protected void processMouseMotionEvent(MouseEvent e) {
+ processMouseMotionEventImpl(e, mouseMotionListeners.getUserListeners());
+ }
+
+ /**
+ * Gets an array of the mouse wheel listeners registered to
+ * the Component.
+ *
+ * @return an array of the MouseWheelListeners registered to
+ * the Component.
+ */
+ public MouseWheelListener[] getMouseWheelListeners() {
+ return mouseWheelListeners.getUserListeners(new MouseWheelListener[0]);
+ }
+
+ /**
+ * Adds the specified mouse wheel listener.
+ *
+ * @param l the MouseWheelListener.
+ */
+ public void addMouseWheelListener(MouseWheelListener l) {
+ mouseWheelListeners.addUserListener(l);
+ }
+
+ /**
+ * Removes the mouse wheel listener registered for this component.
+ *
+ * @param l the MouseWheelListener.
+ */
+ public void removeMouseWheelListener(MouseWheelListener l) {
+ mouseWheelListeners.removeUserListener(l);
+ }
+
+ /**
+ * Processes a mouse wheel event that has occurred on this component
+ * by dispatching it to the registered listeners.
+ *
+ * @param e the MouseWheelEvent.
+ */
+ protected void processMouseWheelEvent(MouseWheelEvent e) {
+ processMouseWheelEventImpl(e, mouseWheelListeners.getUserListeners());
+ }
+
+ /**
+ * Gets an array of the InputMethodListener listeners
+ * registered to the Component.
+ *
+ * @return an array of the InputMethodListener listeners
+ * registered to the Component.
+ */
+ public InputMethodListener[] getInputMethodListeners() {
+ return inputMethodListeners.getUserListeners(new InputMethodListener[0]);
+ }
+
+ /**
+ * Adds the specified input method listener.
+ *
+ * @param l the InputMethodListener.
+ */
+ public void addInputMethodListener(InputMethodListener l) {
+ inputMethodListeners.addUserListener(l);
+ }
+
+ /**
+ * Removes the input method listener registered for this component.
+ *
+ * @param l the InputMethodListener.
+ */
+ public void removeInputMethodListener(InputMethodListener l) {
+ inputMethodListeners.removeUserListener(l);
+ }
+
+ /**
+ * Processes an input method event that has occurred on this component
+ * by dispatching it to the registered listeners.
+ *
+ * @param e the InputMethodEvent.
+ */
+ protected void processInputMethodEvent(InputMethodEvent e) {
+ processInputMethodEventImpl(e, inputMethodListeners.getUserListeners());
+ }
+
+ /**
+ * Process input method event impl.
+ *
+ * @param e the e
+ * @param c the c
+ */
+ private void processInputMethodEventImpl(InputMethodEvent e,
+ Collection<InputMethodListener> c) {
+ for (InputMethodListener listener : c) {
+ switch (e.getID()) {
+ case InputMethodEvent.CARET_POSITION_CHANGED:
+ listener.caretPositionChanged(e);
+ break;
+ case InputMethodEvent.INPUT_METHOD_TEXT_CHANGED:
+ listener.inputMethodTextChanged(e);
+ break;
+ }
+ }
+ }
+
+ //???AWT
+ /*
+ public Point getMousePosition() throws HeadlessException {
+ Point absPointerPos = MouseInfo.getPointerInfo().getLocation();
+ Window winUnderPtr = toolkit.dispatcher.mouseDispatcher.findWindowAt(absPointerPos);
+ Point pointerPos = MouseDispatcher.convertPoint(null, absPointerPos, winUnderPtr);
+ boolean isUnderPointer = false;
+ if (winUnderPtr == null) {
+ return null;
+ }
+ isUnderPointer = winUnderPtr.isComponentAt(this, pointerPos);
+ if (isUnderPointer) {
+ return MouseDispatcher.convertPoint(null, absPointerPos, this);
+ }
+ return null;
+ }
+ */
+
+ /**
+ * Set native caret at the given position <br>
+ * Note: this method takes AWT lock inside because it walks through the
+ * component hierarchy.
+ *
+ * @param x the x
+ * @param y the y
+ */
+ void setCaretPos(final int x, final int y) {
+ Runnable r = new Runnable() {
+ public void run() {
+ toolkit.lockAWT();
+ try {
+ setCaretPosImpl(x, y);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ };
+ if (Thread.currentThread() instanceof EventDispatchThread) {
+ r.run();
+ } else {
+ toolkit.getSystemEventQueueImpl().postEvent(new InvocationEvent(this, r));
+ }
+ }
+
+ /**
+ * This method should be called only at event dispatch thread.
+ *
+ * @param x the x
+ * @param y the y
+ */
+ void setCaretPosImpl(int x, int y) {
+ Component c = this;
+ while ((c != null) && c.behaviour.isLightweight()) {
+ x += c.x;
+ y += c.y;
+ //???AWT: c = c.getParent();
+ }
+ if (c == null) {
+ return;
+ }
+ //???AWT
+ /*
+ if (c instanceof Window) {
+ Insets insets = c.getNativeInsets();
+ x -= insets.left;
+ y -= insets.top;
+ }
+ toolkit.getWindowFactory().setCaretPosition(x, y);
+ */
+ }
+
+ // to be overridden in standard components such as Button and List
+ /**
+ * Gets the default minimum size.
+ *
+ * @return the default minimum size
+ */
+ Dimension getDefaultMinimumSize() {
+ return null;
+ }
+
+ // to be overridden in standard components such as Button and List
+ /**
+ * Gets the default preferred size.
+ *
+ * @return the default preferred size
+ */
+ Dimension getDefaultPreferredSize() {
+ return null;
+ }
+
+ // to be overridden in standard components such as Button and List
+ /**
+ * Reset default size.
+ */
+ void resetDefaultSize() {
+ }
+
+ //???AWT
+ /*
+ ComponentBehavior createBehavior() {
+ return new LWBehavior(this);
+ }
+ */
+
+ /**
+ * Gets the default background.
+ *
+ * @return the default background
+ */
+ Color getDefaultBackground() {
+ //???AWT: return getWindowAncestor().getDefaultBackground();
+ return getBackground();
+ }
+
+ /**
+ * Gets the default foreground.
+ *
+ * @return the default foreground
+ */
+ Color getDefaultForeground() {
+ //???AWT return getWindowAncestor().getDefaultForeground();
+ return getForeground();
+ }
+
+ /**
+ * Called when native resource for this component is created (for
+ * heavyweights only).
+ *
+ * @param win the win
+ */
+ void nativeWindowCreated(NativeWindow win) {
+ // to be overridden
+ }
+
+ /**
+ * Determine the component's area hidden behind the windows that have higher
+ * Z-order, including windows of other applications.
+ *
+ * @param image the image
+ * @param destLocation the dest location
+ * @param destSize the dest size
+ * @param source the source
+ *
+ * @return the calculated region, or null if it cannot be determined
+ */
+ //???AWT
+ /*
+ MultiRectArea getObscuredRegion(Rectangle part) {
+ if (!visible || parent == null || !parent.visible) {
+ return null;
+ }
+ Rectangle r = new Rectangle(0, 0, w, h);
+ if (part != null) {
+ r = r.intersection(part);
+ }
+ if (r.isEmpty()) {
+ return null;
+ }
+ r.translate(x, y);
+ MultiRectArea ret = parent.getObscuredRegion(r);
+ if (ret != null) {
+ parent.addObscuredRegions(ret, this);
+ ret.translate(-x, -y);
+ ret.intersect(new Rectangle(0, 0, w, h));
+ }
+ return ret;
+ }
+ */
+
+ //???AWT
+ /*
+ private void readObject(ObjectInputStream stream) throws IOException,
+ ClassNotFoundException {
+ stream.defaultReadObject();
+ FieldsAccessor accessor = new FieldsAccessor(Component.class, this);
+ accessor.set("toolkit", Toolkit.getDefaultToolkit()); //$NON-NLS-1$
+ accessor.set("behaviour", createBehavior()); //$NON-NLS-1$
+ accessor.set("componentLock", new Object()); // $NON-LOCK-1$ //$NON-NLS-1$
+ }
+ */
+
+ final void onDrawImage(Image image, Point destLocation, Dimension destSize, Rectangle source) {
+ ImageParameters imageParams;
+ if (updatedImages == null) {
+ updatedImages = new HashMap<Image, ImageParameters>();
+ }
+ imageParams = updatedImages.get(image);
+ if (imageParams == null) {
+ imageParams = new ImageParameters();
+ updatedImages.put(image, imageParams);
+ }
+ imageParams.addDrawing(destLocation, destSize, source);
+ }
+
+ public boolean imageUpdate(Image img, int infoflags, int x, int y, int w, int h) {
+ toolkit.lockAWT();
+ try {
+ boolean done = false;
+ if ((infoflags & (ALLBITS | FRAMEBITS)) != 0) {
+ done = true;
+ } else if ((infoflags & SOMEBITS) != 0 && incrementalImageUpdate) {
+ done = true;
+ }
+ if (done) {
+ repaint();
+ }
+ return (infoflags & (ABORT | ALLBITS)) == 0;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ //???AWT
+ /*
+ private void invalidateRealParent() {
+ Container realParent = getRealParent();
+ if ((realParent != null) && realParent.isValid()) {
+ realParent.invalidate();
+ }
+ }
+ */
+
+ /**
+ * The Class ImageParameters.
+ */
+ private class ImageParameters {
+
+ /** The drawing params. */
+ private final LinkedList<DrawingParameters> drawingParams = new LinkedList<DrawingParameters>();
+
+ /** The size. */
+ Dimension size = new Dimension(Component.this.w, Component.this.h);
+
+ /**
+ * Adds the drawing.
+ *
+ * @param destLocation the dest location
+ * @param destSize the dest size
+ * @param source the source
+ */
+ void addDrawing(Point destLocation, Dimension destSize, Rectangle source) {
+ drawingParams.add(new DrawingParameters(destLocation, destSize, source));
+ }
+
+ /**
+ * Drawing parameters iterator.
+ *
+ * @return the iterator< drawing parameters>
+ */
+ Iterator<DrawingParameters> drawingParametersIterator() {
+ return drawingParams.iterator();
+ }
+
+ /**
+ * The Class DrawingParameters.
+ */
+ class DrawingParameters {
+
+ /** The dest location. */
+ Point destLocation;
+
+ /** The dest size. */
+ Dimension destSize;
+
+ /** The source. */
+ Rectangle source;
+
+ /**
+ * Instantiates a new drawing parameters.
+ *
+ * @param destLocation the dest location
+ * @param destSize the dest size
+ * @param source the source
+ */
+ DrawingParameters(Point destLocation, Dimension destSize, Rectangle source) {
+ this.destLocation = new Point(destLocation);
+ if (destSize != null) {
+ this.destSize = new Dimension(destSize);
+ } else {
+ this.destSize = null;
+ }
+ if (source != null) {
+ this.source = new Rectangle(source);
+ } else {
+ this.source = null;
+ }
+ }
+ }
+ }
+
+ /**
+ * TextComponent support.
+ *
+ * @param e the e
+ *
+ * @return true, if dispatch event to im
+ */
+ //???AWT
+ /*
+ private TextKit textKit = null;
+
+ TextKit getTextKit() {
+ return textKit;
+ }
+
+ void setTextKit(TextKit kit) {
+ textKit = kit;
+ }
+ */
+
+ /**
+ * TextField support
+ */
+ //???AWT
+ /*
+ private TextFieldKit textFieldKit = null;
+
+ TextFieldKit getTextFieldKit() {
+ return textFieldKit;
+ }
+
+ void setTextFieldKit(TextFieldKit kit) {
+ textFieldKit = kit;
+ }
+ */
+
+ /**
+ * Dispatches input & focus events to input method
+ * context.
+ * @param e event to pass to InputContext.dispatchEvent()
+ * @return true if event was consumed by IM, false otherwise
+ */
+ private boolean dispatchEventToIM(AWTEvent e) {
+ InputContext ic = getInputContext();
+ if (ic == null) {
+ return false;
+ }
+ int id = e.getID();
+ boolean isInputEvent = ((id >= KeyEvent.KEY_FIRST) && (id <= KeyEvent.KEY_LAST))
+ || ((id >= MouseEvent.MOUSE_FIRST) && (id <= MouseEvent.MOUSE_LAST));
+ if (((id >= FocusEvent.FOCUS_FIRST) && (id <= FocusEvent.FOCUS_LAST)) || isInputEvent) {
+ ic.dispatchEvent(e);
+ }
+ return e.isConsumed();
+ }
+}
diff --git a/awt/java/awt/ComponentBehavior.java b/awt/java/awt/ComponentBehavior.java
new file mode 100644
index 0000000..89c9999
--- /dev/null
+++ b/awt/java/awt/ComponentBehavior.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Dmitry A. Durnev
+ * @version $Revision$
+ */
+package java.awt;
+
+import org.apache.harmony.awt.wtk.NativeWindow;
+
+/**
+ * The interface of the helper object that encapsulates the difference
+ * between lightweight and heavyweight components.
+ */
+interface ComponentBehavior {
+
+ void addNotify();
+
+ void setBounds(int x, int y, int w, int h, int bMask);
+
+ void setVisible(boolean b);
+
+ Graphics getGraphics(int translationX, int translationY, int width, int height);
+
+ NativeWindow getNativeWindow();
+
+ boolean isLightweight();
+
+ void onMove(int x, int y);
+
+ boolean isOpaque();
+
+ boolean isDisplayable();
+
+ void setEnabled(boolean value);
+
+ void removeNotify();
+
+ void setZOrder(int newIndex, int oldIndex);
+
+ boolean setFocus(boolean focus, Component opposite);
+}
diff --git a/awt/java/awt/ComponentOrientation.java b/awt/java/awt/ComponentOrientation.java
new file mode 100644
index 0000000..ddb118d
--- /dev/null
+++ b/awt/java/awt/ComponentOrientation.java
@@ -0,0 +1,140 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov, Dmitry A. Durnev
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.io.Serializable;
+import java.util.*;
+
+/**
+ * The ComponentOrientation class specifies the language-sensitive orientation
+ * of component's elements or text. It is used to reflect the differences in this
+ * ordering between different writting systems. The ComponentOrientation class
+ * indicates the orientation of the elements/text in the horizontal direction
+ * ("left to right" or "right to left") and in the vertical direction
+ * ("top to bottom" or "bottom to top").
+ */
+public final class ComponentOrientation implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -4113291392143563828L;
+
+ /**
+ * The Constant LEFT_TO_RIGHT indicates that items run left to right.
+ */
+ public static final ComponentOrientation LEFT_TO_RIGHT = new ComponentOrientation(true, true);
+
+ /**
+ * The Constant RIGHT_TO_LEFT indicates that items run right to left.
+ */
+ public static final ComponentOrientation RIGHT_TO_LEFT = new ComponentOrientation(true, false);
+
+ /** The Constant UNKNOWN indicates that a component's orientation is not set. */
+ public static final ComponentOrientation UNKNOWN = new ComponentOrientation(true, true);
+
+ /** The Constant rlLangs. */
+ private static final Set<String> rlLangs = new HashSet<String>(); //RIGHT_TO_LEFT languages
+
+ /** The horizontal. */
+ private final boolean horizontal;
+
+ /** The left2right. */
+ private final boolean left2right;
+
+ static {
+ rlLangs.add("ar"); //$NON-NLS-1$
+ rlLangs.add("fa"); //$NON-NLS-1$
+ rlLangs.add("iw"); //$NON-NLS-1$
+ rlLangs.add("ur"); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the orientation for the given ResourceBundle's localization.
+ *
+ * @param bdl the ResourceBundle.
+ *
+ * @return the ComponentOrientation.
+ *
+ * @deprecated Use getOrientation(java.util.Locale) method.
+ */
+ @Deprecated
+ public static ComponentOrientation getOrientation(ResourceBundle bdl) {
+ Object obj = null;
+ try {
+ obj = bdl.getObject("Orientation"); //$NON-NLS-1$
+ }
+ catch (MissingResourceException mre) {
+ obj = null;
+ }
+ if (obj instanceof ComponentOrientation) {
+ return (ComponentOrientation) obj;
+ }
+ Locale locale = bdl.getLocale();
+ if (locale == null) {
+ locale = Locale.getDefault();
+ }
+ return getOrientation(locale);
+ }
+
+ /**
+ * Gets the orientation for the specified locale.
+ *
+ * @param locale the specified Locale.
+ *
+ * @return the ComponentOrientation.
+ */
+ public static ComponentOrientation getOrientation(Locale locale) {
+ String lang = locale.getLanguage();
+ return rlLangs.contains(lang) ? RIGHT_TO_LEFT : LEFT_TO_RIGHT;
+ }
+
+ /**
+ * Instantiates a new component orientation.
+ *
+ * @param hor whether the items should be arranged horizontally
+ * @param l2r whether this orientation specifies a left-to-right flow
+ */
+ private ComponentOrientation(boolean hor, boolean l2r) {
+ horizontal = hor;
+ left2right = l2r;
+ }
+
+ /**
+ * Returns true if the text of the of writing systems arranged
+ * horizontally.
+ *
+ * @return true, if the text is written horizontally, false
+ * for a vertical arrangement.
+ */
+ public boolean isHorizontal() {
+ return horizontal;
+ }
+
+ /**
+ * Returns true if the text is arranged from left to right.
+ *
+ * @return true, for writing systems written from left to right;
+ * false for right-to-left.
+ */
+ public boolean isLeftToRight() {
+ return left2right;
+ }
+
+}
diff --git a/awt/java/awt/Composite.java b/awt/java/awt/Composite.java
new file mode 100644
index 0000000..8e5b90a
--- /dev/null
+++ b/awt/java/awt/Composite.java
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.image.ColorModel;
+
+/**
+ * The Composite interface allows the methods to compose a draw primitive
+ * on the graphics area. The classes implementing this interface provides
+ * the rules and a method to create the context for a particular operation.
+ */
+public interface Composite {
+
+ /**
+ * Creates a CompositeContext which defines the encapsulated and
+ * optimized environment for a compositing operation. Several contexts
+ * can exist for a single Composite object.
+ *
+ * @param srcColorModel the source's ColorModel.
+ * @param dstColorModel the destination's ColorModel.
+ * @param hints the RenderingHints.
+ *
+ * @return the CompositeContext object.
+ */
+ public CompositeContext createContext(ColorModel srcColorModel,
+ ColorModel dstColorModel, RenderingHints hints);
+
+}
+
diff --git a/awt/java/awt/CompositeContext.java b/awt/java/awt/CompositeContext.java
new file mode 100644
index 0000000..c676032
--- /dev/null
+++ b/awt/java/awt/CompositeContext.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.image.Raster;
+import java.awt.image.WritableRaster;
+
+/**
+ * The CompositeContext interface specifies the encapsulated and optimized
+ * environment for a compositing operation.
+ */
+public interface CompositeContext {
+
+ /**
+ * Composes the two source Raster objects and places the result in the
+ * destination WritableRaster.
+ *
+ * @param src the source Raster.
+ * @param dstIn the destination Raster.
+ * @param dstOut the WritableRaster object where the result of
+ * composing operation is stored.
+ */
+ public void compose(Raster src, Raster dstIn, WritableRaster dstOut);
+
+ /**
+ * Releases resources allocated for a context.
+ */
+ public void dispose();
+
+}
+
diff --git a/awt/java/awt/Cursor.java b/awt/java/awt/Cursor.java
new file mode 100644
index 0000000..625686c
--- /dev/null
+++ b/awt/java/awt/Cursor.java
@@ -0,0 +1,372 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Dmitry A. Durnev
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+import org.apache.harmony.awt.wtk.NativeCursor;
+
+/**
+ * The Cursor class represents the bitmap of the mouse cursor.
+ */
+public class Cursor implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 8028237497568985504L;
+
+ /** The Constant DEFAULT_CURSOR indicates the default cursor type. */
+ public static final int DEFAULT_CURSOR = 0;
+
+ /** The Constant CROSSHAIR_CURSOR cursor type. */
+ public static final int CROSSHAIR_CURSOR = 1;
+
+ /** The Constant TEXT_CURSOR cursor type. */
+ public static final int TEXT_CURSOR = 2;
+
+ /** The Constant WAIT_CURSOR cursor type. */
+ public static final int WAIT_CURSOR = 3;
+
+ /** The Constant SW_RESIZE_CURSOR cursor type. */
+ public static final int SW_RESIZE_CURSOR = 4;
+
+ /** The Constant SE_RESIZE_CURSOR cursor type. */
+ public static final int SE_RESIZE_CURSOR = 5;
+
+ /** The Constant NW_RESIZE_CURSOR cursor type. */
+ public static final int NW_RESIZE_CURSOR = 6;
+
+ /** The Constant NE_RESIZE_CURSOR cursor type. */
+ public static final int NE_RESIZE_CURSOR = 7;
+
+ /** The Constant N_RESIZE_CURSOR cursor type. */
+ public static final int N_RESIZE_CURSOR = 8;
+
+ /** The Constant S_RESIZE_CURSOR cursor type. */
+ public static final int S_RESIZE_CURSOR = 9;
+
+ /** The Constant W_RESIZE_CURSOR cursor type. */
+ public static final int W_RESIZE_CURSOR = 10;
+
+ /** The Constant E_RESIZE_CURSOR cursor type. */
+ public static final int E_RESIZE_CURSOR = 11;
+
+ /** The Constant HAND_CURSOR cursor type. */
+ public static final int HAND_CURSOR = 12;
+
+ /** The Constant MOVE_CURSOR cursor type. */
+ public static final int MOVE_CURSOR = 13;
+
+ /** A mapping from names to system custom cursors. */
+ static Map<String, Cursor> systemCustomCursors;
+
+ /** The cursor props. */
+ static Properties cursorProps;
+
+ /** The Constant predefinedNames. */
+ static final String[] predefinedNames = {
+ "Default", "Crosshair", "Text", "Wait", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ "Southwest Resize", "Southeast Resize", //$NON-NLS-1$ //$NON-NLS-2$
+ "Northwest Resize", "Northeast Resize", //$NON-NLS-1$ //$NON-NLS-2$
+ "North Resize", "South Resize", "West Resize", "East Resize", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ "Hand", "Move" //$NON-NLS-1$ //$NON-NLS-2$
+
+ };
+
+ /** The predefined set of cursors. */
+ protected static Cursor[] predefined = {
+ new Cursor(DEFAULT_CURSOR), null, null, null,
+ null, null, null, null,
+ null, null, null, null,
+ null, null
+ };
+
+ /** The Constant CUSTOM_CURSOR is associated with all custom cursor types.
+ * (Those which are not predefined)
+ */
+ public static final int CUSTOM_CURSOR = -1;
+
+ /** The name of the cursor. */
+ protected String name;
+
+ /** The type of the cursor, chosen from the list of cursor type constants. */
+ private final int type;
+
+ /** The native cursor. */
+ private transient NativeCursor nativeCursor;
+
+ /** The exact point on the cursor image that indicates which point
+ * the cursor is selecting (pointing to). The coordinates are given
+ * with respect the origin of the Image (its upper left corner).
+ */
+ private Point hotSpot;
+
+ /** The image to draw on the screen representing the cursor. */
+ private Image image;
+
+ /**
+ * Instantiates a new cursor with the specified name.
+ *
+ * @param name the name of cursor.
+ */
+ protected Cursor(String name) {
+ this(name, null, new Point());
+ }
+
+ /**
+ * Instantiates a new cursor of the specified type.
+ *
+ * @param type the type of cursor.
+ */
+ public Cursor(int type) {
+ checkType(type);
+ this.type = type;
+ if ((type >= 0) && (type < predefinedNames.length)) {
+ name = predefinedNames[type] + " Cursor"; //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Instantiates a new cursor.
+ *
+ * @param name the name
+ * @param img the img
+ * @param hotSpot the hot spot
+ */
+ Cursor(String name, Image img, Point hotSpot) {
+ this.name = name;
+ type = CUSTOM_CURSOR;
+ this.hotSpot = hotSpot;
+ image = img;
+ }
+
+ /**
+ * Finalize method overrided finalize method from Object class.
+ *
+ * @throws Throwable if the native cursor is not null and throws
+ * a throwable when destroyed.
+ */
+ @Override
+ protected void finalize() throws Throwable {
+ if (nativeCursor != null) {
+ nativeCursor.destroyCursor();
+ }
+ }
+
+ /**
+ * Gets the name of the cursor.
+ *
+ * @return the name of the cursor.
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * Returns the String representation of the cursor.
+ *
+ * @return the String representation of the cursor.
+ */
+ @Override
+ public String toString() {
+ return getClass().getName() + "[" + name + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ /**
+ * Gets the cursor type.
+ *
+ * @return the cursor type
+ */
+ public int getType() {
+ return type;
+ }
+
+ /**
+ * Gets the predefined cursor with the specified type.
+ *
+ * @param type the type of cursor.
+ *
+ * @return the predefined cursor with the specified type.
+ */
+ public static Cursor getPredefinedCursor(int type) {
+ checkType(type);
+ Cursor cursor = predefined[type];
+ if (cursor == null) {
+ cursor = new Cursor(type);
+ predefined[type] = cursor;
+ }
+ return cursor;
+ }
+
+ /**
+ * Gets the default cursor.
+ *
+ * @return the default cursor.
+ */
+ public static Cursor getDefaultCursor() {
+ return getPredefinedCursor(DEFAULT_CURSOR);
+ }
+
+ /**
+ * Gets the specified system custom cursor.
+ *
+ * @param name the name of the desired system cursor.
+ *
+ * @return the specific system cursor with the specified name.
+ *
+ * @throws AWTException if the desired cursor has malformed data
+ * such as an incorrectly defined hot spot.
+ * @throws HeadlessException if the isHeadless method of the GraphicsEnvironment
+ * returns true.
+ */
+ public static Cursor getSystemCustomCursor(String name)
+ throws AWTException, HeadlessException {
+ Toolkit.checkHeadless();
+ return getSystemCustomCursorFromMap(name);
+ }
+
+ /**
+ * Gets the specified system custom cursor from the map of system custom cursors.
+ *
+ * @param name the name of the desired cursor.
+ *
+ * @return the desired system custom cursor from the
+ * map of system custom cursors.
+ *
+ * @throws AWTException the AWT exception
+ */
+ private static Cursor getSystemCustomCursorFromMap (String name)
+ throws AWTException {
+ loadCursorProps();
+ if (systemCustomCursors == null) {
+ systemCustomCursors = new HashMap<String, Cursor>();
+ }
+ Cursor cursor = systemCustomCursors.get(name);
+ if (cursor != null) {
+ return cursor;
+ }
+ // awt.141=failed to parse hotspot property for cursor:
+ String exMsg = Messages.getString("awt.141") + name; //$NON-NLS-1$
+ String nm = "Cursor." + name; //$NON-NLS-1$
+ String nameStr = cursorProps.getProperty(nm + ".Name"); //$NON-NLS-1$
+ String hotSpotStr = cursorProps.getProperty(nm + ".HotSpot"); //$NON-NLS-1$
+ String fileStr = cursorProps.getProperty(nm + ".File"); //$NON-NLS-1$
+ int idx = hotSpotStr.indexOf(',');
+ if (idx < 0) {
+ throw new AWTException(exMsg);
+ }
+ int x, y;
+ try {
+ x = new Integer(hotSpotStr.substring(0, idx)).intValue();
+ y = new Integer(hotSpotStr.substring(idx + 1,
+ hotSpotStr.length())).intValue();
+ } catch (NumberFormatException nfe) {
+ throw new AWTException(exMsg);
+ }
+ Image img = Toolkit.getDefaultToolkit().createImage(fileStr);
+ cursor = new Cursor(nameStr, img, new Point(x, y));
+ systemCustomCursors.put(name, cursor);
+
+ return cursor;
+ }
+
+ /**
+ * Load cursor props.
+ *
+ * @throws AWTException the AWT exception
+ */
+ private static void loadCursorProps() throws AWTException {
+ if (cursorProps != null) {
+ return;
+ }
+ String sep = File.separator;
+ String cursorsDir = "lib" + sep + "images" + sep + "cursors"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ String cursorsAbsDir = System.getProperty("java.home") + sep + //$NON-NLS-1$
+ cursorsDir;
+ String cursorPropsFileName = "cursors.properties"; //$NON-NLS-1$
+ String cursorPropsFullFileName = (cursorsAbsDir + sep +
+ cursorPropsFileName);
+ cursorProps = new Properties();
+ try {
+ cursorProps.load(new FileInputStream(new File(
+ cursorPropsFullFileName)));
+ } catch (FileNotFoundException e) {
+ // awt.142=Exception: class {0} {1} occurred while loading: {2}
+ throw new AWTException(Messages.getString("awt.142",//$NON-NLS-1$
+ new Object[]{e.getClass(), e.getMessage(), cursorPropsFullFileName}));
+ } catch (IOException e) {
+ throw new AWTException(e.getMessage());
+ }
+
+ }
+
+ /**
+ * Check type.
+ *
+ * @param type the type
+ */
+ static void checkType(int type) {
+ // can't use predefined array here because it may not have been
+ // initialized yet
+ if ((type < 0) || (type >= predefinedNames.length)) {
+ // awt.143=illegal cursor type
+ throw new IllegalArgumentException(Messages.getString("awt.143")); //$NON-NLS-1$
+ }
+ }
+
+ // "lazily" create native cursors:
+ /**
+ * Gets the native cursor.
+ *
+ * @return the native cursor
+ */
+ NativeCursor getNativeCursor() {
+ if (nativeCursor != null) {
+ return nativeCursor;
+ }
+ Toolkit toolkit = Toolkit.getDefaultToolkit();
+ if (type != CUSTOM_CURSOR) {
+ nativeCursor = toolkit.createNativeCursor(type);
+ } else {
+ nativeCursor = toolkit.createCustomNativeCursor(image, hotSpot,
+ name);
+ }
+ return nativeCursor;
+ }
+
+ /**
+ * Sets the native cursor.
+ *
+ * @param nativeCursor the new native cursor
+ */
+ void setNativeCursor(NativeCursor nativeCursor) {
+ this.nativeCursor = nativeCursor;
+ }
+}
+
diff --git a/awt/java/awt/Dimension.java b/awt/java/awt/Dimension.java
new file mode 100644
index 0000000..8137846
--- /dev/null
+++ b/awt/java/awt/Dimension.java
@@ -0,0 +1,185 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.geom.Dimension2D;
+import java.io.Serializable;
+
+import org.apache.harmony.misc.HashCode;
+
+/**
+ * The Dimension represents the size (width and height) of a component.
+ * The width and height values can be negative, but in that case the
+ * behavior of some methods is unexpected.
+ */
+public class Dimension extends Dimension2D implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 4723952579491349524L;
+
+ /** The width dimension. */
+ public int width;
+
+ /** The height dimension. */
+ public int height;
+
+ /**
+ * Instantiates a new Dimension with the same data as the specified Dimension.
+ *
+ * @param d the Dimension to copy the data from when creating the
+ * new Dimension object.
+ */
+ public Dimension(Dimension d) {
+ this(d.width, d.height);
+ }
+
+ /**
+ * Instantiates a new Dimension with zero width and height.
+ */
+ public Dimension() {
+ this(0, 0);
+ }
+
+ /**
+ * Instantiates a new Dimension with the specified width and height.
+ *
+ * @param width the width of the new Dimension.
+ * @param height the height of the new Dimension.
+ */
+ public Dimension(int width, int height) {
+ setSize(width, height);
+ }
+
+ /**
+ * Returns the hash code of the Dimension.
+ *
+ * @return the hash code of the Dimension.
+ */
+ @Override
+ public int hashCode() {
+ HashCode hash = new HashCode();
+ hash.append(width);
+ hash.append(height);
+ return hash.hashCode();
+ }
+
+ /**
+ * Compares this Dimension object with the specified object.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if the specified Object is a Dimension with
+ * the same width and height data as this Dimension.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (obj instanceof Dimension) {
+ Dimension d = (Dimension)obj;
+ return (d.width == width && d.height == height);
+ }
+ return false;
+ }
+
+ /**
+ * Returns the String associated to this Dimension object.
+ *
+ * @return the String associated to this Dimension object.
+ */
+ @Override
+ public String toString() {
+ // The output format based on 1.5 release behaviour. It could be obtained in the following way
+ // System.out.println(new Dimension().toString())
+ return getClass().getName() + "[width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+ /**
+ * Sets the size of this Dimension object with the specified width and height.
+ *
+ * @param width the width of the Dimension.
+ * @param height the height of the Dimension.
+ */
+ public void setSize(int width, int height) {
+ this.width = width;
+ this.height = height;
+ }
+
+ /**
+ * Sets the size of this Dimension object by copying the
+ * data from the specified Dimension object.
+ *
+ * @param d the Dimension that gives the new size values.
+ */
+ public void setSize(Dimension d) {
+ setSize(d.width, d.height);
+ }
+
+ /**
+ * Sets the size of this Dimension object with the specified double width
+ * and height.
+ *
+ * @param width the width of the Dimension.
+ * @param height the height of the Dimension.
+ *
+ * @see java.awt.geom.Dimension2D#setSize(double, double)
+ */
+ @Override
+ public void setSize(double width, double height) {
+ setSize((int)Math.ceil(width), (int)Math.ceil(height));
+ }
+
+ /**
+ * Gets the size of the Dimension.
+ *
+ * @return the size of the Dimension.
+ */
+ public Dimension getSize() {
+ return new Dimension(width, height);
+ }
+
+ /**
+ * Gets the height of the Dimension.
+ *
+ * @return the height of the Dimension.
+ *
+ * @see java.awt.geom.Dimension2D#getHeight()
+ */
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ /**
+ * Gets the width of the Dimension.
+ *
+ * @return the width of the Dimension.
+ *
+ * @see java.awt.geom.Dimension2D#getWidth()
+ */
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+}
+
diff --git a/awt/java/awt/Dispatcher.java b/awt/java/awt/Dispatcher.java
new file mode 100644
index 0000000..d457af4
--- /dev/null
+++ b/awt/java/awt/Dispatcher.java
@@ -0,0 +1,723 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov, Dmitry A. Durnev
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.event.ComponentEvent;
+import java.awt.event.FocusEvent;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseEvent;
+import java.awt.event.PaintEvent;
+import java.awt.event.WindowEvent;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+import org.apache.harmony.awt.wtk.NativeEvent;
+import org.apache.harmony.awt.wtk.NativeWindow;
+
+
+/**
+ * Helper package-private class for managing lightweight components &
+ * dispatching events from heavyweight source
+ */
+class Dispatcher {
+
+ //???AWT: final PopupDispatcher popupDispatcher = new PopupDispatcher();
+
+ //???AWT: final FocusDispatcher focusDispatcher;
+
+ final MouseGrabManager mouseGrabManager = new MouseGrabManager();
+
+ final MouseDispatcher mouseDispatcher;
+
+ private final ComponentDispatcher componentDispatcher = new ComponentDispatcher();
+
+ private final KeyDispatcher keyDispatcher = new KeyDispatcher();
+
+ private final Toolkit toolkit;
+
+ int clickInterval = 250;
+
+ /**
+ * @param toolkit - AWT toolkit
+ */
+ Dispatcher(Toolkit toolkit) {
+ this.toolkit = toolkit;
+
+ //???AWT: focusDispatcher = new FocusDispatcher(toolkit);
+ mouseDispatcher = new MouseDispatcher(mouseGrabManager, toolkit);
+ }
+
+ /**
+ * Dispatch native event: produce appropriate AWT events,
+ * update component's fields when needed
+ * @param event - native event to dispatch
+ * @return - true means default processing by OS is not needed
+ */
+ public boolean onEvent(NativeEvent event) {
+ int eventId = event.getEventId();
+
+ if (eventId == NativeEvent.ID_CREATED) {
+ return toolkit.onWindowCreated(event.getWindowId());
+ } else if (eventId == NativeEvent.ID_MOUSE_GRAB_CANCELED) {
+ return mouseGrabManager.onGrabCanceled();
+ //???AWT
+// } else if (popupDispatcher.onEvent(event)) {
+// return false;
+ } else {
+ Component src = toolkit.getComponentById(event.getWindowId());
+
+ if (src != null) {
+ if (((eventId >= ComponentEvent.COMPONENT_FIRST) && (eventId <= ComponentEvent.COMPONENT_LAST))
+ || ((eventId >= WindowEvent.WINDOW_FIRST) && (eventId <= WindowEvent.WINDOW_LAST))
+ || (eventId == NativeEvent.ID_INSETS_CHANGED)
+ || (eventId == NativeEvent.ID_BOUNDS_CHANGED)
+ || (eventId == NativeEvent.ID_THEME_CHANGED)) {
+ return componentDispatcher.dispatch(src, event);
+ } else if ((eventId >= MouseEvent.MOUSE_FIRST)
+ && (eventId <= MouseEvent.MOUSE_LAST)) {
+ return mouseDispatcher.dispatch(src, event);
+ } else if (eventId == PaintEvent.PAINT) {
+ //???AWT: src.redrawManager.addPaintRegion(src, event.getClipRects());
+ return true;
+ }
+ }
+ if ((eventId >= FocusEvent.FOCUS_FIRST)
+ && (eventId <= FocusEvent.FOCUS_LAST)) {
+
+ //???AWT: return focusDispatcher.dispatch(src, event);
+ return false;
+ } else if ((eventId >= KeyEvent.KEY_FIRST)
+ && (eventId <= KeyEvent.KEY_LAST)) {
+ return keyDispatcher.dispatch(src, event);
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * The dispatcher of native events that affect
+ * component's state or bounds
+ */
+ final class ComponentDispatcher {
+
+ /**
+ * Handle native event that affects component's state or bounds
+ * @param src - the component updated by the event
+ * @param event - the native event
+ * @return - as in Dispatcher.onEvent()
+ * @see Dispatcher#onEvent(NativeEvent)
+ */
+ boolean dispatch(Component src, NativeEvent event) {
+ int id = event.getEventId();
+
+ if ((id == NativeEvent.ID_INSETS_CHANGED)
+ || (id == NativeEvent.ID_THEME_CHANGED)) {
+ return dispatchInsets(event, src);
+ } else if ((id >= WindowEvent.WINDOW_FIRST)
+ && (id <= WindowEvent.WINDOW_LAST)) {
+ return dispatchWindow(event, src);
+ } else {
+ return dispatchPureComponent(event, src);
+ }
+ }
+
+ /**
+ * Handle the change of top-level window's native decorations
+ * @param event - the native event
+ * @param src - the component updated by the event
+ * @return - as in Dispatcher.onEvent()
+ * @see Dispatcher#onEvent(NativeEvent)
+ */
+ boolean dispatchInsets(NativeEvent event, Component src) {
+ //???AWT
+ /*
+ if (src instanceof Window) {
+ ((Window) src).setNativeInsets(event.getInsets());
+ }
+ */
+ return false;
+ }
+
+ /**
+ * Handle the change of top-level window's state
+ * @param event - the native event
+ * @param src - the component updated by the event
+ * @return - as in Dispatcher.onEvent()
+ * @see Dispatcher#onEvent(NativeEvent)
+ */
+ boolean dispatchWindow(NativeEvent event, Component src) {
+ //???AWT
+ /*
+ Window window = (Window) src;
+ int id = event.getEventId();
+
+ if (id == WindowEvent.WINDOW_CLOSING) {
+ toolkit.getSystemEventQueueImpl().postEvent(
+ new WindowEvent(window, WindowEvent.WINDOW_CLOSING));
+
+ return true;
+ } else if (id == WindowEvent.WINDOW_STATE_CHANGED) {
+ if (window instanceof Frame) {
+ ((Frame) window)
+ .updateExtendedState(event.getWindowState());
+ }
+ }
+ */
+
+ return false;
+ }
+
+ /**
+ * Handle the change of component's size and/or position
+ * @param event - the native event
+ * @param src - the component updated by the event
+ * @return - as in Dispatcher.onEvent()
+ * @see Dispatcher#onEvent(NativeEvent)
+ */
+ private boolean dispatchPureComponent(NativeEvent event, Component src) {
+ Rectangle rect = event.getWindowRect();
+ Point loc = rect.getLocation();
+ int mask;
+
+ switch (event.getEventId()) {
+ case NativeEvent.ID_BOUNDS_CHANGED:
+ mask = 0;
+ break;
+ case ComponentEvent.COMPONENT_MOVED:
+ mask = NativeWindow.BOUNDS_NOSIZE;
+ break;
+ case ComponentEvent.COMPONENT_RESIZED:
+ mask = NativeWindow.BOUNDS_NOMOVE;
+ break;
+ default:
+ // awt.12E=Unknown component event id.
+ throw new RuntimeException(Messages.getString("awt.12E")); //$NON-NLS-1$
+ }
+
+ //???AWT
+ /*
+ if (!(src instanceof Window)) {
+ Component compTo = src.getParent();
+ Component compFrom = src.getHWAncestor();
+
+ if ((compTo != null) && (compFrom != null)) {
+ loc = MouseDispatcher.convertPoint(compFrom, loc, compTo);
+ }
+ } else {
+ int windowState = event.getWindowState();
+
+ if ((windowState >= 0) && (src instanceof Frame)) {
+ ((Frame) src).updateExtendedState(windowState);
+ }
+ }
+ src.setBounds(loc.x, loc.y, rect.width, rect.height, mask, false);
+ */
+
+ return false;
+ }
+
+ }
+
+ /**
+ * The dispatcher of the keyboard events
+ */
+ final class KeyDispatcher {
+
+ /**
+ * Handle the keyboard event using the KeyboardFocusManager
+ * @param src - the component receiving the event
+ * @param event - the native event
+ * @return - as in Dispatcher.onEvent()
+ * @see Dispatcher#onEvent(NativeEvent)
+ */
+ boolean dispatch(Component src, NativeEvent event) {
+ int id = event.getEventId();
+ int modifiers = event.getInputModifiers();
+ int location = event.getKeyLocation();
+ int code = event.getVKey();
+ StringBuffer chars = event.getKeyChars();
+ int charsLength = chars.length();
+ long time = event.getTime();
+ char keyChar = event.getLastChar();
+
+ //???AWT
+ /*
+ if (src == null) {
+ //retarget focus proxy key events to focusOwner:
+ Window focusProxyOwner = toolkit.getFocusProxyOwnerById(event
+ .getWindowId());
+ if (focusProxyOwner == null) {
+ return false;
+ }
+ src = KeyboardFocusManager.actualFocusOwner;
+ }
+ */
+
+ EventQueue eventQueue = toolkit.getSystemEventQueueImpl();
+
+ if (src != null) {
+ eventQueue.postEvent(new KeyEvent(src, id, time, modifiers,
+ code, keyChar, location));
+ // KEY_TYPED goes after KEY_PRESSED
+ if (id == KeyEvent.KEY_PRESSED) {
+ for (int i = 0; i < charsLength; i++) {
+ keyChar = chars.charAt(i);
+ if (keyChar != KeyEvent.CHAR_UNDEFINED) {
+ eventQueue.postEvent(new KeyEvent(src,
+ KeyEvent.KEY_TYPED, time, modifiers,
+ KeyEvent.VK_UNDEFINED, keyChar,
+ KeyEvent.KEY_LOCATION_UNKNOWN));
+ }
+ }
+ }
+ }
+
+ return false;
+ }
+
+ }
+
+ /**
+ * Retargets the mouse events to the grab owner when mouse is grabbed,
+ * grab and ungrab mouse when mouse buttons are pressed and released
+ */
+
+ static final class MouseGrabManager {
+
+ /**
+ * The top-level window holding the mouse grab
+ * that was explicitly started by startGrab() method
+ */
+ //???AWT: private Window nativeGrabOwner = null;
+ /**
+ * The component that owns the synthetic
+ * mouse grab while at least one of the
+ * mouse buttons is pressed
+ */
+ private Component syntheticGrabOwner = null;
+
+ /**
+ * Previous value of syntheticGrabOwner
+ */
+ private Component lastSyntheticGrabOwner = null;
+
+ /**
+ * Number of mouse buttons currently pressed
+ */
+ private int syntheticGrabDepth = 0;
+
+ /**
+ * The callback to be called when the explicit mouse grab ends
+ */
+ private Runnable whenCanceled;
+
+ /**
+ * Explicitly start the mouse grab
+ * @param grabWindow - the window that will own the grab
+ * @param whenCanceled - the callback to call when the grab ends.
+ * This parameter can be null
+ */
+ //???AWT
+ /*
+ void startGrab(Window grabWindow, Runnable whenCanceled) {
+
+ if (nativeGrabOwner != null) {
+ // awt.12F=Attempt to start nested mouse grab
+ throw new RuntimeException(Messages.getString("awt.12F")); //$NON-NLS-1$
+ }
+
+ NativeWindow win = grabWindow.getNativeWindow();
+ if (win == null) {
+ // awt.130=Attempt to grab mouse in not displayable window
+ throw new RuntimeException(Messages.getString("awt.130")); //$NON-NLS-1$
+ }
+
+ nativeGrabOwner = grabWindow;
+ this.whenCanceled = whenCanceled;
+ win.grabMouse();
+ }
+ */
+
+ /**
+ * Ends the explicit mouse grab. If the non-null callback was provided
+ * in the startGrab() method, this callback is called
+ */
+ void endGrab() {
+ //???AWT
+ /*
+ if (nativeGrabOwner == null) {
+ return;
+ }
+
+ Window grabWindow = nativeGrabOwner;
+ nativeGrabOwner = null;
+ NativeWindow win = grabWindow.getNativeWindow();
+
+ if (win != null) {
+ win.ungrabMouse();
+ if (whenCanceled != null) {
+ whenCanceled.run();
+ whenCanceled = null;
+ }
+ }
+ */
+ }
+
+ /**
+ * Ends both explicit and synthetic grans
+ * @return - always returns false
+ */
+ boolean onGrabCanceled() {
+ endGrab();
+ resetSyntheticGrab();
+
+ return false;
+ }
+
+ /**
+ * Starts the synthetic mouse grab, increases the counter
+ * of currently pressed mouse buttons
+ * @param source - the component where mouse press event occured
+ * @return - the component that owns the synthetic grab
+ */
+ Component onMousePressed(Component source) {
+ if (syntheticGrabDepth == 0) {
+ syntheticGrabOwner = source;
+ lastSyntheticGrabOwner = source;
+ }
+ syntheticGrabDepth++;
+
+ return syntheticGrabOwner;
+ }
+
+ /**
+ * Decreases the counter of currently pressed mouse buttons,
+ * ends the synthetic mouse grab, when this counter becomes zero
+ * @param source - the component where mouse press event occured
+ * @return - the component that owns the synthetic grab,
+ * or source parameter if mouse grab was released
+ */
+ Component onMouseReleased(Component source) {
+ Component ret = source;
+
+ //???AWT
+ /*
+ if (syntheticGrabOwner != null && nativeGrabOwner == null) {
+ ret = syntheticGrabOwner;
+ }
+ */
+ syntheticGrabDepth--;
+ if (syntheticGrabDepth <= 0) {
+ resetSyntheticGrab();
+ lastSyntheticGrabOwner = null;
+ }
+
+ return ret;
+ }
+
+ /**
+ * Update the state of synthetic ouse gram
+ * when the mouse is moved/dragged
+ * @param event - the native event
+ */
+ void preprocessEvent(NativeEvent event) {
+ int id = event.getEventId();
+ switch (id) {
+ case MouseEvent.MOUSE_MOVED:
+ if (syntheticGrabOwner != null) {
+ syntheticGrabOwner = null;
+ syntheticGrabDepth = 0;
+ }
+ if (lastSyntheticGrabOwner != null) {
+ lastSyntheticGrabOwner = null;
+ }
+ case MouseEvent.MOUSE_DRAGGED:
+ if (syntheticGrabOwner == null
+ && lastSyntheticGrabOwner != null) {
+ syntheticGrabOwner = lastSyntheticGrabOwner;
+ syntheticGrabDepth = 0;
+ int mask = event.getInputModifiers();
+ syntheticGrabDepth += (mask & InputEvent.BUTTON1_DOWN_MASK) != 0 ? 1
+ : 0;
+ syntheticGrabDepth += (mask & InputEvent.BUTTON2_DOWN_MASK) != 0 ? 1
+ : 0;
+ syntheticGrabDepth += (mask & InputEvent.BUTTON3_DOWN_MASK) != 0 ? 1
+ : 0;
+ }
+ }
+ }
+
+ /**
+ * @return the component that currently owns the synthetic grab
+ */
+ Component getSyntheticGrabOwner() {
+ return syntheticGrabOwner;
+ }
+
+ /**
+ * ends synthetic grab
+ */
+ private void resetSyntheticGrab() {
+ syntheticGrabOwner = null;
+ syntheticGrabDepth = 0;
+ }
+
+ }
+
+ /**
+ * Dispatches native events related to the pop-up boxes
+ * (the non-component windows such as menus and drop lists)
+ */
+// final class PopupDispatcher {
+//
+// private PopupBox activePopup;
+//
+// private PopupBox underCursor;
+//
+// private final MouseGrab grab = new MouseGrab();
+//
+// /**
+// * Handles the mouse grab for pop-up boxes
+// */
+// private final class MouseGrab {
+// private int depth;
+//
+// private PopupBox owner;
+//
+// private final Point start = new Point();
+//
+// /**
+// * Starts the grab when mouse is pressed
+// * @param src - the pop-up box where mouse event has occured
+// * @param where - the mouse pointer location
+// * @return - the grab owner
+// */
+// PopupBox mousePressed(PopupBox src, Point where) {
+// if (depth == 0) {
+// owner = src;
+// start.setLocation(where);
+// }
+// depth++;
+// return owner;
+// }
+//
+// /**
+// * Ends the grab when all mousebuttons are released
+// * @param src - the pop-up box where mouse event has occured
+// * @param where - the mouse pointer location
+// * @return - the grab owner, or src parameter if the grab has ended
+// */
+// PopupBox mouseReleased(PopupBox src, Point where) {
+// PopupBox ret = (owner != null) ? owner : src;
+// if (depth == 0) {
+// return ret;
+// }
+// depth--;
+// if (depth == 0) {
+// PopupBox tgt = owner;
+// owner = null;
+// if (tgt != null && src == null) {
+// Point a = new Point(start);
+// Point b = new Point(where);
+// Point pos = tgt.getScreenLocation();
+// a.translate(-pos.x, -pos.y);
+// b.translate(-pos.x, -pos.y);
+// if (tgt.closeOnUngrab(a, b)) {
+// return null;
+// }
+// }
+// }
+// return ret;
+// }
+//
+// /**
+// * Set the grab owner to null
+// */
+// void reset() {
+// depth = 0;
+// owner = null;
+// start.setLocation(0, 0);
+// }
+//
+// /**
+// * @return - the pop-up box currently owning the grab
+// */
+// public PopupBox getOwner() {
+// return owner;
+// }
+// }
+//
+// /**
+// * Call the mouse event handler of the pop-up box
+// * @param src - the pop-up box where the mouse event occured
+// * @param eventId - the event ID, one of MouseEvent.MOUSE_* constants
+// * @param where - the mouse pointer location
+// * @param event - native event
+// */
+// private void mouseEvent(PopupBox src, int eventId, Point where,
+// NativeEvent event) {
+// Point pos = src.getScreenLocation();
+// pos.setLocation(where.x - pos.x, where.y - pos.y);
+//
+// src.onMouseEvent(eventId, pos, event.getMouseButton(), event
+// .getTime(), event.getInputModifiers(), event
+// .getWheelRotation());
+// }
+//
+// /**
+// * Handle the native event targeted by a pop-up box. This could be
+// * paint event, mouse or keyboard event.
+// * @param event - the native event
+// * @return - false if the event was handled and doesn't
+// * need the further processing; true when the further
+// * processing is needed
+// */
+// boolean onEvent(NativeEvent event) {
+// PopupBox src = toolkit.getPopupBoxById(event.getWindowId());
+// int id = event.getEventId();
+//
+// if ((id == PaintEvent.PAINT)) {
+// if (src != null) {
+// src.paint(event.getClipRects());
+// return true;
+// }
+// Component c = toolkit.getComponentById(event.getWindowId());
+// if ((c != null) && (c instanceof Frame)) {
+// ((Frame) c).paintMenuBar(event.getClipRects());
+// }
+// return false;
+// }
+//
+// if ((id >= MouseEvent.MOUSE_FIRST) && (id <= MouseEvent.MOUSE_LAST)) {
+// Point where = event.getScreenPos();
+//
+// if (src != underCursor) {
+// if (underCursor != null) {
+// mouseEvent(underCursor, MouseEvent.MOUSE_EXITED, where,
+// event);
+// }
+// underCursor = src;
+// if (underCursor != null) {
+// mouseEvent(underCursor, MouseEvent.MOUSE_ENTERED,
+// where, event);
+// underCursor.setDefaultCursor();
+// }
+// }
+// if (id == MouseEvent.MOUSE_EXITED) {
+// underCursor = null;
+// }
+//
+// if ((activePopup == null) && (src == null || !src.isMenuBar())) {
+// return false;
+// }
+//
+// if (id == MouseEvent.MOUSE_PRESSED) {
+// src = grab.mousePressed(src, where);
+// } else if (id == MouseEvent.MOUSE_RELEASED) {
+// src = grab.mouseReleased(src, where);
+// } else if (src == null) {
+// src = grab.getOwner();
+// }
+//
+// PopupBox wasActive = activePopup;
+//
+// if (src != null) {
+// mouseEvent(src, id, where, event);
+// return src.isMenu() || src.contains(where);
+// }
+//
+// if (wasActive != null && activePopup == null) {
+// return wasActive.isMenu();
+// }
+//
+// if ((id == MouseEvent.MOUSE_PRESSED)
+// || (id == MouseEvent.MOUSE_RELEASED)) {
+// boolean isMenu = activePopup.isMenu();
+// deactivateAll();
+// return !isMenu;
+// }
+// return true;
+// }
+//
+// if (activePopup == null) {
+// return false;
+// }
+//
+// if ((id >= KeyEvent.KEY_FIRST) && (id <= KeyEvent.KEY_LAST)) {
+// boolean isMenu = activePopup.isMenu();
+// activePopup.dispatchKeyEvent(id, event.getVKey(), event
+// .getTime(), event.getInputModifiers());
+//
+// return isMenu;
+// }
+//
+// return false;
+// }
+//
+// /**
+// * Remember the pop-up as active and grab the mouse on it
+// * @param popup - the pop-up box to activate
+// */
+// void activate(final PopupBox popup) {
+// if (activePopup == null) {
+//
+// activePopup = popup;
+// mouseGrabManager.startGrab(popup.getOwner(), new Runnable() {
+// public void run() {
+// deactivate(popup);
+// }
+// });
+// }
+// }
+//
+// /**
+// * Deactivate the currently active pop-up box
+// */
+// void deactivateAll() {
+// deactivate(activePopup);
+// }
+//
+// /**
+// * Deactivate the pop-up box, end the mouse grab
+// */
+// void deactivate(PopupBox popup) {
+// grab.reset();
+//
+// if (activePopup != null && activePopup == popup) {
+// activePopup = null;
+// mouseGrabManager.endGrab();
+// popup.hide();
+// underCursor = null;
+// }
+// }
+//
+// /**
+// * Check that the pop-up box is currently active
+// * @param popup - the pop-up box to check
+// * @return - true if active
+// */
+// boolean isActive(PopupBox popup) {
+// return (popup == activePopup) && (popup != null);
+// }
+// }
+
+}
\ No newline at end of file
diff --git a/awt/java/awt/DisplayMode.java b/awt/java/awt/DisplayMode.java
new file mode 100644
index 0000000..082c7b8
--- /dev/null
+++ b/awt/java/awt/DisplayMode.java
@@ -0,0 +1,147 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ * The DisplayMode class containes the bit depth, height, width and
+ * refresh rate of a GraphicsDevice.
+ */
+public final class DisplayMode {
+
+ /** The width. */
+ private final int width;
+
+ /** The height. */
+ private final int height;
+
+ /** The bit depth. */
+ private final int bitDepth;
+
+ /** The refresh rate. */
+ private final int refreshRate;
+
+ /** The Constant Value BIT_DEPTH_MULTI indicates the bit depth */
+
+ public static final int BIT_DEPTH_MULTI = -1;
+
+ /** The Constant REFRESH_RATE_UNKNOWN indicates the refresh rate. */
+ public static final int REFRESH_RATE_UNKNOWN = 0;
+
+ /**
+ * Creates a new DisplayMode object with the specified parameters.
+ *
+ * @param width the width of the display.
+ * @param height the height of the display.
+ * @param bitDepth the bit depth of the display.
+ * @param refreshRate the refresh rate of the display.
+ */
+
+ public DisplayMode(int width, int height, int bitDepth, int refreshRate) {
+ this.width = width;
+ this.height = height;
+ this.bitDepth = bitDepth;
+ this.refreshRate = refreshRate;
+ }
+
+
+ /**
+ * Compares if this DisplayMode is equal to the specified object or not.
+ *
+ * @param dm the Object to be compared.
+ *
+ * @return true, if the specified object is a DisplayMode with the same
+ * data values as this DisplayMode, false otherwise.
+ */
+
+ @Override
+ public boolean equals(Object dm) {
+ if (dm instanceof DisplayMode) {
+ return equals((DisplayMode)dm);
+ }
+ return false;
+ }
+
+ /**
+ * Compares if this DisplayMode is equal to the specified DisplayMode object
+ * or not.
+ *
+ * @param dm the DisplayMode to be compared.
+ *
+ * @return true, if all of the data values of this DisplayMode are equal
+ * to the values of the specified DisplayMode object, false otherwise.
+ */
+ public boolean equals(DisplayMode dm) {
+ if (dm == null) {
+ return false;
+ }
+ if (dm.bitDepth != bitDepth) {
+ return false;
+ }
+ if (dm.refreshRate != refreshRate) {
+ return false;
+ }
+ if (dm.width != width) {
+ return false;
+ }
+ if (dm.height != height) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Gets the bit depth of the DisplayMode, returns BIT_DEPTH_MULTI value
+ * if multiple bit depths are supported in this display mode.
+ *
+ * @return the bit depth of the DisplayMode.
+ */
+ public int getBitDepth() {
+ return bitDepth;
+ }
+
+ /**
+ * Gets the height of the DisplayMode.
+ *
+ * @return the height of the DisplayMode.
+ */
+ public int getHeight() {
+ return height;
+ }
+
+ /**
+ * Gets the refresh rate of the DisplayMode, returns REFRESH_RATE_UNKNOWN
+ * value if the information is not available.
+ *
+ * @return the refresh rate of the DisplayMode.
+ */
+ public int getRefreshRate() {
+ return refreshRate;
+ }
+
+ /**
+ * Gets the width of the DisplayMode.
+ *
+ * @return the width of the DisplayMode.
+ */
+ public int getWidth() {
+ return width;
+ }
+}
diff --git a/awt/java/awt/Event.java b/awt/java/awt/Event.java
new file mode 100644
index 0000000..f074258
--- /dev/null
+++ b/awt/java/awt/Event.java
@@ -0,0 +1,479 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Dmitry A. Durnev
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.io.Serializable;
+
+/**
+ * The Event Class is obsolete and has been replaced by AWTEvent class.
+ *
+ */
+public class Event implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 5488922509400504703L;
+
+ /**
+ * The Constant SHIFT_MASK indicates that the Shift key is down when
+ * the event occurred.
+ */
+ public static final int SHIFT_MASK = 1;
+
+ /**
+ * The Constant CTRL_MASK indicates that the Control key is down when
+ * the event occurred.
+ */
+ public static final int CTRL_MASK = 2;
+
+ /** The Constant META_MASK indicates that the Meta key is down when t
+ * he event occurred (or the right mouse button). */
+ public static final int META_MASK = 4;
+
+ /**
+ * The Constant ALT_MASK indicates that the Alt key is down when
+ * the event occurred (or the middle mouse button).
+ */
+ public static final int ALT_MASK = 8;
+
+ /** The Constant HOME indicates Home key. */
+ public static final int HOME = 1000;
+
+ /** The Constant END indicates End key. */
+ public static final int END = 1001;
+
+ /** The Constant PGUP indicates Page Up key. */
+ public static final int PGUP = 1002;
+
+ /** The Constant PGDN indicates Page Down key. */
+ public static final int PGDN = 1003;
+
+ /** The Constant UP indicates Up key. */
+ public static final int UP = 1004;
+
+ /** The Constant DOWN indicates Down key. */
+ public static final int DOWN = 1005;
+
+ /** The Constant LEFT indicates Left key. */
+ public static final int LEFT = 1006;
+
+ /** The Constant RIGHT indicates Right key. */
+ public static final int RIGHT = 1007;
+
+ /** The Constant F1 indicates F1 key. */
+ public static final int F1 = 1008;
+
+ /** The Constant F2 indicates F2 key. */
+ public static final int F2 = 1009;
+
+ /** The Constant F3 indicates F3 key. */
+ public static final int F3 = 1010;
+
+ /** The Constant F4 indicates F4 key. */
+ public static final int F4 = 1011;
+
+ /** The Constant F5 indicates F5 key. */
+ public static final int F5 = 1012;
+
+ /** The Constant F6 indicates F6 key. */
+ public static final int F6 = 1013;
+
+ /** The Constant F7 indicates F7 key. */
+ public static final int F7 = 1014;
+
+ /** The Constant F8 indicates F8 key. */
+ public static final int F8 = 1015;
+
+ /** The Constant F9 indicates F9 key. */
+ public static final int F9 = 1016;
+
+ /** The Constant F10 indicates F10 key. */
+ public static final int F10 = 1017;
+
+ /** The Constant F11 indicates F11 key. */
+ public static final int F11 = 1018;
+
+ /** The Constant F12 indicates F12 key. */
+ public static final int F12 = 1019;
+
+ /** The Constant PRINT_SCREEN indicates Print Screen key. */
+ public static final int PRINT_SCREEN = 1020;
+
+ /** The Constant SCROLL_LOCK indicates Scroll Lock key. */
+ public static final int SCROLL_LOCK = 1021;
+
+ /** The Constant CAPS_LOCK indicates Caps Lock key. */
+ public static final int CAPS_LOCK = 1022;
+
+ /** The Constant NUM_LOCK indicates Num Lock key. */
+ public static final int NUM_LOCK = 1023;
+
+ /** The Constant PAUSE indicates Pause key. */
+ public static final int PAUSE = 1024;
+
+ /** The Constant INSERT indicates Insert key. */
+ public static final int INSERT = 1025;
+
+ /** The Constant ENTER indicates Enter key. */
+ public static final int ENTER = 10;
+
+ /** The Constant BACK_SPACE indicates Back Space key. */
+ public static final int BACK_SPACE = 8;
+
+ /** The Constant TAB indicates TAb key. */
+ public static final int TAB = 9;
+
+ /** The Constant ESCAPE indicates Escape key. */
+ public static final int ESCAPE = 27;
+
+ /** The Constant DELETE indicates Delete key. */
+ public static final int DELETE = 127;
+
+ /**
+ * The Constant WINDOW_DESTROY indicates an event when the user has asked the
+ * window manager to kill the window.
+ */
+ public static final int WINDOW_DESTROY = 201;
+
+ /**
+ * The Constant WINDOW_EXPOSE indicates an event when the user has asked the
+ * window manager to expose the window.
+ */
+ public static final int WINDOW_EXPOSE = 202;
+
+ /**
+ * The Constant WINDOW_ICONIFY indicates an event when the user has asked the
+ * window manager to inconify the window.
+ */
+ public static final int WINDOW_ICONIFY = 203;
+
+ /**
+ * The Constant WINDOW_DEICONIFY indicates an event when the user has asked the
+ * window manager to deinconify the window.
+ */
+ public static final int WINDOW_DEICONIFY = 204;
+
+ /**
+ * The Constant WINDOW_MOVED indicates an event when the user has asked the
+ * window manager to move the window.
+ */
+ public static final int WINDOW_MOVED = 205;
+
+ /**
+ * The Constant KEY_PRESS indicates an event when the user presses
+ * a normal key.
+ */
+ public static final int KEY_PRESS = 401;
+
+ /**
+ * The Constant KEY_RELEASE indicates an event when the user releases
+ * a normal key.
+ */
+ public static final int KEY_RELEASE = 402;
+
+ /**
+ * The Constant KEY_ACTION indicates an event when the user pressed
+ * a non-ASCII action key.
+ */
+ public static final int KEY_ACTION = 403;
+
+ /**
+ * The Constant KEY_ACTION_RELEASE indicates an event when the user released
+ * a non-ASCII action key.
+ */
+ public static final int KEY_ACTION_RELEASE = 404;
+
+ /**
+ * The Constant MOUSE_DOWN indicates an event when the user has pressed
+ * the mouse button.
+ */
+ public static final int MOUSE_DOWN = 501;
+
+ /**
+ * The Constant MOUSE_UP indicates an event when the user has released
+ * the mouse button.
+ */
+ public static final int MOUSE_UP = 502;
+
+ /**
+ * The Constant MOUSE_MOVE indicates an event when the user has moved
+ * the mouse with no button pressed.
+ */
+ public static final int MOUSE_MOVE = 503;
+
+ /**
+ * The Constant MOUSE_ENTER indicates an event when the mouse
+ * has entered a component.
+ */
+ public static final int MOUSE_ENTER = 504;
+
+ /**
+ * The Constant MOUSE_EXIT indicates an event when the mouse
+ * has exited a component.
+ */
+ public static final int MOUSE_EXIT = 505;
+
+ /** The Constant MOUSE_DRAG indicates an event when the user
+ * has moved a mouse with the pressed button.
+ */
+ public static final int MOUSE_DRAG = 506;
+
+ /**
+ * The Constant SCROLL_LINE_UP indicates an event when the user has
+ * activated line-up area of scrollbar.
+ */
+ public static final int SCROLL_LINE_UP = 601;
+
+ /**
+ * The Constant SCROLL_LINE_DOWN indicates an event when the user has
+ * activated line-down area of scrollbar.
+ */
+ public static final int SCROLL_LINE_DOWN = 602;
+
+ /**
+ * The Constant SCROLL_PAGE_UP indicates an event when the user has
+ * activated page up area of scrollbar.
+ */
+ public static final int SCROLL_PAGE_UP = 603;
+
+ /**
+ * The Constant SCROLL_PAGE_DOWN indicates an event when the user has
+ * activated page down area of scrollbar.
+ */
+ public static final int SCROLL_PAGE_DOWN = 604;
+
+ /**
+ * The Constant SCROLL_ABSOLUTE indicates an event when the user
+ * has moved the bubble in a scroll bar.
+ */
+ public static final int SCROLL_ABSOLUTE = 605;
+
+ /** The Constant SCROLL_BEGIN indicates a scroll begin event. */
+ public static final int SCROLL_BEGIN = 606;
+
+ /** The Constant SCROLL_END indicates a scroll end event. */
+ public static final int SCROLL_END = 607;
+
+ /**
+ * The Constant LIST_SELECT indicates that an item in a list
+ * has been selected.
+ */
+ public static final int LIST_SELECT = 701;
+
+ /**
+ * The Constant LIST_DESELECT indicates that an item in a list
+ * has been deselected.
+ */
+ public static final int LIST_DESELECT = 702;
+
+ /**
+ * The Constant ACTION_EVENT indicates that the user wants some
+ * action to occur.
+ */
+ public static final int ACTION_EVENT = 1001;
+
+ /** The Constant LOAD_FILE indicates a file loading event. */
+ public static final int LOAD_FILE = 1002;
+
+ /** The Constant SAVE_FILE indicates a file saving event. */
+ public static final int SAVE_FILE = 1003;
+
+ /** The Constant GOT_FOCUS indicates that a component got the focus. */
+ public static final int GOT_FOCUS = 1004;
+
+ /** The Constant LOST_FOCUS indicates that the component lost the focus. */
+ public static final int LOST_FOCUS = 1005;
+
+ /** The target is the component with which the event is associated. */
+ public Object target;
+
+ /** The when is timestamp when event has occured. */
+ public long when;
+
+ /** The id indicates the type of the event. */
+ public int id;
+
+ /** The x coordinate of event. */
+ public int x;
+
+ /** The y coordinate of event. */
+ public int y;
+
+ /** The key code of key event. */
+ public int key;
+
+ /** The state of the modifier keys (given by a bitmask). */
+ public int modifiers;
+
+ /** The click count indicates the number of consecutive clicks. */
+ public int clickCount;
+
+ /** The argument of the event. */
+ public Object arg;
+
+ /** The next event. */
+ public Event evt;
+
+ /**
+ * Instantiates a new event with the specified target component,
+ * event type, and argument.
+ *
+ * @param target the target component.
+ * @param id the event type.
+ * @param arg the argument.
+ */
+ public Event(Object target, int id, Object arg) {
+ this(target, 0l, id, 0, 0, 0, 0, arg);
+ }
+
+ /**
+ * Instantiates a new event with the specified target component, time stamp,
+ * event type, x and y coordinates, keyboard key, state of the modifier
+ * keys, and an argument set to null.
+ *
+ * @param target the target component.
+ * @param when the time stamp.
+ * @param id the event type.
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ * @param key the key.
+ * @param modifiers the modifier keys state.
+ */
+ public Event(Object target, long when, int id, int x, int y, int key, int modifiers) {
+ this(target, when, id, x, y, key, modifiers, null);
+ }
+
+ /**
+ * Instantiates a new event with the specified target component, time stamp,
+ * event type, x and y coordinates, keyboard key, state of the modifier
+ * keys, and an argument.
+ *
+ * @param target the target component.
+ * @param when the time stamp.
+ * @param id the event type.
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ * @param key the key.
+ * @param modifiers the modifier keys state.
+ * @param arg the specified argument.
+ */
+ public Event(Object target, long when, int id, int x, int y, int key, int modifiers, Object arg) {
+ this.target = target;
+ this.when = when;
+ this.id = id;
+ this.x = x;
+ this.y = y;
+ this.key = key;
+ this.modifiers = modifiers;
+ this.arg = arg;
+ }
+
+ /**
+ * Returns a string representation of this Event.
+ *
+ * @return a string representation of this Event.
+ */
+ @Override
+ public String toString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * Event e = new Event(new Button(), 0l, Event.KEY_PRESS,
+ * 0, 0, Event.TAB, Event.SHIFT_MASK, "arg");
+ * System.out.println(e);
+ */
+
+ return getClass().getName() + "[" + paramString() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ /**
+ * Returns a string representing the state of this Event.
+ *
+ * @return a string representing the state of this Event.
+ */
+ protected String paramString() {
+ return "id=" + id + ",x=" + x + ",y=" + y + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ (key != 0 ? ",key=" + key + getModifiersString() : "") + //$NON-NLS-1$ //$NON-NLS-2$
+ ",target=" + target + //$NON-NLS-1$
+ (arg != null ? ",arg=" + arg : ""); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ /**
+ * Gets a string representation of the modifiers.
+ *
+ * @return a string representation of the modifiers
+ */
+ private String getModifiersString() {
+ String strMod = ""; //$NON-NLS-1$
+ if (shiftDown()) {
+ strMod += ",shift"; //$NON-NLS-1$
+ }
+ if (controlDown()) {
+ strMod += ",control"; //$NON-NLS-1$
+ }
+ if (metaDown()) {
+ strMod += ",meta"; //$NON-NLS-1$
+ }
+ return strMod;
+ }
+
+ /**
+ * Translates x and y coordinates of his event to the x+dx and x+dy
+ * coordinates.
+ *
+ * @param dx the dx - the distance by which the event's x coordinate
+ * is increased
+ * @param dy the dy - the distance by which the event's y coordinate
+ * is increased
+ */
+ public void translate(int dx, int dy) {
+ x += dx;
+ y += dy;
+ }
+
+ /**
+ * Checks if Control key is down or not.
+ *
+ * @return true, if Control key is down; false otherwise.
+ */
+ public boolean controlDown() {
+ return (modifiers & CTRL_MASK) != 0;
+ }
+
+ /**
+ * Checks if Meta key is down or not.
+ *
+ * @return true, if Meta key is down; false otherwise.
+ */
+ public boolean metaDown() {
+ return (modifiers & META_MASK) != 0;
+ }
+
+ /**
+ * Checks if Shift key is down or not.
+ *
+ * @return true, if Shift key is down; false otherwise.
+ */
+ public boolean shiftDown() {
+ return (modifiers & SHIFT_MASK) != 0;
+ }
+
+}
+
diff --git a/awt/java/awt/EventDispatchThread.java b/awt/java/awt/EventDispatchThread.java
new file mode 100644
index 0000000..442c8a2
--- /dev/null
+++ b/awt/java/awt/EventDispatchThread.java
@@ -0,0 +1,118 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov, Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt;
+
+import org.apache.harmony.awt.wtk.NativeEvent;
+import org.apache.harmony.awt.wtk.NativeEventQueue;
+
+class EventDispatchThread extends Thread {
+
+ private static final class MarkerEvent extends AWTEvent {
+ MarkerEvent(Object source, int id) {
+ super(source, id);
+ }
+ }
+
+ final Dispatcher dispatcher;
+ final Toolkit toolkit;
+ private NativeEventQueue nativeQueue;
+
+ protected volatile boolean shutdownPending = false;
+
+ /**
+ * Initialise and run the main event loop
+ */
+ @Override
+ public void run() {
+ nativeQueue = toolkit.getNativeEventQueue();
+
+ try {
+ runModalLoop(null);
+ } finally {
+ toolkit.shutdownWatchdog.forceShutdown();
+ }
+ }
+
+ void runModalLoop(ModalContext context) {
+ long lastPaintTime = System.currentTimeMillis();
+ while (!shutdownPending && (context == null || context.isModalLoopRunning())) {
+ try {
+ EventQueue eventQueue = toolkit.getSystemEventQueueImpl();
+
+ NativeEvent ne = nativeQueue.getNextEvent();
+ if (ne != null) {
+ dispatcher.onEvent(ne);
+ MarkerEvent marker = new MarkerEvent(this, 0);
+ eventQueue.postEvent(marker);
+ for (AWTEvent ae = eventQueue.getNextEventNoWait();
+ (ae != null) && (ae != marker);
+ ae = eventQueue.getNextEventNoWait()) {
+ eventQueue.dispatchEvent(ae);
+ }
+ } else {
+ toolkit.shutdownWatchdog.setNativeQueueEmpty(true);
+ AWTEvent ae = eventQueue.getNextEventNoWait();
+ if (ae != null) {
+ eventQueue.dispatchEvent(ae);
+ long curTime = System.currentTimeMillis();
+ if (curTime - lastPaintTime > 10) {
+ toolkit.onQueueEmpty();
+ lastPaintTime = System.currentTimeMillis();
+ }
+ } else {
+ toolkit.shutdownWatchdog.setAwtQueueEmpty(true);
+ toolkit.onQueueEmpty();
+ lastPaintTime = System.currentTimeMillis();
+ waitForAnyEvent();
+ }
+ }
+ } catch (Throwable t) {
+ // TODO: Exception handler should be implemented
+ // t.printStackTrace();
+ }
+ }
+ }
+
+ private void waitForAnyEvent() {
+ EventQueue eventQueue = toolkit.getSystemEventQueueImpl();
+ if (!eventQueue.isEmpty() || !nativeQueue.isEmpty()) {
+ return;
+ }
+ Object eventMonitor = nativeQueue.getEventMonitor();
+ synchronized(eventMonitor) {
+ try {
+ eventMonitor.wait();
+ } catch (InterruptedException e) {}
+ }
+ }
+
+ void shutdown() {
+ shutdownPending = true;
+ }
+
+ EventDispatchThread(Toolkit toolkit, Dispatcher dispatcher ) {
+ this.toolkit = toolkit;
+ this.dispatcher = dispatcher;
+ setName("AWT-EventDispatchThread"); //$NON-NLS-1$
+ setDaemon(true);
+ }
+
+}
diff --git a/awt/java/awt/EventQueue.java b/awt/java/awt/EventQueue.java
new file mode 100644
index 0000000..3997546
--- /dev/null
+++ b/awt/java/awt/EventQueue.java
@@ -0,0 +1,310 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov, Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.event.InvocationEvent;
+import java.lang.reflect.InvocationTargetException;
+import java.util.EmptyStackException;
+
+/**
+ * The EventQueue class manages events. It is a platform-independent class
+ * that queues events both from the underlying peer classes and from trusted
+ * application classes.
+ */
+public class EventQueue {
+
+ /** The core ref. */
+ private final EventQueueCoreAtomicReference coreRef =
+ new EventQueueCoreAtomicReference();
+
+ /**
+ * The Class EventQueueCoreAtomicReference.
+ */
+ private static final class EventQueueCoreAtomicReference {
+
+ /** The core. */
+ private EventQueueCore core;
+
+ /*synchronized*/ /**
+ * Gets the.
+ *
+ * @return the event queue core
+ */
+ EventQueueCore get() {
+ return core;
+ }
+
+ /*synchronized*/ /**
+ * Sets the.
+ *
+ * @param newCore the new core
+ */
+ void set(EventQueueCore newCore) {
+ core = newCore;
+ }
+ }
+
+ /**
+ * Returns true if the calling thread is the current
+ * AWT EventQueue's dispatch thread.
+ *
+ * @return true, if the calling thread is the current
+ * AWT EventQueue's dispatch thread; false otherwise.
+ */
+ public static boolean isDispatchThread() {
+ return Thread.currentThread() instanceof EventDispatchThread;
+ }
+
+ /**
+ * Posts an InvocationEvent which executes the run() method on a Runnable
+ * when dispatched by the AWT event dispatcher thread.
+ *
+ * @param runnable the Runnable whose run method should be executed
+ * synchronously on the EventQueue.
+ */
+ public static void invokeLater(Runnable runnable) {
+ Toolkit toolkit = Toolkit.getDefaultToolkit();
+ InvocationEvent event = new InvocationEvent(toolkit, runnable);
+ toolkit.getSystemEventQueueImpl().postEvent(event);
+ }
+
+ /**
+ * Posts an InvocationEvent which executes the run() method on a Runnable
+ * when dispatched by the AWT event dispatcher thread and the
+ * notifyAll method is called on it immediately after run returns.
+ *
+ * @param runnable the Runnable whose run method should be executed
+ * synchronously on the EventQueue.
+ *
+ * @throws InterruptedException if another thread has interrupted
+ * this thread.
+ * @throws InvocationTargetException if a throwable is thrown
+ * when running the runnable.
+ */
+ public static void invokeAndWait(Runnable runnable)
+ throws InterruptedException, InvocationTargetException {
+
+ if (isDispatchThread()) {
+ throw new Error();
+ }
+
+ final Toolkit toolkit = Toolkit.getDefaultToolkit();
+ final Object notifier = new Object(); //$NON-LOCK-1$
+ InvocationEvent event = new InvocationEvent(
+ toolkit, runnable, notifier, true);
+
+ synchronized (notifier) {
+ toolkit.getSystemEventQueueImpl().postEvent(event);
+ notifier.wait();
+ }
+
+ Exception exception = event.getException();
+
+ if (exception != null) {
+ throw new InvocationTargetException(exception);
+ }
+ }
+
+ /**
+ * Gets the system event queue.
+ *
+ * @return the system event queue
+ */
+ private static EventQueue getSystemEventQueue() {
+ Thread th = Thread.currentThread();
+ if (th instanceof EventDispatchThread) {
+ return ((EventDispatchThread)th).toolkit.getSystemEventQueueImpl();
+ }
+ return null;
+ }
+
+ /**
+ * Gets the most recent event's timestamp.
+ * This event was dispatched from the EventQueue associated with the
+ * calling thread.
+ *
+ * @return the timestamp of the last Event to be dispatched,
+ * or System.currentTimeMillis() if this method is invoked from
+ * a thread other than an event-dispatching thread.
+ */
+ public static long getMostRecentEventTime() {
+ EventQueue eq = getSystemEventQueue();
+ return (eq != null) ?
+ eq.getMostRecentEventTimeImpl() : System.currentTimeMillis();
+ }
+
+ /**
+ * Gets the most recent event time impl.
+ *
+ * @return the most recent event time impl
+ */
+ private long getMostRecentEventTimeImpl() {
+ return getCore().getMostRecentEventTime();
+ }
+
+ /**
+ * Returns the the currently dispatched event by the EventQueue
+ * associated with the calling thread.
+ *
+ * @return the currently dispatched event or null if this method
+ * is invoked from a thread other than an event-dispatching thread.
+ */
+ public static AWTEvent getCurrentEvent() {
+ EventQueue eq = getSystemEventQueue();
+ return (eq != null) ?
+ eq.getCurrentEventImpl() : null;
+ }
+
+ /**
+ * Gets the current event impl.
+ *
+ * @return the current event impl
+ */
+ private AWTEvent getCurrentEventImpl() {
+ return getCore().getCurrentEvent();
+ }
+
+ /**
+ * Instantiates a new event queue.
+ */
+ public EventQueue() {
+ setCore(new EventQueueCore(this));
+ }
+
+ /**
+ * Instantiates a new event queue.
+ *
+ * @param t the t
+ */
+ EventQueue(Toolkit t) {
+ setCore(new EventQueueCore(this, t));
+ }
+
+ /**
+ * Posts a event to the EventQueue.
+ *
+ * @param event AWTEvent.
+ */
+ public void postEvent(AWTEvent event) {
+ event.isPosted = true;
+ getCore().postEvent(event);
+ }
+
+ /**
+ * Returns an event from the EventQueue and removes it from this queue.
+ *
+ * @return the next AWTEvent.
+ *
+ * @throws InterruptedException is thrown if another thread
+ * interrupts this thread.
+ */
+ public AWTEvent getNextEvent() throws InterruptedException {
+ return getCore().getNextEvent();
+ }
+
+ /**
+ * Gets the next event no wait.
+ *
+ * @return the next event no wait
+ */
+ AWTEvent getNextEventNoWait() {
+ return getCore().getNextEventNoWait();
+ }
+
+ /**
+ * Returns the first event of the EventQueue (without removing it
+ * from the queue).
+ *
+ * @return the the first AWT event of the EventQueue.
+ */
+ public AWTEvent peekEvent() {
+ return getCore().peekEvent();
+ }
+
+ /**
+ * Returns the first event of the EventQueue with the specified ID
+ * (without removing it from the queue).
+ *
+ * @param id the type ID of event.
+ *
+ * @return the first event of the EventQueue with the specified ID.
+ */
+ public AWTEvent peekEvent(int id) {
+ return getCore().peekEvent(id);
+ }
+
+ /**
+ * Replaces the existing EventQueue with the specified EventQueue.
+ * Any pending events are transferred to the new EventQueue.
+ *
+ * @param newEventQueue the new event queue.
+ */
+ public void push(EventQueue newEventQueue) {
+ getCore().push(newEventQueue);
+ }
+
+ /**
+ * Stops dispatching events using this EventQueue.
+ * Any pending events are transferred to the previous EventQueue.
+ *
+ * @throws EmptyStackException is thrown if no previous push
+ * was made on this EventQueue.
+ */
+ protected void pop() throws EmptyStackException {
+ getCore().pop();
+ }
+
+ /**
+ * Dispatches the specified event.
+ *
+ * @param event the AWTEvent.
+ */
+ protected void dispatchEvent(AWTEvent event) {
+ getCore().dispatchEventImpl(event);
+ }
+
+ /**
+ * Checks if the queue is empty.
+ *
+ * @return true, if is empty
+ */
+ boolean isEmpty() {
+ return getCore().isEmpty();
+ }
+
+ /**
+ * Gets the core.
+ *
+ * @return the core
+ */
+ EventQueueCore getCore() {
+ return coreRef.get();
+ }
+
+ /**
+ * Sets the core.
+ *
+ * @param newCore the new core
+ */
+ void setCore(EventQueueCore newCore) {
+ coreRef.set((newCore != null) ? newCore : new EventQueueCore(this));
+ }
+}
diff --git a/awt/java/awt/EventQueueCore.java b/awt/java/awt/EventQueueCore.java
new file mode 100644
index 0000000..ffc7c46
--- /dev/null
+++ b/awt/java/awt/EventQueueCore.java
@@ -0,0 +1,253 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.InputEvent;
+import java.awt.event.InputMethodEvent;
+import java.awt.event.InvocationEvent;
+import java.awt.event.MouseEvent;
+import java.util.LinkedList;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The events storage for EventQueue
+ */
+final class EventQueueCore {
+
+ private final LinkedList<EventQueue> queueStack = new LinkedList<EventQueue>();
+ private final LinkedList<AWTEvent> events = new LinkedList<AWTEvent>();
+
+ private Toolkit toolkit;
+ private EventQueue activeQueue;
+ private Thread dispatchThread;
+
+ AWTEvent currentEvent;
+ long mostRecentEventTime = System.currentTimeMillis();
+
+ EventQueueCore(EventQueue eq) {
+ synchronized (this) {
+ queueStack.addLast(eq);
+ activeQueue = eq;
+ }
+ }
+
+ EventQueueCore(EventQueue eq, Toolkit t) {
+ synchronized (this) {
+ queueStack.addLast(eq);
+ activeQueue = eq;
+ setToolkit(t);
+ }
+ }
+
+ synchronized long getMostRecentEventTime() {
+ return mostRecentEventTime;
+ }
+
+ synchronized AWTEvent getCurrentEvent() {
+ return currentEvent;
+ }
+
+ synchronized boolean isSystemEventQueue() {
+ return toolkit != null;
+ }
+
+ private void setToolkit(Toolkit t) {
+ toolkit = t;
+ if (toolkit != null) {
+ toolkit.setSystemEventQueueCore(this);
+ dispatchThread = toolkit.dispatchThread;
+ }
+ }
+
+ synchronized void postEvent(AWTEvent event) {
+ //???AWT
+ /*
+ events.addLast(event);
+ if ((toolkit == null) && (dispatchThread == null)) {
+ dispatchThread = new EventQueueThread(this);
+ dispatchThread.start();
+ }
+ // TODO: add event coalescing
+ if (toolkit != null) {
+ toolkit.shutdownWatchdog.setAwtQueueEmpty(false);
+ if (!GraphicsEnvironment.getLocalGraphicsEnvironment().isHeadlessInstance()) {
+ notifyEventMonitor(toolkit);
+ }
+ }
+ notifyAll();
+ */
+ }
+
+ void notifyEventMonitor(Toolkit t) {
+ Object em = t.getNativeEventQueue().getEventMonitor();
+ synchronized (em) {
+ em.notifyAll();
+ }
+ }
+
+ synchronized AWTEvent getNextEvent() throws InterruptedException {
+ while (events.isEmpty()) {
+ wait();
+ }
+ AWTEvent event = events.removeFirst();
+ // TODO: add event coalescing
+ return event;
+ }
+
+ synchronized AWTEvent peekEvent() {
+ return events.isEmpty() ? null : events.getFirst();
+ }
+
+ synchronized AWTEvent peekEvent(int id) {
+ for (AWTEvent event : events) {
+ if (event.getID() == id) {
+ return event;
+ }
+ }
+ return null;
+ }
+
+ synchronized void dispatchEvent(AWTEvent event) {
+ updateCurrentEventAndTime(event);
+ try {
+ activeQueue.dispatchEvent(event);
+ } finally {
+ currentEvent = null;
+ }
+ }
+
+ void dispatchEventImpl(AWTEvent event) {
+ if (event instanceof ActiveEvent) {
+ updateCurrentEventAndTime(event);
+ try {
+ ((ActiveEvent) event).dispatch();
+ } finally {
+ currentEvent = null;
+ }
+ return;
+ }
+
+ Object src = event.getSource();
+
+ if (src instanceof Component) {
+ if (preprocessComponentEvent(event)) {
+ ((Component) src).dispatchEvent(event);
+ }
+ } else {
+ if (toolkit != null) {
+ toolkit.dispatchAWTEvent(event);
+ }
+ if (src instanceof MenuComponent) {
+ ((MenuComponent) src).dispatchEvent(event);
+ }
+ }
+ }
+
+ private final boolean preprocessComponentEvent(AWTEvent event) {
+ if (event instanceof MouseEvent) {
+ return preprocessMouseEvent((MouseEvent)event);
+ }
+ return true;
+ }
+
+ private final boolean preprocessMouseEvent(MouseEvent event) {
+ //???AWT
+ /*
+ if (toolkit != null && toolkit.mouseEventPreprocessor != null) {
+ toolkit.lockAWT();
+ try {
+ return toolkit.mouseEventPreprocessor.preprocess(event);
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ return true;
+ */
+ return true;
+ }
+
+ private void updateCurrentEventAndTime(AWTEvent event) {
+ currentEvent = event;
+ long when = 0;
+ if (event instanceof ActionEvent) {
+ when = ((ActionEvent) event).getWhen();
+ } else if (event instanceof InputEvent) {
+ when = ((InputEvent) event).getWhen();
+ } else if (event instanceof InputMethodEvent) {
+ when = ((InputMethodEvent) event).getWhen();
+ } else if (event instanceof InvocationEvent) {
+ when = ((InvocationEvent) event).getWhen();
+ }
+ if (when != 0) {
+ mostRecentEventTime = when;
+ }
+ }
+
+ synchronized void push(EventQueue newEventQueue) {
+ // TODO: handle incorrect situations
+ if (queueStack.isEmpty()) {
+ // awt.6B=Queue stack is empty
+ throw new IllegalStateException(Messages.getString("awt.6B")); //$NON-NLS-1$
+ }
+
+ queueStack.addLast(newEventQueue);
+ activeQueue = newEventQueue;
+ activeQueue.setCore(this);
+ }
+
+ synchronized void pop() {
+ EventQueue removed = queueStack.removeLast();
+ if (removed != activeQueue) {
+ // awt.6C=Event queue stack is broken
+ throw new IllegalStateException(Messages.getString("awt.6C")); //$NON-NLS-1$
+ }
+ activeQueue = queueStack.getLast();
+ removed.setCore(null);
+ }
+
+ synchronized AWTEvent getNextEventNoWait() {
+ try {
+ return events.isEmpty() ? null : activeQueue.getNextEvent();
+ } catch (InterruptedException e) {
+ return null;
+ }
+ }
+
+ synchronized boolean isEmpty() {
+ return (currentEvent == null) && events.isEmpty();
+ }
+
+ synchronized boolean isEmpty(long timeout) {
+ if (!isEmpty()) {
+ return false;
+ }
+ try {
+ wait(timeout);
+ } catch (InterruptedException e) {}
+ return isEmpty();
+ }
+
+ synchronized EventQueue getActiveEventQueue() {
+ return activeQueue;
+ }
+}
diff --git a/awt/java/awt/Font.java b/awt/java/awt/Font.java
new file mode 100644
index 0000000..139ae68
--- /dev/null
+++ b/awt/java/awt/Font.java
@@ -0,0 +1,1500 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+import com.android.internal.awt.AndroidGraphics2D;
+
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphVector;
+import java.awt.font.LineMetrics;
+import java.awt.font.TextAttribute;
+import java.awt.font.TransformAttribute;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.BufferedInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Serializable;
+import java.text.CharacterIterator;
+import java.text.AttributedCharacterIterator.Attribute;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+import org.apache.harmony.awt.gl.font.AndroidGlyphVector;
+import org.apache.harmony.awt.gl.font.CommonGlyphVector;
+import org.apache.harmony.awt.gl.font.FontPeerImpl;
+import org.apache.harmony.awt.gl.font.FontMetricsImpl;
+import org.apache.harmony.awt.gl.font.LineMetricsImpl;
+import org.apache.harmony.awt.internal.nls.Messages;
+import org.apache.harmony.misc.HashCode;
+
+
+/**
+ * The Font class represents fonts for rendering text.
+ * This class allow to map characters to glyphs.
+ * <p>
+ * A glyph is a shape used to render a character or a sequence of
+ * characters. For example one character of Latin writing system
+ * represented by one glyth, but in complex writing system such as
+ * South and South-East Asian there is more complicated correspondence
+ * between characters and glyphs.
+ * <p>
+ * The Font object is identified by two types of names. The logical font name
+ * is the name that is used to construct the font. The font name
+ * is the name of a particular font face (for example, Arial Bold).
+ * The family name is the font's family name that specifies
+ * the typographic design across several faces (for example, Arial). In
+ * all the Font is identified by three attributes: the family name,
+ * the style (such as bold or italic), and the size.
+ */
+public class Font implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -4206021311591459213L;
+
+ // Identity Transform attribute
+ /** The Constant IDENTITY_TRANSFORM. */
+ private static final TransformAttribute IDENTITY_TRANSFORM = new TransformAttribute(
+ new AffineTransform());
+
+ /** The Constant PLAIN indicates font's plain style. */
+ public static final int PLAIN = 0;
+
+ /** The Constant BOLD indicates font's bold style. */
+ public static final int BOLD = 1;
+
+ /** The Constant ITALIC indicates font's italic style. */
+ public static final int ITALIC = 2;
+
+ /** The Constant ROMAN_BASELINE indicated roman baseline. */
+ public static final int ROMAN_BASELINE = 0;
+
+ /** The Constant CENTER_BASELINE indicates center baseline. */
+ public static final int CENTER_BASELINE = 1;
+
+ /** The Constant HANGING_BASELINE indicates hanging baseline. */
+ public static final int HANGING_BASELINE = 2;
+
+ /**
+ * The Constant TRUETYPE_FONT indicates a font resource of
+ * type TRUETYPE.
+ */
+ public static final int TRUETYPE_FONT = 0;
+
+ /**
+ * The Constant TYPE1_FONT indicates a font resource of
+ * type TYPE1.
+ */
+ public static final int TYPE1_FONT = 1;
+
+ /**
+ * The Constant LAYOUT_LEFT_TO_RIGHT indicates that text is
+ * left to right.
+ */
+ public static final int LAYOUT_LEFT_TO_RIGHT = 0;
+
+ /**
+ * The Constant LAYOUT_RIGHT_TO_LEFT indicates that text is
+ * right to left.
+ */
+ public static final int LAYOUT_RIGHT_TO_LEFT = 1;
+
+ /**
+ * The Constant LAYOUT_NO_START_CONTEXT indicates that the text
+ * in the char array before the indicated start should not be examined.
+ */
+ public static final int LAYOUT_NO_START_CONTEXT = 2;
+
+ /** The Constant LAYOUT_NO_LIMIT_CONTEXT indicates that text in
+ * the char array after the indicated limit should not be examined. */
+ public static final int LAYOUT_NO_LIMIT_CONTEXT = 4;
+
+ /** The Constant DEFAULT_FONT. */
+ static final Font DEFAULT_FONT = new Font("Dialog", Font.PLAIN, 12); //$NON-NLS-1$
+
+ /** The name of the Font. */
+ protected String name;
+
+ /** The style of the Font. */
+ protected int style;
+
+ /** The size of the Font. */
+ protected int size;
+
+ /** The point size of the Font. */
+ protected float pointSize;
+
+ // Flag if the Font object transformed
+ /** The transformed. */
+ private boolean transformed;
+
+ // Set of font attributes
+ /** The requested attributes. */
+ private Hashtable<Attribute, Object> fRequestedAttributes;
+
+ // font peer object corresponding to this Font
+ /** The font peer. */
+ private transient FontPeerImpl fontPeer;
+
+ // number of glyphs in this Font
+ /** The num glyphs. */
+ private transient int numGlyphs = -1;
+
+ // code for missing glyph for this Font
+ /** The missing glyph code. */
+ private transient int missingGlyphCode = -1;
+
+ /**
+ * Writes object to ObjectOutputStream.
+ *
+ * @param out ObjectOutputStream
+ *
+ * @throws IOException Signals that an I/O exception has occurred.
+ */
+ private void writeObject(java.io.ObjectOutputStream out) throws IOException {
+ out.defaultWriteObject();
+ }
+
+ /**
+ * Reads object from ObjectInputStream object and set native platform
+ * dependent fields to default values.
+ *
+ * @param in ObjectInputStream object
+ *
+ * @throws IOException Signals that an I/O exception has occurred.
+ * @throws ClassNotFoundException the class not found exception
+ */
+ private void readObject(java.io.ObjectInputStream in) throws IOException,
+ ClassNotFoundException {
+ in.defaultReadObject();
+
+ numGlyphs = -1;
+ missingGlyphCode = -1;
+
+ }
+
+ /**
+ * Instantiates a new Font with the specified attributes.
+ * The Font will be created with default attributes
+ * if the attribute's parameter is null.
+ *
+ * @param attributes the attributes to be assigned to the new Font, or null.
+ */
+ public Font(Map<? extends Attribute, ?> attributes) {
+ Object currAttr;
+
+ // Default values are taken from the documentation of the Font class.
+ // See Font constructor, decode and getFont sections.
+
+ this.name = "default"; //$NON-NLS-1$
+ this.size = 12;
+ this.pointSize = 12;
+ this.style = Font.PLAIN;
+
+ if (attributes != null) {
+
+ fRequestedAttributes = new Hashtable<Attribute, Object>(attributes);
+
+ currAttr = attributes.get(TextAttribute.SIZE);
+ if (currAttr != null) {
+ this.pointSize = ((Float) currAttr).floatValue();
+ this.size = (int) Math.ceil(this.pointSize);
+ }
+
+ currAttr = attributes.get(TextAttribute.POSTURE);
+ if (currAttr != null
+ && currAttr.equals(TextAttribute.POSTURE_OBLIQUE)) {
+ this.style |= Font.ITALIC;
+ }
+
+ currAttr = attributes.get(TextAttribute.WEIGHT);
+ if ((currAttr != null)
+ && (((Float) currAttr).floatValue() >= (TextAttribute.WEIGHT_BOLD)
+ .floatValue())) {
+ this.style |= Font.BOLD;
+ }
+
+ currAttr = attributes.get(TextAttribute.FAMILY);
+ if (currAttr != null) {
+ this.name = (String) currAttr;
+ }
+
+ currAttr = attributes.get(TextAttribute.TRANSFORM);
+ if (currAttr != null) {
+ if (currAttr instanceof TransformAttribute) {
+ this.transformed = !((TransformAttribute) currAttr)
+ .getTransform().isIdentity();
+ } else if (currAttr instanceof AffineTransform) {
+ this.transformed = !((AffineTransform) currAttr)
+ .isIdentity();
+ }
+ }
+
+ } else {
+ fRequestedAttributes = new Hashtable<Attribute, Object>(5);
+ fRequestedAttributes.put(TextAttribute.TRANSFORM,
+ IDENTITY_TRANSFORM);
+
+ this.transformed = false;
+
+ fRequestedAttributes.put(TextAttribute.FAMILY, name);
+
+ fRequestedAttributes.put(TextAttribute.SIZE, new Float(this.size));
+
+ if ((this.style & Font.BOLD) != 0) {
+ fRequestedAttributes.put(TextAttribute.WEIGHT,
+ TextAttribute.WEIGHT_BOLD);
+ } else {
+ fRequestedAttributes.put(TextAttribute.WEIGHT,
+ TextAttribute.WEIGHT_REGULAR);
+ }
+ if ((this.style & Font.ITALIC) != 0) {
+ fRequestedAttributes.put(TextAttribute.POSTURE,
+ TextAttribute.POSTURE_OBLIQUE);
+ } else {
+ fRequestedAttributes.put(TextAttribute.POSTURE,
+ TextAttribute.POSTURE_REGULAR);
+ }
+
+ }
+ }
+
+ /**
+ * Instantiates a new Font with the specified name, style and size.
+ *
+ * @param name the name of font.
+ * @param style the style of font.
+ * @param size the size of font.
+ */
+ public Font(String name, int style, int size) {
+
+ this.name = (name != null) ? name : "Default"; //$NON-NLS-1$
+ this.size = (size >= 0) ? size : 0;
+ this.style = (style & ~0x03) == 0 ? style : Font.PLAIN;
+ this.pointSize = this.size;
+
+ fRequestedAttributes = new Hashtable<Attribute, Object>(5);
+
+ fRequestedAttributes.put(TextAttribute.TRANSFORM, IDENTITY_TRANSFORM);
+
+ this.transformed = false;
+
+ fRequestedAttributes.put(TextAttribute.FAMILY, this.name);
+ fRequestedAttributes.put(TextAttribute.SIZE, new Float(this.size));
+
+ if ((this.style & Font.BOLD) != 0) {
+ fRequestedAttributes.put(TextAttribute.WEIGHT,
+ TextAttribute.WEIGHT_BOLD);
+ } else {
+ fRequestedAttributes.put(TextAttribute.WEIGHT,
+ TextAttribute.WEIGHT_REGULAR);
+ }
+ if ((this.style & Font.ITALIC) != 0) {
+ fRequestedAttributes.put(TextAttribute.POSTURE,
+ TextAttribute.POSTURE_OBLIQUE);
+ } else {
+ fRequestedAttributes.put(TextAttribute.POSTURE,
+ TextAttribute.POSTURE_REGULAR);
+ }
+ }
+
+ /**
+ * Returns true if this Font has a glyph for the specified character.
+ *
+ * @param c the character.
+ *
+ * @return true if this Font has a glyph for the specified character,
+ * false otherwise.
+ */
+ public boolean canDisplay(char c) {
+ FontPeerImpl peer = (FontPeerImpl) this.getPeer();
+ return peer.canDisplay(c);
+ }
+
+ /**
+ * Returns true if the Font can display the characters of the
+ * the specified text from the specified start position
+ * to the specified limit position.
+ *
+ * @param text the text.
+ * @param start the start offset (in the character array).
+ * @param limit the limit offset (in the character array).
+ *
+ * @return the a character's position in the text that this Font
+ * can not display, or -1 if this Font can display all characters
+ * in this text.
+ */
+ public int canDisplayUpTo(char[] text, int start, int limit) {
+ int st = start;
+ int result;
+ while ((st < limit) && canDisplay(text[st])) {
+ st++;
+ }
+
+ if (st == limit) {
+ result = -1;
+ } else {
+ result = st;
+ }
+
+ return result;
+ }
+
+ /**
+ * Returns true if the Font can display the characters of the
+ * the specified CharacterIterator from the specified start position
+ * and the specified limit position.
+ *
+ * @param iter the CharacterIterator.
+ * @param start the start offset.
+ * @param limit the limit offset.
+ *
+ * @return the a character's position in the CharacterIterator
+ * that this Font can not display, or -1 if this Font can display
+ * all characters in this text.
+ */
+ public int canDisplayUpTo(CharacterIterator iter, int start, int limit) {
+ int st = start;
+ char c = iter.setIndex(start);
+ int result;
+
+ while ((st < limit) && (canDisplay(c))) {
+ st++;
+ c = iter.next();
+ }
+ if (st == limit) {
+ result = -1;
+ } else {
+ result = st;
+ }
+
+ return result;
+ }
+
+ /**
+ * Returns true if this Font can display a specified String.
+ *
+ * @param str the String.
+ *
+ * @return the a character's position in the String that
+ * this Font can not display, or -1 if this Font can display
+ * all characters in this text.
+ */
+ public int canDisplayUpTo(String str) {
+ char[] chars = str.toCharArray();
+ return canDisplayUpTo(chars, 0, chars.length);
+ }
+
+ /**
+ * Creates a GlyphVector of associating characters to glyphs
+ * based on the unicode map of this Font.
+ *
+ * @param frc the FontRenderContext.
+ * @param chars the characters array.
+ *
+ * @return the GlyphVector of associating characters to glyphs
+ * based on the unicode map of this Font.
+ */
+ public GlyphVector createGlyphVector(FontRenderContext frc, char[] chars) {
+ return new AndroidGlyphVector(chars, frc, this, 0);
+ }
+
+ /**
+ * Creates a GlyphVector of associating characters contained
+ * in the specified CharacterIterator to glyphs based on
+ * the unicode map of this Font.
+ *
+ * @param frc the FontRenderContext.
+ * @param iter the CharacterIterator.
+ *
+ * @return the GlyphVector of associating characters contained
+ * in the specified CharacterIterator to glyphs
+ * based on the unicode map of this Font.
+ */
+ public GlyphVector createGlyphVector(FontRenderContext frc,
+ CharacterIterator iter) {
+ throw new RuntimeException("Not implemented!"); //$NON-NLS-1$
+ }
+
+ /**
+ * Creates a GlyphVector of associating characters to glyphs based on
+ * the unicode map of this Font.
+ *
+ * @param frc the FontRenderContext.
+ * @param glyphCodes the specified integer array of glyph codes.
+ *
+ * @return the GlyphVector of associating characters to glyphs
+ * based on the unicode map of this Font.
+ */
+ public GlyphVector createGlyphVector(FontRenderContext frc, int[] glyphCodes)
+ throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented!"); //$NON-NLS-1$
+ }
+
+ /**
+ * Creates a GlyphVector of associating characters to glyphs based on
+ * the unicode map of this Font.
+ *
+ * @param frc the FontRenderContext.
+ * @param str the specified String.
+ *
+ * @return the GlyphVector of associating characters to glyphs
+ * based on the unicode map of this Font.
+ */
+ public GlyphVector createGlyphVector(FontRenderContext frc, String str) {
+ return new AndroidGlyphVector(str.toCharArray(), frc, this, 0);
+
+ }
+
+ /**
+ * Returns the font style constant value corresponding to one of the font style
+ * names ("BOLD", "ITALIC", "BOLDITALIC"). This method returns Font.PLAIN if
+ * the argument is not one of the predefined style names.
+ *
+ * @param fontStyleName font style name
+ *
+ * @return font style constant value corresponding to the font style name
+ * specified.
+ */
+ private static int getFontStyle(String fontStyleName) {
+ int result = Font.PLAIN;
+
+ if (fontStyleName.toUpperCase().equals("BOLDITALIC")) { //$NON-NLS-1$
+ result = Font.BOLD | Font.ITALIC;
+ } else if (fontStyleName.toUpperCase().equals("BOLD")) { //$NON-NLS-1$
+ result = Font.BOLD;
+ } else if (fontStyleName.toUpperCase().equals("ITALIC")) { //$NON-NLS-1$
+ result = Font.ITALIC;
+ }
+
+ return result;
+ }
+
+ /**
+ * Decodes the specified string which described the Font. The string
+ * should have the following format: fontname-style-pointsize.
+ * The style can be PLAIN, BOLD, BOLDITALIC, or ITALIC.
+ *
+ * @param str the string which describes the font.
+ *
+ * @return the Font from the specified string.
+ */
+ public static Font decode(String str) {
+ // XXX: Documentation doesn't describe all cases, e.g. fonts face names
+ // with
+ // symbols that are suggested as delimiters in the documentation.
+ // In this decode implementation only ***-***-*** format is used with
+ // '-'
+ // as the delimiter to avoid unexpected parse results of font face names
+ // with spaces.
+
+ if (str == null) {
+ return DEFAULT_FONT;
+ }
+
+ StringTokenizer strTokens;
+ String delim = "-"; //$NON-NLS-1$
+ String substr;
+
+ int fontSize = DEFAULT_FONT.size;
+ int fontStyle = DEFAULT_FONT.style;
+ String fontName = DEFAULT_FONT.name;
+
+ strTokens = new StringTokenizer(str.trim(), delim);
+
+ // Font Name
+ if (strTokens.hasMoreTokens()) {
+ fontName = strTokens.nextToken(); // first token is the font name
+ }
+
+ // Font Style or Size (if the style is undefined)
+ if (strTokens.hasMoreTokens()) {
+ substr = strTokens.nextToken();
+
+ try {
+ // if second token is the font size
+ fontSize = Integer.parseInt(substr);
+ } catch (NumberFormatException e) {
+ // then second token is the font style
+ fontStyle = getFontStyle(substr);
+ }
+
+ }
+
+ // Font Size
+ if (strTokens.hasMoreTokens()) {
+ try {
+ fontSize = Integer.parseInt(strTokens.nextToken());
+ } catch (NumberFormatException e) {
+ }
+ }
+
+ return new Font(fontName, fontStyle, fontSize);
+ }
+
+ /**
+ * Perfoms the specified affine transform to the Font and returns
+ * a new Font.
+ *
+ * @param trans the AffineTransform.
+ *
+ * @return the Font object.
+ *
+ * @throws IllegalArgumentException if affine transform parameter
+ * is null.
+ */
+ @SuppressWarnings("unchecked")
+ public Font deriveFont(AffineTransform trans) {
+
+ if (trans == null) {
+ // awt.94=transform can not be null
+ throw new IllegalArgumentException(Messages.getString("awt.94")); //$NON-NLS-1$
+ }
+
+ Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>) fRequestedAttributes
+ .clone();
+
+ derivefRequestedAttributes.put(TextAttribute.TRANSFORM,
+ new TransformAttribute(trans));
+
+ return new Font(derivefRequestedAttributes);
+
+ }
+
+ /**
+ * Returns a new Font that is a copy of the current Font
+ * modified so that the size is the specified size.
+ *
+ * @param size the size of font.
+ *
+ * @return the Font object.
+ */
+ @SuppressWarnings("unchecked")
+ public Font deriveFont(float size) {
+ Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>) fRequestedAttributes
+ .clone();
+ derivefRequestedAttributes.put(TextAttribute.SIZE, new Float(size));
+ return new Font(derivefRequestedAttributes);
+ }
+
+ /**
+ * Returns a new Font that is a copy of the current Font
+ * modified so that the style is the specified style.
+ *
+ * @param style the style of font.
+ *
+ * @return the Font object.
+ */
+ @SuppressWarnings("unchecked")
+ public Font deriveFont(int style) {
+ Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>) fRequestedAttributes
+ .clone();
+
+ if ((style & Font.BOLD) != 0) {
+ derivefRequestedAttributes.put(TextAttribute.WEIGHT,
+ TextAttribute.WEIGHT_BOLD);
+ } else if (derivefRequestedAttributes.get(TextAttribute.WEIGHT) != null) {
+ derivefRequestedAttributes.remove(TextAttribute.WEIGHT);
+ }
+
+ if ((style & Font.ITALIC) != 0) {
+ derivefRequestedAttributes.put(TextAttribute.POSTURE,
+ TextAttribute.POSTURE_OBLIQUE);
+ } else if (derivefRequestedAttributes.get(TextAttribute.POSTURE) != null) {
+ derivefRequestedAttributes.remove(TextAttribute.POSTURE);
+ }
+
+ return new Font(derivefRequestedAttributes);
+ }
+
+ /**
+ * Returns a new Font that is a copy of the current Font
+ * modified to match the specified style and with the specified
+ * affine transform applied to its glyphs.
+ *
+ * @param style the style of font.
+ * @param trans the AffineTransform.
+ *
+ * @return the Font object.
+ */
+ @SuppressWarnings("unchecked")
+ public Font deriveFont(int style, AffineTransform trans) {
+
+ if (trans == null) {
+ // awt.94=transform can not be null
+ throw new IllegalArgumentException(Messages.getString("awt.94")); //$NON-NLS-1$
+ }
+ Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>) fRequestedAttributes
+ .clone();
+
+ if ((style & BOLD) != 0) {
+ derivefRequestedAttributes.put(TextAttribute.WEIGHT,
+ TextAttribute.WEIGHT_BOLD);
+ } else if (derivefRequestedAttributes.get(TextAttribute.WEIGHT) != null) {
+ derivefRequestedAttributes.remove(TextAttribute.WEIGHT);
+ }
+
+ if ((style & ITALIC) != 0) {
+ derivefRequestedAttributes.put(TextAttribute.POSTURE,
+ TextAttribute.POSTURE_OBLIQUE);
+ } else if (derivefRequestedAttributes.get(TextAttribute.POSTURE) != null) {
+ derivefRequestedAttributes.remove(TextAttribute.POSTURE);
+ }
+ derivefRequestedAttributes.put(TextAttribute.TRANSFORM,
+ new TransformAttribute(trans));
+
+ return new Font(derivefRequestedAttributes);
+ }
+
+ /**
+ * Returns a new Font that is a copy of the current Font
+ * modified so that the size and style are the specified
+ * size and style.
+ *
+ * @param style the style of font.
+ * @param size the size of font.
+ *
+ * @return the Font object.
+ */
+ @SuppressWarnings("unchecked")
+ public Font deriveFont(int style, float size) {
+ Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>) fRequestedAttributes
+ .clone();
+
+ if ((style & BOLD) != 0) {
+ derivefRequestedAttributes.put(TextAttribute.WEIGHT,
+ TextAttribute.WEIGHT_BOLD);
+ } else if (derivefRequestedAttributes.get(TextAttribute.WEIGHT) != null) {
+ derivefRequestedAttributes.remove(TextAttribute.WEIGHT);
+ }
+
+ if ((style & ITALIC) != 0) {
+ derivefRequestedAttributes.put(TextAttribute.POSTURE,
+ TextAttribute.POSTURE_OBLIQUE);
+ } else if (derivefRequestedAttributes.get(TextAttribute.POSTURE) != null) {
+ derivefRequestedAttributes.remove(TextAttribute.POSTURE);
+ }
+
+ derivefRequestedAttributes.put(TextAttribute.SIZE, new Float(size));
+ return new Font(derivefRequestedAttributes);
+
+ }
+
+ /**
+ * Returns a new Font object with a new set of font attributes.
+ *
+ * @param attributes the map of attributes.
+ *
+ * @return the Font.
+ */
+ @SuppressWarnings("unchecked")
+ public Font deriveFont(Map<? extends Attribute, ?> attributes) {
+ Attribute[] avalAttributes = this.getAvailableAttributes();
+
+ Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>) fRequestedAttributes
+ .clone();
+ Object currAttribute;
+ for (Attribute element : avalAttributes) {
+ currAttribute = attributes.get(element);
+ if (currAttribute != null) {
+ derivefRequestedAttributes.put(element, currAttribute);
+ }
+ }
+ return new Font(derivefRequestedAttributes);
+ }
+
+ /**
+ * Compares the specified Object with the current Font.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if the specified Object is an instance of Font
+ * with the same family, size, and style as this Font, false otherwise.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+
+ if (obj != null) {
+ try {
+ Font font = (Font) obj;
+
+ return ((this.style == font.style) && (this.size == font.size)
+ && this.name.equals(font.name)
+ && (this.pointSize == font.pointSize) && (this
+ .getTransform()).equals(font.getTransform()));
+ } catch (ClassCastException e) {
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Gets the map of font's attributes.
+ *
+ * @return the map of font's attributes.
+ */
+ @SuppressWarnings("unchecked")
+ public Map<TextAttribute, ?> getAttributes() {
+ return (Map<TextAttribute, ?>) fRequestedAttributes.clone();
+ }
+
+ /**
+ * Gets the keys of all available attributes.
+ *
+ * @return the keys array of all available attributes.
+ */
+ public Attribute[] getAvailableAttributes() {
+ Attribute[] attrs = { TextAttribute.FAMILY, TextAttribute.POSTURE,
+ TextAttribute.SIZE, TextAttribute.TRANSFORM,
+ TextAttribute.WEIGHT, TextAttribute.SUPERSCRIPT,
+ TextAttribute.WIDTH };
+ return attrs;
+ }
+
+ /**
+ * Gets the baseline for this character.
+ *
+ * @param c the character.
+ *
+ * @return the baseline for this character.
+ */
+ public byte getBaselineFor(char c) {
+ // TODO: implement using TT BASE table data
+ return 0;
+ }
+
+ /**
+ * Gets the family name of the Font.
+ *
+ * @return the family name of the Font.
+ */
+ public String getFamily() {
+ if (fRequestedAttributes != null) {
+ fRequestedAttributes.get(TextAttribute.FAMILY);
+ }
+ return null;
+ }
+
+ /**
+ * Returns the family name of this Font associated with
+ * the specified locale.
+ *
+ * @param l the locale.
+ *
+ * @return the family name of this Font associated with
+ * the specified locale.
+ */
+ public String getFamily(Locale l) {
+ if (l == null) {
+ // awt.01='{0}' parameter is null
+ throw new NullPointerException(Messages.getString(
+ "awt.01", "Locale")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ return getFamily();
+ }
+
+ /**
+ * Gets a Font with the specified attribute set.
+ *
+ * @param attributes the attributes to be assigned to the new Font.
+ *
+ * @return the Font.
+ */
+ public static Font getFont(Map<? extends Attribute, ?> attributes) {
+ Font fnt = (Font) attributes.get(TextAttribute.FONT);
+ if (fnt != null) {
+ return fnt;
+ }
+ return new Font(attributes);
+ }
+
+ /**
+ * Gets a Font object from the system properties list with the specified name
+ * or returns the specified Font if there is no such property.
+ *
+ * @param sp the specified property name.
+ * @param f the Font.
+ *
+ * @return the Font object from the system properties list with the specified name
+ * or the specified Font if there is no such property.
+ */
+ public static Font getFont(String sp, Font f) {
+ String pr = System.getProperty(sp);
+ if (pr == null) {
+ return f;
+ }
+ return decode(pr);
+ }
+
+ /**
+ * Gets a Font object from the system properties list with the specified name.
+ *
+ * @param sp the system property name.
+ *
+ * @return the Font, or null if there is no shuch property
+ * with the specified name.
+ */
+ public static Font getFont(String sp) {
+ return getFont(sp, null);
+ }
+
+ /**
+ * Gets the font name.
+ *
+ * @return the font name.
+ */
+ public String getFontName() {
+ if (fRequestedAttributes != null) {
+ fRequestedAttributes.get(TextAttribute.FAMILY);
+ }
+ return null;
+ }
+
+ /**
+ * Returns the font name associated with the specified locale.
+ *
+ * @param l the locale.
+ *
+ * @return the font name associated with the specified locale.
+ */
+ public String getFontName(Locale l) {
+ return getFamily();
+ }
+
+ /**
+ * Returns a LineMetrics object created with the specified parameters.
+ *
+ * @param chars the chars array.
+ * @param start the start offset.
+ * @param end the end offset.
+ * @param frc the FontRenderContext.
+ *
+ * @return the LineMetrics for the specified parameters.
+ */
+ public LineMetrics getLineMetrics(char[] chars, int start, int end,
+ FontRenderContext frc) {
+ if (frc == null) {
+ // awt.00=FontRenderContext is null
+ throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$
+ }
+
+ //FontMetrics fm = AndroidGraphics2D.getInstance().getFontMetrics();
+ FontMetrics fm = new FontMetricsImpl(this);
+ float[] fmet = {fm.getAscent(), fm.getDescent(), fm.getLeading()};
+ return new LineMetricsImpl(chars.length, fmet, null);
+ }
+
+ /**
+ * Returns a LineMetrics object created with the specified parameters.
+ *
+ * @param iter the CharacterIterator.
+ * @param start the start offset.
+ * @param end the end offset.
+ * @param frc the FontRenderContext.
+ *
+ * @return the LineMetrics for the specified parameters.
+ */
+ public LineMetrics getLineMetrics(CharacterIterator iter, int start,
+ int end, FontRenderContext frc) {
+
+ if (frc == null) {
+ // awt.00=FontRenderContext is null
+ throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$
+ }
+
+ String resultString;
+ int iterCount;
+
+ iterCount = end - start;
+ if (iterCount < 0) {
+ resultString = ""; //$NON-NLS-1$
+ } else {
+ char[] chars = new char[iterCount];
+ int i = 0;
+ for (char c = iter.setIndex(start); c != CharacterIterator.DONE
+ && (i < iterCount); c = iter.next()) {
+ chars[i] = c;
+ i++;
+ }
+ resultString = new String(chars);
+ }
+ return this.getLineMetrics(resultString, frc);
+ }
+
+ /**
+ * Returns a LineMetrics object created with the specified parameters.
+ *
+ * @param str the String.
+ * @param frc the FontRenderContext.
+ *
+ * @return the LineMetrics for the specified parameters.
+ */
+ public LineMetrics getLineMetrics(String str, FontRenderContext frc) {
+ //FontMetrics fm = AndroidGraphics2D.getInstance().getFontMetrics();
+ FontMetrics fm = new FontMetricsImpl(this);
+ float[] fmet = {fm.getAscent(), fm.getDescent(), fm.getLeading()};
+ //Log.i("FONT FMET", fmet.toString());
+ return new LineMetricsImpl(str.length(), fmet, null);
+
+ }
+
+ /**
+ * Returns a LineMetrics object created with the specified parameters.
+ *
+ * @param str the String.
+ * @param start the start offset.
+ * @param end the end offset.
+ * @param frc the FontRenderContext.
+ *
+ * @return the LineMetrics for the specified parameters.
+ */
+ public LineMetrics getLineMetrics(String str, int start, int end,
+ FontRenderContext frc) {
+ return this.getLineMetrics(str.substring(start, end), frc);
+ }
+
+ /**
+ * Gets the logical bounds of the specified String in
+ * the specified FontRenderContext. The logical bounds contains
+ * the origin, ascent, advance, and height.
+ *
+ * @param ci the specified CharacterIterator.
+ * @param start the start offset.
+ * @param end the end offset.
+ * @param frc the FontRenderContext.
+ *
+ * @return a Rectangle2D object.
+ */
+ public Rectangle2D getStringBounds(CharacterIterator ci, int start,
+ int end, FontRenderContext frc) {
+ int first = ci.getBeginIndex();
+ int finish = ci.getEndIndex();
+ char[] chars;
+
+ if (start < first) {
+ // awt.95=Wrong start index: {0}
+ throw new IndexOutOfBoundsException(Messages.getString(
+ "awt.95", start)); //$NON-NLS-1$
+ }
+ if (end > finish) {
+ // awt.96=Wrong finish index: {0}
+ throw new IndexOutOfBoundsException(Messages.getString(
+ "awt.96", end)); //$NON-NLS-1$
+ }
+ if (start > end) {
+ // awt.97=Wrong range length: {0}
+ throw new IndexOutOfBoundsException(Messages.getString("awt.97", //$NON-NLS-1$
+ (end - start)));
+ }
+
+ if (frc == null) {
+ throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$
+ }
+
+ chars = new char[end - start];
+
+ ci.setIndex(start);
+ for (int i = 0; i < chars.length; i++) {
+ chars[i] = ci.current();
+ ci.next();
+ }
+
+ return this.getStringBounds(chars, 0, chars.length, frc);
+
+ }
+
+ /**
+ * Gets the logical bounds of the specified String in
+ * the specified FontRenderContext. The logical bounds contains
+ * the origin, ascent, advance, and height.
+ *
+ * @param str the specified String.
+ * @param frc the FontRenderContext.
+ *
+ * @return a Rectangle2D object.
+ */
+ public Rectangle2D getStringBounds(String str, FontRenderContext frc) {
+ char[] chars = str.toCharArray();
+ return this.getStringBounds(chars, 0, chars.length, frc);
+
+ }
+
+ /**
+ * Gets the logical bounds of the specified String in
+ * the specified FontRenderContext. The logical bounds contains
+ * the origin, ascent, advance, and height.
+ *
+ * @param str the specified String.
+ * @param start the start offset.
+ * @param end the end offset.
+ * @param frc the FontRenderContext.
+ *
+ * @return a Rectangle2D object.
+ */
+ public Rectangle2D getStringBounds(String str, int start, int end,
+ FontRenderContext frc) {
+
+ return this.getStringBounds((str.substring(start, end)), frc);
+ }
+
+ /**
+ * Gets the logical bounds of the specified String in
+ * the specified FontRenderContext. The logical bounds contains
+ * the origin, ascent, advance, and height.
+ *
+ * @param chars the specified character array.
+ * @param start the start offset.
+ * @param end the end offset.
+ * @param frc the FontRenderContext.
+ *
+ * @return a Rectangle2D object.
+ */
+ public Rectangle2D getStringBounds(char[] chars, int start, int end,
+ FontRenderContext frc) {
+ if (start < 0) {
+ // awt.95=Wrong start index: {0}
+ throw new IndexOutOfBoundsException(Messages.getString(
+ "awt.95", start)); //$NON-NLS-1$
+ }
+ if (end > chars.length) {
+ // awt.96=Wrong finish index: {0}
+ throw new IndexOutOfBoundsException(Messages.getString(
+ "awt.96", end)); //$NON-NLS-1$
+ }
+ if (start > end) {
+ // awt.97=Wrong range length: {0}
+ throw new IndexOutOfBoundsException(Messages.getString("awt.97", //$NON-NLS-1$
+ (end - start)));
+ }
+
+ if (frc == null) {
+ throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$
+ }
+
+ FontPeerImpl peer = (FontPeerImpl) this.getPeer();
+
+ final int TRANSFORM_MASK = AffineTransform.TYPE_GENERAL_ROTATION
+ | AffineTransform.TYPE_GENERAL_TRANSFORM;
+ Rectangle2D bounds;
+
+ AffineTransform transform = getTransform();
+
+ // XXX: for transforms where an angle between basis vectors is not 90
+ // degrees Rectanlge2D class doesn't fit as Logical bounds.
+ if ((transform.getType() & TRANSFORM_MASK) == 0) {
+ int width = 0;
+ for (int i = start; i < end; i++) {
+ width += peer.charWidth(chars[i]);
+ }
+ //LineMetrics nlm = peer.getLineMetrics();
+
+ LineMetrics nlm = getLineMetrics(chars, start, end, frc);
+
+ bounds = transform.createTransformedShape(
+ new Rectangle2D.Float(0, -nlm.getAscent(), width, nlm
+ .getHeight())).getBounds2D();
+ } else {
+ int len = end - start;
+ char[] subChars = new char[len];
+ System.arraycopy(chars, start, subChars, 0, len);
+ bounds = createGlyphVector(frc, subChars).getLogicalBounds();
+ }
+ return bounds;
+ }
+
+ /**
+ * Gets the character's maximum bounds as defined in
+ * the specified FontRenderContext.
+ *
+ * @param frc the FontRenderContext.
+ *
+ * @return the character's maximum bounds.
+ */
+ public Rectangle2D getMaxCharBounds(FontRenderContext frc) {
+ if (frc == null) {
+ // awt.00=FontRenderContext is null
+ throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$
+ }
+
+ FontPeerImpl peer = (FontPeerImpl) this.getPeer();
+
+ Rectangle2D bounds = peer.getMaxCharBounds(frc);
+ AffineTransform transform = getTransform();
+ // !! Documentation doesn't describe meaning of max char bounds
+ // for the fonts that have rotate transforms. For all transforms
+ // returned bounds are the bounds of transformed maxCharBounds
+ // Rectangle2D that corresponds to the font with identity transform.
+ // TODO: resolve this issue to return correct bounds
+ bounds = transform.createTransformedShape(bounds).getBounds2D();
+
+ return bounds;
+ }
+
+ /**
+ * Returns a new GlyphVector object performing full layout of
+ * the text.
+ *
+ * @param frc the FontRenderContext.
+ * @param chars the character array to be layout.
+ * @param start the start offset of the text to use for
+ * the GlyphVector.
+ * @param count the count of characters to use for
+ * the GlyphVector.
+ * @param flags the flag indicating text direction:
+ * LAYOUT_RIGHT_TO_LEFT, LAYOUT_LEFT_TO_RIGHT.
+ *
+ * @return the GlyphVector.
+ */
+ public GlyphVector layoutGlyphVector(FontRenderContext frc, char[] chars,
+ int start, int count, int flags) {
+ // TODO: implement method for bidirectional text.
+ // At the moment only LTR and RTL texts supported.
+ if (start < 0) {
+ // awt.95=Wrong start index: {0}
+ throw new ArrayIndexOutOfBoundsException(Messages.getString(
+ "awt.95", //$NON-NLS-1$
+ start));
+ }
+
+ if (count < 0) {
+ // awt.98=Wrong count value, can not be negative: {0}
+ throw new ArrayIndexOutOfBoundsException(Messages.getString(
+ "awt.98", //$NON-NLS-1$
+ count));
+ }
+
+ if (start + count > chars.length) {
+ // awt.99=Wrong [start + count] is out of range: {0}
+ throw new ArrayIndexOutOfBoundsException(Messages.getString(
+ "awt.99", //$NON-NLS-1$
+ (start + count)));
+ }
+
+ char[] out = new char[count];
+ System.arraycopy(chars, start, out, 0, count);
+
+ return new CommonGlyphVector(out, frc, this, flags);
+ }
+
+ /**
+ * Returns the String representation of this Font.
+ *
+ * @return the String representation of this Font.
+ */
+ @Override
+ public String toString() {
+ String stl = "plain"; //$NON-NLS-1$
+ String result;
+
+ if (this.isBold() && this.isItalic()) {
+ stl = "bolditalic"; //$NON-NLS-1$
+ }
+ if (this.isBold() && !this.isItalic()) {
+ stl = "bold"; //$NON-NLS-1$
+ }
+
+ if (!this.isBold() && this.isItalic()) {
+ stl = "italic"; //$NON-NLS-1$
+ }
+
+ result = this.getClass().getName() + "[family=" + this.getFamily() + //$NON-NLS-1$
+ ",name=" + this.name + //$NON-NLS-1$
+ ",style=" + stl + //$NON-NLS-1$
+ ",size=" + this.size + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+ return result;
+ }
+
+ /**
+ * Gets the postscript name of this Font.
+ *
+ * @return the postscript name of this Font.
+ */
+ public String getPSName() {
+ FontPeerImpl peer = (FontPeerImpl) this.getPeer();
+ return peer.getPSName();
+ }
+
+ /**
+ * Gets the logical name of this Font.
+ *
+ * @return the logical name of this Font.
+ */
+ public String getName() {
+ return (this.name);
+ }
+
+ /**
+ * Gets the peer of this Font.
+ *
+ * @return the peer of this Font.
+ *
+ * @deprecated Font rendering is platform independent now.
+ */
+ @Deprecated
+ public java.awt.peer.FontPeer getPeer() {
+ if (fontPeer == null) {
+ fontPeer = (FontPeerImpl) Toolkit.getDefaultToolkit()
+ .getGraphicsFactory().getFontPeer(this);
+ }
+ return fontPeer;
+
+ }
+
+ /**
+ * Gets the transform acting on this Font (from the Font's
+ * attributes).
+ *
+ * @return the transformation of this Font.
+ */
+ public AffineTransform getTransform() {
+ Object transform = fRequestedAttributes.get(TextAttribute.TRANSFORM);
+
+ if (transform != null) {
+ if (transform instanceof TransformAttribute) {
+ return ((TransformAttribute) transform).getTransform();
+ }
+ if (transform instanceof AffineTransform) {
+ return new AffineTransform((AffineTransform) transform);
+ }
+ } else {
+ transform = new AffineTransform();
+ }
+ return (AffineTransform) transform;
+
+ }
+
+ /**
+ * Checks if this font is transformed or not.
+ *
+ * @return true, if this font is transformed, false otherwise.
+ */
+ public boolean isTransformed() {
+ return this.transformed;
+ }
+
+ /**
+ * Checks if this font has plain style or not.
+ *
+ * @return true, if this font has plain style, false otherwise.
+ */
+ public boolean isPlain() {
+ return (this.style == PLAIN);
+ }
+
+ /**
+ * Checks if this font has italic style or not.
+ *
+ * @return true, if this font has italic style, false otherwise.
+ */
+ public boolean isItalic() {
+ return (this.style & ITALIC) != 0;
+ }
+
+ /**
+ * Checks if this font has bold style or not.
+ *
+ * @return true, if this font has bold style, false otherwise.
+ */
+ public boolean isBold() {
+ return (this.style & BOLD) != 0;
+ }
+
+ /**
+ * Returns true if this Font has uniform line metrics.
+ *
+ * @return true if this Font has uniform line metrics,
+ * false otherwise.
+ */
+ public boolean hasUniformLineMetrics() {
+ FontPeerImpl peer = (FontPeerImpl) this.getPeer();
+ return peer.hasUniformLineMetrics();
+ }
+
+ /**
+ * Returns hash code of this Font object.
+ *
+ * @return the hash code of this Font object.
+
+ */
+ @Override
+ public int hashCode() {
+ HashCode hash = new HashCode();
+
+ hash.append(this.name);
+ hash.append(this.style);
+ hash.append(this.size);
+
+ return hash.hashCode();
+ }
+
+ /**
+ * Gets the style of this Font.
+ *
+ * @return the style of this Font.
+ */
+ public int getStyle() {
+ return this.style;
+ }
+
+ /**
+ * Gets the size of this Font.
+ *
+ * @return the size of this Font.
+ */
+ public int getSize() {
+ return this.size;
+ }
+
+ /**
+ * Gets the number of glyphs for this Font.
+ *
+ * @return the number of glyphs for this Font.
+ */
+ public int getNumGlyphs() {
+ if (numGlyphs == -1) {
+ FontPeerImpl peer = (FontPeerImpl) this.getPeer();
+ this.numGlyphs = peer.getNumGlyphs();
+ }
+ return this.numGlyphs;
+ }
+
+ /**
+ * Gets the glyphCode which is used as default glyph when this Font
+ * does not have a glyph for a specified unicode.
+ *
+ * @return the missing glyph code.
+ */
+ public int getMissingGlyphCode() {
+ if (missingGlyphCode == -1) {
+ FontPeerImpl peer = (FontPeerImpl) this.getPeer();
+ this.missingGlyphCode = peer.getMissingGlyphCode();
+ }
+ return this.missingGlyphCode;
+ }
+
+ /**
+ * Gets the float value of font's size.
+ *
+ * @return the float value of font's size.
+ */
+ public float getSize2D() {
+ return this.pointSize;
+ }
+
+ /**
+ * Gets the italic angle of this Font.
+ *
+ * @return the italic angle of this Font.
+ */
+ public float getItalicAngle() {
+ FontPeerImpl peer = (FontPeerImpl) this.getPeer();
+ return peer.getItalicAngle();
+ }
+
+ /**
+ * Creates the font with the specified font format and font file.
+ *
+ * @param fontFormat the font format.
+ * @param fontFile the file object represented the input data
+ * for the font.
+ *
+ * @return the Font.
+ *
+ * @throws FontFormatException is thrown if fontFile does not contain
+ * the required font tables for the specified format.
+ * @throws IOException signals that an I/O exception has occurred.
+ */
+ public static Font createFont(int fontFormat, File fontFile)
+ throws FontFormatException, IOException {
+ // ???AWT not supported
+ InputStream is = new FileInputStream(fontFile);
+ try {
+ return createFont(fontFormat, is);
+ } finally {
+ is.close();
+ }
+ }
+
+ /**
+ * Creates the font with the specified font format and input stream.
+ *
+ * @param fontFormat the font format.
+ * @param fontStream the input stream represented input data for
+ * the font.
+ *
+ * @return the Font.
+ *
+ * @throws FontFormatException is thrown if fontFile does not contain
+ * the required font tables for the specified format.
+ * @throws IOException signals that an I/O exception has occurred.
+ */
+ public static Font createFont(int fontFormat, InputStream fontStream)
+ throws FontFormatException, IOException {
+
+ // ???AWT not supported
+
+ BufferedInputStream buffStream;
+ int bRead = 0;
+ int size = 8192;
+ // memory page size, for the faster reading
+ byte buf[] = new byte[size];
+
+ if (fontFormat != TRUETYPE_FONT) { // awt.9A=Unsupported font format
+ throw new IllegalArgumentException(Messages.getString("awt.9A")); //$NON-NLS-1$
+ }
+
+ /* Get font file in system-specific directory */
+
+ File fontFile = Toolkit.getDefaultToolkit().getGraphicsFactory()
+ .getFontManager().getTempFontFile();
+
+ // BEGIN android-modified
+ buffStream = new BufferedInputStream(fontStream, 8192);
+ // END android-modified
+ FileOutputStream fOutStream = new FileOutputStream(fontFile);
+
+ bRead = buffStream.read(buf, 0, size);
+
+ while (bRead != -1) {
+ fOutStream.write(buf, 0, bRead);
+ bRead = buffStream.read(buf, 0, size);
+ }
+
+ buffStream.close();
+ fOutStream.close();
+
+ Font font = null;
+
+ font = Toolkit.getDefaultToolkit().getGraphicsFactory().embedFont(
+ fontFile.getAbsolutePath());
+ if (font == null) { // awt.9B=Can't create font - bad font data
+ throw new FontFormatException(Messages.getString("awt.9B")); //$NON-NLS-1$
+ }
+ return font;
+ }
+
+}
diff --git a/awt/java/awt/FontFormatException.java b/awt/java/awt/FontFormatException.java
new file mode 100644
index 0000000..c017fd2
--- /dev/null
+++ b/awt/java/awt/FontFormatException.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ * The FontFormatException class is used to provide notification
+ * and information that font can't be created.
+ */
+public class FontFormatException extends Exception {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -4481290147811361272L;
+
+ /**
+ * Instantiates a new font format exception with detailed message.
+ *
+ * @param reason the detailed message.
+ */
+ public FontFormatException(String reason) {
+ super(reason);
+ }
+
+}
diff --git a/awt/java/awt/FontMetrics.java b/awt/java/awt/FontMetrics.java
new file mode 100644
index 0000000..3948d73
--- /dev/null
+++ b/awt/java/awt/FontMetrics.java
@@ -0,0 +1,456 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.font.FontRenderContext;
+import java.awt.font.LineMetrics;
+import java.awt.geom.Rectangle2D;
+import java.io.Serializable;
+import java.text.CharacterIterator;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The FontMetrics class contains information about the rendering
+ * of a particular font on a particular screen.
+ * <p>
+ * Each character in the Font has three values that help define where
+ * to place it: an ascent, a descent, and an advance. The ascent is the
+ * distance the character extends above the baseline. The descent is
+ * the distance the character extends below the baseline.
+ * The advance width defines the position at which the next character
+ * should be placed.
+ * <p>
+ * An array of characters or a string has an ascent, a descent,
+ * and an advance width too. The ascent or descent of the array
+ * is specified by the maximum ascent or descent of the characters
+ * in the array. The advance width is the sum of the advance widths
+ * of each of the characters in the character array.
+ */
+public abstract class FontMetrics implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 1681126225205050147L;
+
+ /** The font from which the FontMetrics is created. */
+ protected Font font;
+
+ /**
+ * Instantiates a new font metrics from the specified Font.
+ *
+ * @param fnt the Font.
+ */
+ protected FontMetrics(Font fnt) {
+ this.font = fnt;
+ }
+
+ /**
+ * Returns the String representation of this FontMetrics.
+ *
+ * @return the string
+ */
+ @Override
+ public String toString() {
+ return this.getClass().getName() +
+ "[font=" + this.getFont() + //$NON-NLS-1$
+ "ascent=" + this.getAscent() + //$NON-NLS-1$
+ ", descent=" + this.getDescent() + //$NON-NLS-1$
+ ", height=" + this.getHeight() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ /**
+ * Gets the font associated with this FontMetrics.
+ *
+ * @return the font associated with this FontMetrics.
+ */
+ public Font getFont() {
+ return font;
+ }
+
+ /**
+ * Gets the height of the text line in this Font.
+ *
+ * @return the height of the text line in this Font.
+ */
+ public int getHeight() {
+ return this.getAscent() + this.getDescent() + this.getLeading();
+ }
+
+ /**
+ * Gets the font ascent of the Font associated with this FontMetrics.
+ * The font ascent is the distance from the font's baseline to
+ * the top of most alphanumeric characters.
+ *
+ * @return the ascent of the Font associated with this FontMetrics.
+ */
+ public int getAscent() {
+ return 0;
+ }
+
+ /**
+ * Gets the font descent of the Font associated with this FontMetrics.
+ * The font descent is the distance from the font's baseline to
+ * the bottom of most alphanumeric characters with descenders.
+ *
+ * @return the descent of the Font associated with this FontMetrics.
+ */
+ public int getDescent() {
+ return 0;
+ }
+
+ /**
+ * Gets the leading of the Font associated with this FontMetrics.
+ *
+ * @return the leading of the Font associated with this FontMetrics.
+ */
+ public int getLeading() {
+ return 0;
+ }
+
+ /**
+ * Gets the LineMetrics object for the specified CharacterIterator
+ * in the specified Graphics.
+ *
+ * @param ci the CharacterIterator.
+ * @param beginIndex the offset.
+ * @param limit the number of characters to be used.
+ * @param context the Graphics.
+ *
+ * @return the LineMetrics object for the specified CharacterIterator
+ * in the specified Graphics.
+ */
+ public LineMetrics getLineMetrics(CharacterIterator ci, int beginIndex,
+ int limit, Graphics context) {
+ return font.getLineMetrics(ci, beginIndex, limit,
+ this.getFRCFromGraphics(context));
+ }
+
+ /**
+ * Gets the LineMetrics object for the specified String
+ * in the specified Graphics.
+ *
+ * @param str the String.
+ * @param context the Graphics.
+ *
+ * @return the LineMetrics object for the specified String
+ * in the specified Graphics.
+ */
+ public LineMetrics getLineMetrics(String str, Graphics context) {
+ return font.getLineMetrics(str, this.getFRCFromGraphics(context));
+ }
+
+ /**
+ * Gets the LineMetrics object for the specified character
+ * array in the specified Graphics.
+ *
+ * @param chars the character array.
+ * @param beginIndex the offset of array.
+ * @param limit the number of characters to be used.
+ * @param context the Graphics.
+ *
+ * @return the LineMetrics object for the specified character
+ * array in the specified Graphics.
+ */
+ public LineMetrics getLineMetrics(char[] chars, int beginIndex, int limit,
+ Graphics context) {
+ return font.getLineMetrics(chars, beginIndex, limit,
+ this.getFRCFromGraphics(context));
+ }
+
+ /**
+ * Gets the LineMetrics object for the specified String
+ * in the specified Graphics.
+ *
+ * @param str the String.
+ * @param beginIndex the offset.
+ * @param limit the number of characters to be used.
+ * @param context the Graphics.
+ *
+ * @return the LineMetrics object for the specified String
+ * in the specified Graphics.
+ */
+ public LineMetrics getLineMetrics(String str, int beginIndex, int limit,
+ Graphics context) {
+ return font.getLineMetrics(str, beginIndex, limit,
+ this.getFRCFromGraphics(context));
+ }
+
+ /**
+ * Returns the character's maximum bounds in the specified
+ * Graphics context.
+ *
+ * @param context the Graphics context.
+ *
+ * @return the character's maximum bounds in the specified
+ * Graphics context.
+ */
+ public Rectangle2D getMaxCharBounds(Graphics context) {
+ return this.font.getMaxCharBounds(this.getFRCFromGraphics(context));
+ }
+
+ /**
+ * Gets the bounds of the specified CharacterIterator
+ * in the specified Graphics context.
+ *
+ * @param ci the CharacterIterator.
+ * @param beginIndex the begin offset of the array.
+ * @param limit the number of characters.
+ * @param context the Graphics.
+ *
+ * @return the bounds of the specified CharacterIterator
+ * in the specified Graphics context.
+ */
+ public Rectangle2D getStringBounds(CharacterIterator ci, int beginIndex,
+ int limit, Graphics context) {
+ return font.getStringBounds(ci, beginIndex, limit,
+ this.getFRCFromGraphics(context));
+ }
+
+ /**
+ * Gets the bounds of the specified String
+ * in the specified Graphics context.
+ *
+ * @param str the String.
+ * @param beginIndex the begin offset of the array.
+ * @param limit the number of characters.
+ * @param context the Graphics.
+ *
+ * @return the bounds of the specified String
+ * in the specified Graphics context.
+ */
+ public Rectangle2D getStringBounds(String str, int beginIndex, int limit,
+ Graphics context) {
+ return font.getStringBounds(str, beginIndex, limit,
+ this.getFRCFromGraphics(context));
+ }
+
+
+ /**
+ * Gets the bounds of the specified characters array
+ * in the specified Graphics context.
+ *
+ * @param chars the characters array.
+ * @param beginIndex the begin offset of the array.
+ * @param limit the number of characters.
+ * @param context the Graphics.
+ *
+ * @return the bounds of the specified characters array
+ * in the specified Graphics context.
+ */
+ public Rectangle2D getStringBounds(char[] chars, int beginIndex, int limit,
+ Graphics context) {
+ return font.getStringBounds(chars, beginIndex, limit,
+ this.getFRCFromGraphics(context));
+ }
+
+ /**
+ * Gets the bounds of the specified String
+ * in the specified Graphics context.
+ *
+ * @param str the String.
+ * @param context the Graphics.
+ *
+ * @return the bounds of the specified String
+ * in the specified Graphics context.
+ */
+ public Rectangle2D getStringBounds(String str, Graphics context) {
+ return font.getStringBounds(str, this.getFRCFromGraphics(context));
+ }
+
+ /**
+ * Checks if the Font has uniform line metrics or not.
+ * The Font can contain characters of other fonts for
+ * covering character set. In this case the Font isn't
+ * uniform.
+ *
+ * @return true, if the Font has uniform line metrics,
+ * false otherwise.
+ */
+ public boolean hasUniformLineMetrics() {
+ return this.font.hasUniformLineMetrics();
+ }
+
+ /**
+ * Returns the distance from the leftmost point to the rightmost
+ * point on the string's baseline showing the specified array
+ * of bytes in this Font.
+ *
+ * @param data the array of bytes to be measured.
+ * @param off the start offset.
+ * @param len the number of bytes to be measured.
+ *
+ * @return the advance width of the array.
+ */
+ public int bytesWidth(byte[] data, int off, int len) {
+ int width = 0;
+ if ((off >= data.length) || (off < 0)){
+ // awt.13B=offset off is out of range
+ throw new IllegalArgumentException(Messages.getString("awt.13B")); //$NON-NLS-1$
+ }
+
+ if ((off+len > data.length)){
+ // awt.13C=number of elemets len is out of range
+ throw new IllegalArgumentException(Messages.getString("awt.13C")); //$NON-NLS-1$
+ }
+
+ for (int i = off; i < off+len; i++){
+ width += charWidth(data[i]);
+ }
+
+ return width;
+ }
+
+ /**
+ * Returns the distance from the leftmost point to the rightmost
+ * point on the string's baseline showing the specified array
+ * of characters in this Font.
+ *
+ * @param data the array of characters to be measured.
+ * @param off the start offset.
+ * @param len the number of bytes to be measured.
+ *
+ * @return the advance width of the array.
+ */
+ public int charsWidth(char[] data, int off , int len){
+ int width = 0;
+ if ((off >= data.length) || (off < 0)){
+ // awt.13B=offset off is out of range
+ throw new IllegalArgumentException(Messages.getString("awt.13B")); //$NON-NLS-1$
+ }
+
+ if ((off+len > data.length)){
+ // awt.13C=number of elemets len is out of range
+ throw new IllegalArgumentException(Messages.getString("awt.13C")); //$NON-NLS-1$
+ }
+
+ for (int i = off; i < off+len; i++){
+ width += charWidth(data[i]);
+ }
+
+ return width;
+ }
+
+ /**
+ * Returns the distance from the leftmost point to the rightmost
+ * point of the specified character in this Font.
+ *
+ * @param ch the specified unicode point code of
+ * character to be measured.
+ *
+ * @return the advance width of the character.
+ */
+ public int charWidth(int ch) {
+ return 0;
+ }
+
+ /**
+ * Returns the distance from the leftmost point to the rightmost
+ * point of the specified character in this Font.
+ *
+ * @param ch the specified character to be measured.
+ *
+ * @return the advance width of the character.
+ */
+ public int charWidth(char ch) {
+ return 0;
+ }
+
+ /**
+ * Gets the maximum advance width of character in this Font.
+ *
+ * @return the maximum advance width of character in this Font.
+ */
+ public int getMaxAdvance() {
+ return 0;
+ }
+
+ /**
+ * Gets the maximum font ascent of the Font associated with
+ * this FontMetrics.
+ *
+ * @return the maximum font ascent of the Font associated with
+ * this FontMetrics.
+ */
+ public int getMaxAscent() {
+ return 0;
+ }
+
+ /**
+ * Gets the maximum font descent of character in this Font.
+ *
+ * @return the maximum font descent of character in this Font.
+ *
+ * @deprecated Replaced by getMaxDescent() method.
+ */
+ @Deprecated
+ public int getMaxDecent() {
+ return 0;
+ }
+
+ /**
+ * Gets the maximum font descent of character in this Font.
+ *
+ * @return the maximum font descent of character in this Font.
+ */
+ public int getMaxDescent() {
+ return 0;
+ }
+
+ /**
+ * Gets the advance widths of the characters in the Font.
+ *
+ * @return the advance widths of the characters in the Font.
+ */
+ public int[] getWidths() {
+ return null;
+ }
+
+ /**
+ * Returns the advance width for the specified String in this Font.
+ *
+ * @param str String to be measured.
+ *
+ * @return the the advance width for the specified String
+ * in this Font.
+ */
+ public int stringWidth(String str) {
+ return 0;
+ }
+
+ /**
+ * Returns FontRenderContext instanse of the Graphics context specified.
+ *
+ * @param context the specified Graphics context
+ *
+ * @return a FontRenderContext of the specified Graphics context.
+ */
+ private FontRenderContext getFRCFromGraphics(Graphics context){
+ FontRenderContext frc;
+ if (context instanceof Graphics2D) {
+ frc = ((Graphics2D)context).getFontRenderContext();
+ } else {
+ frc = new FontRenderContext(null, false, false);
+ }
+
+ return frc;
+ }
+}
+
diff --git a/awt/java/awt/GradientPaint.java b/awt/java/awt/GradientPaint.java
new file mode 100644
index 0000000..0e06528
--- /dev/null
+++ b/awt/java/awt/GradientPaint.java
@@ -0,0 +1,219 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.ColorModel;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The GradientPaint class defines a way to fill a Shape with a linear color
+ * gradient pattern.
+ * <p>
+ * The GradientPaint's fill pattern is determined by two points and two colors,
+ * plus the cyclic mode option.
+ * Each of the two points is painted with its corresponding color, and on
+ * the line segment connecting the two points, the color is proportionally
+ * changed between the two colors. For points on the same line which are not
+ * between the two specified points (outside of the connecting segment) their
+ * color is determined by the cyclic mode option. If the mode is cyclic, then
+ * the rest of the line repeats the color pattern of the connecting segment,
+ * cycling back and forth between the two colors. If not, the mode is acyclic
+ * which means that all points
+ * on the line outside the connecting line segment are given the same
+ * color as the closest of the two specified points.
+ * <p>
+ * The color of points that are not on the line connecting the two
+ * specified points are given by perpendicular projection: by taking
+ * the set of lines perpendicular to the connecting line and for each
+ * one, the whole line is colored with the same color.
+ */
+public class GradientPaint implements Paint {
+
+ /** The start point color. */
+ Color color1;
+
+ /** The end color point. */
+ Color color2;
+
+ /** The location of the start point. */
+ Point2D point1;
+
+ /** The location of the end point. */
+ Point2D point2;
+
+ /** The indicator of cycle filling. If TRUE filling
+ * repeated outside points stripe, if FALSE solid color filling outside. */
+ boolean cyclic;
+
+ /**
+ * Instantiates a new GradientPaint with cyclic or acyclic mode.
+ *
+ * @param point1 the first specified point.
+ * @param color1 the Color of the first specified point.
+ * @param point2 the second specified point.
+ * @param color2 the Color of the second specified point.
+ * @param cyclic the cyclic mode - true if the gradient pattern should cycle
+ * repeatedly between the two colors; false otherwise.
+ */
+ public GradientPaint(Point2D point1, Color color1, Point2D point2,
+ Color color2, boolean cyclic) {
+ if (point1 == null || point2 == null) {
+ // awt.6D=Point is null
+ throw new NullPointerException(Messages.getString("awt.6D")); //$NON-NLS-1$
+ }
+ if (color1 == null || color2 == null) {
+ // awt.6E=Color is null
+ throw new NullPointerException(Messages.getString("awt.6E")); //$NON-NLS-1$
+ }
+
+ this.point1 = point1;
+ this.point2 = point2;
+ this.color1 = color1;
+ this.color2 = color2;
+ this.cyclic = cyclic;
+ }
+
+ /**
+ * Instantiates a new GradientPaint with cyclic or acyclic mode;
+ * points are specified by coordinates.
+ *
+ * @param x1 the X coordinate of the first point.
+ * @param y1 the Y coordinate of the first point.
+ * @param color1 the color of the first point.
+ * @param x2 the X coordinate of the second point.
+ * @param y2 the Y coordinate of the second point.
+ * @param color2 the color of the second point.
+ * @param cyclic the cyclic mode - true if the gradient pattern should cycle
+ * repeatedly between the two colors; false otherwise.
+ */
+ public GradientPaint(float x1, float y1, Color color1, float x2, float y2, Color color2,
+ boolean cyclic) {
+ this(new Point2D.Float(x1, y1), color1, new Point2D.Float(x2, y2), color2, cyclic);
+ }
+
+ /**
+ * Instantiates a new acyclic GradientPaint;
+ * points are specified by coordinates.
+ *
+ * @param x1 the X coordinate of the first point.
+ * @param y1 the Y coordinate of the first point.
+ * @param color1 the color of the first point.
+ * @param x2 the X coordinate of the second point.
+ * @param y2 the Y coordinate of the second point.
+ * @param color2 the color of the second point.
+ */
+ public GradientPaint(float x1, float y1, Color color1, float x2, float y2, Color color2) {
+ this(x1, y1, color1, x2, y2, color2, false);
+ }
+
+ /**
+ * Instantiates a new acyclic GradientPaint.
+ *
+ * @param point1 the first specified point.
+ * @param color1 the Color of the first specified point.
+ * @param point2 the second specified point.
+ * @param color2 the Color of the second specified point.
+ */
+ public GradientPaint(Point2D point1, Color color1, Point2D point2, Color color2) {
+ this(point1, color1, point2, color2, false);
+ }
+
+ /**
+ * Creates PaintContext for a color pattern generating.
+ *
+ * @param cm the ColorModel of the Paint data.
+ * @param deviceBounds the bounding Rectangle of graphics primitives
+ * being rendered in the device space.
+ * @param userBounds tthe bounding Rectangle of graphics primitives
+ * being rendered in the user space.
+ * @param t the AffineTransform from user space into device space.
+ * @param hints the RrenderingHints object.
+ *
+ * @return the PaintContext for color pattern generating.
+ *
+ * @see java.awt.Paint#createContext(java.awt.image.ColorModel, java.awt.Rectangle, java.awt.geom.Rectangle2D, java.awt.geom.AffineTransform, java.awt.RenderingHints)
+ */
+ public PaintContext createContext(ColorModel cm, Rectangle deviceBounds,
+ Rectangle2D userBounds, AffineTransform t, RenderingHints hints) {
+ return new GradientPaintContext(cm, t, point1, color1, point2, color2, cyclic);
+ }
+
+ /**
+ * Gets the color of the first point.
+ *
+ * @return the color of the first point.
+ */
+ public Color getColor1() {
+ return color1;
+ }
+
+ /**
+ * Gets the color of the second point.
+ *
+ * @return the color of the second point.
+ */
+ public Color getColor2() {
+ return color2;
+ }
+
+ /**
+ * Gets the first point.
+ *
+ * @return the Point object - the first point.
+ */
+ public Point2D getPoint1() {
+ return point1;
+ }
+
+ /**
+ * Gets the second point.
+ *
+ * @return the Point object - the second point.
+ */
+ public Point2D getPoint2() {
+ return point2;
+ }
+
+ /**
+ * Gets the transparency mode for the GradientPaint.
+ *
+ * @return the transparency mode for the GradientPaint.
+ *
+ * @see java.awt.Transparency#getTransparency()
+ */
+ public int getTransparency() {
+ int a1 = color1.getAlpha();
+ int a2 = color2.getAlpha();
+ return (a1 == 0xFF && a2 == 0xFF) ? OPAQUE : TRANSLUCENT;
+ }
+
+ /**
+ * Returns the GradientPaint mode: true for cyclic mode, false for
+ * acyclic mode.
+ *
+ * @return true if the gradient cycles repeatedly between the two colors;
+ * false otherwise.
+ */
+ public boolean isCyclic() {
+ return cyclic;
+ }
+}
diff --git a/awt/java/awt/GradientPaintContext.java b/awt/java/awt/GradientPaintContext.java
new file mode 100644
index 0000000..74575f5
--- /dev/null
+++ b/awt/java/awt/GradientPaintContext.java
@@ -0,0 +1,204 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.awt.image.ColorModel;
+import java.awt.image.DataBufferInt;
+import java.awt.image.Raster;
+import java.awt.image.WritableRaster;
+
+class GradientPaintContext implements PaintContext {
+
+ /**
+ * The size of noncyclic part of color lookup table
+ */
+ static int LOOKUP_SIZE = 256;
+
+ /**
+ * The index mask to lookup color in the table
+ */
+ static int LOOKUP_MASK = 0x1FF;
+
+ /**
+ * The min value equivalent to zero. If absolute value less then ZERO it considered as zero.
+ */
+ static double ZERO = 1E-10;
+
+ /**
+ * The ColorModel user defined for PaintContext
+ */
+ ColorModel cm;
+
+ /**
+ * The indicator of cycle filling.
+ */
+ boolean cyclic;
+
+ /**
+ * The integer color value of the start point
+ */
+ int c1;
+
+ /**
+ * The integer color value of the end point
+ */
+ int c2;
+
+ /**
+ * The lookup gradient color table
+ */
+ int[] table;
+
+ /**
+ * The tempopary pre-calculated value to evalutae color index
+ */
+ int dx;
+
+ /**
+ * The tempopary pre-calculated value to evalutae color index
+ */
+ int dy;
+
+ /**
+ * The tempopary pre-calculated value to evalutae color index
+ */
+ int delta;
+
+ /**
+ * Constructs a new GradientPaintcontext
+ * @param cm - not used
+ * @param t - the fill transformation
+ * @param point1 - the start fill point
+ * @param color1 - color of the start point
+ * @param point2 - the end fill point
+ * @param color2 - color of the end point
+ * @param cyclic - the indicator of cycle filling
+ */
+ GradientPaintContext(ColorModel cm, AffineTransform t, Point2D point1, Color color1, Point2D point2, Color color2, boolean cyclic) {
+ this.cyclic = cyclic;
+ this.cm = ColorModel.getRGBdefault();
+
+ c1 = color1.getRGB();
+ c2 = color2.getRGB();
+
+ double px = point2.getX() - point1.getX();
+ double py = point2.getY() - point1.getY();
+
+ Point2D p = t.transform(point1, null);
+ Point2D bx = new Point2D.Double(px, py);
+ Point2D by = new Point2D.Double(py, -px);
+
+ t.deltaTransform(bx, bx);
+ t.deltaTransform(by, by);
+
+ double vec = bx.getX() * by.getY() - bx.getY() * by.getX();
+
+ if (Math.abs(vec) < ZERO) {
+ dx = dy = delta = 0;
+ table = new int[1];
+ table[0] = c1;
+ } else {
+ double mult = LOOKUP_SIZE * 256 / vec;
+ dx = (int)(by.getX() * mult);
+ dy = (int)(by.getY() * mult);
+ delta = (int)((p.getX() * by.getY() - p.getY() * by.getX()) * mult);
+ createTable();
+ }
+ }
+
+ /**
+ * Create color index lookup table. Calculate 256 step trasformation from
+ * the start point color to the end point color. Colors multiplied by 256 to do integer calculations.
+ */
+ void createTable() {
+ double ca = (c1 >> 24) & 0xFF;
+ double cr = (c1 >> 16) & 0xFF;
+ double cg = (c1 >> 8) & 0xFF;
+ double cb = c1 & 0xFF;
+
+ double k = 1.0 / LOOKUP_SIZE;
+ double da = (((c2 >> 24) & 0xFF) - ca) * k;
+ double dr = (((c2 >> 16) & 0xFF) - cr) * k;
+ double dg = (((c2 >> 8) & 0xFF) - cg) * k;
+ double db = ((c2 & 0xFF) - cb) * k;
+
+ table = new int[cyclic ? LOOKUP_SIZE + LOOKUP_SIZE : LOOKUP_SIZE];
+ for(int i = 0; i < LOOKUP_SIZE; i++) {
+ table[i] =
+ (int)ca << 24 |
+ (int)cr << 16 |
+ (int)cg << 8 |
+ (int)cb;
+ ca += da;
+ cr += dr;
+ cg += dg;
+ cb += db;
+ }
+ if (cyclic) {
+ for(int i = 0; i < LOOKUP_SIZE; i++) {
+ table[LOOKUP_SIZE + LOOKUP_SIZE - 1 - i] = table[i];
+ }
+ }
+ }
+
+ public ColorModel getColorModel() {
+ return cm;
+ }
+
+ public void dispose() {
+ }
+
+ public Raster getRaster(int x, int y, int w, int h) {
+ WritableRaster rast = cm.createCompatibleWritableRaster(w, h);
+
+ int[] buf = ((DataBufferInt)rast.getDataBuffer()).getData();
+
+ int c = x * dy - y * dx - delta;
+ int cx = dy;
+ int cy = - w * dy - dx;
+ int k = 0;
+
+ if (cyclic) {
+ for(int j = 0; j < h; j++) {
+ for(int i = 0; i < w; i++) {
+ buf[k++] = table[(c >> 8) & LOOKUP_MASK];
+ c += cx;
+ }
+ c += cy;
+ }
+ } else {
+ for(int j = 0; j < h; j++) {
+ for(int i = 0; i < w; i++) {
+ int index = c >> 8;
+ buf[k++] = index < 0 ? c1 : index >= LOOKUP_SIZE ? c2 : table[index];
+ c += cx;
+ }
+ c += cy;
+ }
+ }
+
+ return rast;
+ }
+
+}
+
diff --git a/awt/java/awt/Graphics.java b/awt/java/awt/Graphics.java
new file mode 100644
index 0000000..c20f6bc
--- /dev/null
+++ b/awt/java/awt/Graphics.java
@@ -0,0 +1,737 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.image.ImageObserver;
+import java.text.AttributedCharacterIterator;
+
+/**
+ * The abstract Graphics class allows applications to draw on a screen
+ * or other rendering target. There are several properties which
+ * define rendering options: origin point, clipping area, color, font.
+ * <br><br>
+ * The origin point specifies the beggining of the clipping area coordinate
+ * system. All coordinates used in rendering operations are computed with
+ * respect to this point. The clipping area defines the boundaries where
+ * rendering operations can be performed. Rendering operations can't modify
+ * pixels outside of the clipping area.
+ * <br><br>
+ * The draw and fill methods allow applications to drawing shapes, text,
+ * images with specified font and color options in the specified part
+ * of the screen.
+ *
+ */
+public abstract class Graphics {
+
+ // Constructors
+
+ /**
+ * Instantiates a new Graphics. This constructor is default for Graphics and
+ * can not be called directly.
+ */
+ protected Graphics() {
+ }
+
+ // Public methods
+
+ /**
+ * Creates a copy of the Graphics object with a new origin and a new
+ * specified clip area. The new clip area is the rectangle defined by
+ * the origin point with coordinates X,Y and the given width and height.
+ * The coordinates of all subsequent rendering operations will be computed
+ * with respect to the new origin and can be performed only within the
+ * range of the clipping area dimentions.
+ *
+ * @param x the X coordinate of the original point
+ * @param y the Y coordinate of the original point
+ * @param width the width of clipping area
+ * @param height the height of clipping area
+ *
+ * @return the Graphics object with new origin point and clipping area.
+ */
+ public Graphics create(int x, int y, int width, int height) {
+ Graphics res = create();
+ res.translate(x, y);
+ res.clipRect(0, 0, width, height);
+ return res;
+ }
+
+ /**
+ * Draws the higlighted outline of a rectangle.
+ *
+ * @param x the X coordinate of the rectangle's top left corner.
+ * @param y the Y coordinate of the rectangle's top left corner.
+ * @param width the width of rectangle.
+ * @param height the height of rectangle.
+ * @param raised a boolean value that determines whether the rectangle
+ * is drawn as raised or indented.
+ */
+ public void draw3DRect(int x, int y, int width, int height, boolean raised) {
+ // Note: lighter/darker colors should be used to draw 3d rect.
+ // The resulting rect is (width+1)x(height+1). Stroke and paint attributes of
+ // the Graphics2D should be reset to the default values.
+ // fillRect is used instead of drawLine to bypass stroke
+ // reset/set and rasterization.
+
+ Color color = getColor();
+ Color colorUp, colorDown;
+ if (raised) {
+ colorUp = color.brighter();
+ colorDown = color.darker();
+ } else {
+ colorUp = color.darker();
+ colorDown = color.brighter();
+ }
+
+ setColor(colorUp);
+ fillRect(x, y, width, 1);
+ fillRect(x, y+1, 1, height);
+
+ setColor(colorDown);
+ fillRect(x+width, y, 1, height);
+ fillRect(x+1, y+height, width, 1);
+ }
+
+ /**
+ * Draws the text represented by byte array. This method uses the current
+ * font and color for rendering.
+ *
+ * @param bytes the byte array which contains the text to be drawn.
+ * @param off the offset within the byte array of the text to be drawn.
+ * @param len the number of bytes of text to draw.
+ * @param x the X coordinate where the text is to be drawn.
+ * @param y the Y coordinate where the text is to be drawn.
+ */
+ public void drawBytes(byte[] bytes, int off, int len, int x, int y) {
+ drawString(new String(bytes, off, len), x, y);
+ }
+
+ /**
+ * Draws the text represented by character array. This method uses the
+ * current font and color for rendering.
+ *
+ * @param chars the character array.
+ * @param off the offset within the character array of the text to be drawn.
+ * @param len the number of characters which will be drawn.
+ * @param x the X coordinate where the text is to be drawn.
+ * @param y the Y coordinate where the text is to be drawn.
+ */
+ public void drawChars(char[] chars, int off, int len, int x, int y) {
+ drawString(new String(chars, off, len), x, y);
+ }
+
+ /**
+ * Draws the outline of a polygon which is defined by Polygon object.
+ *
+ * @param p the Polygon object.
+ */
+ public void drawPolygon(Polygon p) {
+ drawPolygon(p.xpoints, p.ypoints, p.npoints);
+ }
+
+ /**
+ * Draws the rectangle with the specified width and length and top left
+ * corner coordinates.
+ *
+ * @param x the X coordinate of the rectangle's top left corner.
+ * @param y the Y coordinate of the rectangle's top left corner.
+ * @param width the width of the rectangle.
+ * @param height the height of the rectangle.
+ */
+ public void drawRect(int x, int y, int width, int height) {
+ int []xpoints = {x, x, x+width, x+width};
+ int []ypoints = {y, y+height, y+height, y};
+
+ drawPolygon(xpoints, ypoints, 4);
+ }
+
+ /**
+ * Fills the higlighted outline of a rectangle.
+ *
+ * @param x the X coordinate of the rectangle's top left corner.
+ * @param y the Y coordinate of the rectangle's top left corner.
+ * @param width the width of the rectangle.
+ * @param height the height of the rectangle.
+ * @param raised a boolean value that determines whether the rectangle
+ * is drawn as raised or indented.
+ */
+ public void fill3DRect(int x, int y, int width, int height, boolean raised) {
+ // Note: lighter/darker colors should be used to draw 3d rect.
+ // The resulting rect is (width)x(height), same as fillRect.
+ // Stroke and paint attributes of the Graphics2D should be reset
+ // to the default values. fillRect is used instead of drawLine to
+ // bypass stroke reset/set and line rasterization.
+
+ Color color = getColor();
+ Color colorUp, colorDown;
+ if (raised) {
+ colorUp = color.brighter();
+ colorDown = color.darker();
+ setColor(color);
+ } else {
+ colorUp = color.darker();
+ colorDown = color.brighter();
+ setColor(colorUp);
+ }
+
+ width--;
+ height--;
+ fillRect(x+1, y+1, width-1, height-1);
+
+ setColor(colorUp);
+ fillRect(x, y, width, 1);
+ fillRect(x, y+1, 1, height);
+
+ setColor(colorDown);
+ fillRect(x+width, y, 1, height);
+ fillRect(x+1, y+height, width, 1);
+ }
+
+ /**
+ * Fills the polygon with the current color.
+ *
+ * @param p the Polygon object.
+ */
+ public void fillPolygon(Polygon p) {
+ fillPolygon(p.xpoints, p.ypoints, p.npoints);
+ }
+
+ /**
+ * Disposes of the Graphics.
+ */
+ @Override
+ public void finalize() {
+ }
+
+ /**
+ * Gets the bounds of the current clipping area as a rectangle
+ * and copies it to an existing rectangle.
+ *
+ * @param r a Rectangle object where the current clipping area
+ * bounds are to be copied.
+ *
+ * @return the bounds of the current clipping area.
+ */
+ public Rectangle getClipBounds(Rectangle r) {
+ Shape clip = getClip();
+
+ if (clip != null) {
+ // TODO: Can we get shape bounds without creating Rectangle object?
+ Rectangle b = clip.getBounds();
+ r.x = b.x;
+ r.y = b.y;
+ r.width = b.width;
+ r.height = b.height;
+ }
+
+ return r;
+ }
+
+ /**
+ * Gets the bounds of the current clipping area as a rectangle.
+ *
+ * @return a Rectangle object
+ *
+ * @deprecated Use {@link #getClipBounds()}
+ */
+ @Deprecated
+ public Rectangle getClipRect() {
+ return getClipBounds();
+ }
+
+ /**
+ * Gets the font metrics of the current font.
+ * The font metrics object contains information about the rendering
+ * of a particular font.
+ *
+ * @return the font metrics of current font.
+ */
+ public FontMetrics getFontMetrics() {
+ return getFontMetrics(getFont());
+ }
+
+ /**
+ * Determines whether or not the specified rectangle intersects the
+ * current clipping area.
+ *
+ * @param x the X coordinate of the rectangle.
+ * @param y the Y coordinate of the rectangle.
+ * @param width the width of the rectangle.
+ * @param height the height of the rectangle.
+ *
+ * @return true, if the specified rectangle intersects the current clipping area,
+ * overwise false.
+ */
+ public boolean hitClip(int x, int y, int width, int height) {
+ // TODO: Create package private method Rectangle.intersects(int, int, int, int);
+ return getClipBounds().intersects(new Rectangle(x, y, width, height));
+ }
+
+ /**
+ * Returns string which represents this Graphics object.
+ *
+ * @return the string which represents this Graphics object.
+ */
+ @Override
+ public String toString() {
+ // TODO: Think about string representation of Graphics.
+ return "Graphics"; //$NON-NLS-1$
+ }
+
+ // Abstract methods
+
+ /**
+ * Clears the specified rectangle. This method fills specified rectangle
+ * with background color.
+ *
+ * @param x the X coordinate of the rectangle.
+ * @param y the Y coordinate of the rectangle.
+ * @param width the width of the rectangle.
+ * @param height the height of the rectangle.
+ */
+ public abstract void clearRect(int x, int y, int width, int height);
+
+ /**
+ * Intersects the current clipping area with a new rectangle.
+ * If the current clipping area is not defined, the rectangle
+ * becomes a new clipping area. Rendering operations are only allowed
+ * within the new the clipping area.
+ *
+ * @param x the X coordinate of the rectangle for intersection.
+ * @param y the Y coordinate of the rectangle for intersection.
+ * @param width the width of the rectangle for intersection.
+ * @param height the height of the rectangle for intersection.
+ */
+ public abstract void clipRect(int x, int y, int width, int height);
+
+ /**
+ * Copies the rectangle area to another area specified by
+ * a distance (dx, dy) from the original rectangle's location.
+ * Positive dx and dy values give a new location defined by
+ * translation to the right and down from the original location,
+ * negative dx and dy values - to the left and up.
+ * <br><br>
+ *
+ * @param sx the X coordinate of the rectangle which will be copied.
+ * @param sy the Y coordinate of the rectangle which will be copied.
+ * @param width the width of the rectangle which will be copied.
+ * @param height the height of the rectangle which will be copied.
+ * @param dx the horizontal distance from the source rectangle's
+ * location to the copy's location.
+ * @param dy the vertical distance from the source rectangle's
+ * location to the copy's location.
+ */
+ public abstract void copyArea(int sx, int sy, int width, int height, int dx, int dy);
+
+ /**
+ * Creates a new copy of this Graphics.
+ *
+ * @return a new Graphics context which is a copy of this Graphics.
+ */
+ public abstract Graphics create();
+
+ /**
+ * Disposes of the Graphics. This Graphics object can not be used after
+ * calling this method.
+ */
+ public abstract void dispose();
+
+ /**
+ * Draws the arc covering the specified rectangle and using the current color.
+ * The rectangle is defined by the origin point (X, Y) and dimentions
+ * (width and height). The arc center is the the center of specified rectangle.
+ * The angle origin is 3 o'clock position, the positive angle is counted as a
+ * counter-clockwise rotation, the negotive angle is counted as clockwise rotation.
+ *
+ * @param x the X origin coordinate of the rectangle which scales the arc.
+ * @param y the Y origin coordinate of the rectangle which scales the arc.
+ * @param width the width of the rectangle which scales the arc.
+ * @param height the height of the rectangle which scales the arc.
+ * @param sa start angle - the origin angle of arc.
+ * @param ea arc angle - the angular arc value relative to the start angle.
+ */
+ public abstract void drawArc(int x, int y, int width, int height, int sa, int ea);
+
+ /**
+ * Draws the specified image with the defined background color.
+ * The top left corner of image will be drawn at point (x, y)
+ * in current coordinate system. The image loading process notifies the
+ * specified Image Observer. This method returns true if the image
+ * has loaded, overwise it returns false.
+ *
+ * @param img the image which will be drawn.
+ * @param x the X coordinate of the image top left corner.
+ * @param y the Y coordinate of the image top left corner.
+ * @param bgcolor the background color.
+ * @param observer the ImageObserver object which should be notified about image loading process.
+ *
+ * @return true, if loading image is successful or image is null, overwise false.
+ */
+ public abstract boolean drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer);
+
+ /**
+ * Draws the specified image.
+ * The top left corner of image will be drawn at point (x, y)
+ * in current coordinate system. The image loading process notifies the
+ * specified Image Observer. This method returns true if the image
+ * has loaded, overwise it returns false.
+ *
+ * @param img the image which will be drawn.
+ * @param x the X coordinate of the image top left corner.
+ * @param y the Y coordinate of the image top left corner.
+ * @param observer the ImageObserver object which should be notified about image loading process.
+ *
+ * @return true, if loading image is successful or image is null, overwise false.
+ */
+ public abstract boolean drawImage(Image img, int x, int y, ImageObserver observer);
+
+ /**
+ * Scales the specified image to fit in the specified rectangle and
+ * draws it with the defined background color. The top left corner
+ * of the image will be drawn at the point (x, y) in current coordinate
+ * system. The non-opaque pixels will be drawn in the background color.
+ * The image loading process notifies the specified Image Observer.
+ * This method returns true if the image has loaded, overwise it returns false.
+ *
+ * @param img the image which will be drawn.
+ * @param x the X coordinate of the image's top left corner.
+ * @param y the Y coordinate of the image's top left corner.
+ * @param width the width of rectangle which scales the image.
+ * @param height the height of rectangle which scales the image.
+ * @param bgcolor the background color.
+ * @param observer the ImageObserver object which should be notified about image loading process.
+ *
+ * @return true, if loading image is successful or image is null, overwise false.
+ */
+ public abstract boolean drawImage(Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer);
+
+ /**
+ * Scales the specified image to fit in the specified rectangle and
+ * draws it. The top left corner of the image will be drawn at the
+ * point (x, y) in current coordinate system. The image loading process
+ * notifies the specified Image Observer.
+ * This method returns true if the image has loaded, overwise it returns false.
+ *
+ * @param img the image which will be drawn.
+ * @param x the X coordinate of the image top left corner.
+ * @param y the Y coordinate of the image top left corner.
+ * @param width the width of rectangle which scales the image.
+ * @param height the height of rectangle which scales the image.
+ * @param observer the ImageObserver object which should be notified about image loading process.
+ *
+ * @return true, if loading image is successful or image is null, overwise false.
+ */
+ public abstract boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer);
+
+ /**
+ * Scales the specified area of the specified image to fit in the rectangle area
+ * defined by its corners coordinates and draws the sub-image with the specified
+ * background color. The sub-image to be drawn is defined by its top left
+ * corner coordinates (sx1, sy1) and bottom right corner coordinates (sx2, sy2)
+ * computed with respect to the origin (top left corner) of the source image.
+ * The non opaque pixels will be drawn in the background color. The
+ * image loading process notifies specified Image Observer.
+ * This method returns true if the image
+ * has loaded, overwise it returns false.
+ *
+ * @param img the image which will be drawn.
+ * @param dx1 the X top left corner coordinate of the destination rectangle area.
+ * @param dy1 the Y top left corner coordinate of the destination rectangle area.
+ * @param dx2 the X bottom right corner coordinate of the destination rectangle area.
+ * @param dy2 the Y bottom right corner coordinate of the destination rectangle area.
+ * @param sx1 the X top left corner coordinate of the area to be drawn within the source image.
+ * @param sy1 the Y top left corner coordinate of the area to be drawn within the source image.
+ * @param sx2 the X bottom right corner coordinate of the area to be drawn within the source image.
+ * @param sy2 the Y bottom right corner coordinate of the area to be drawn within the source image.
+ * @param bgcolor the background color.
+ * @param observer the ImageObserver object which should be notified about image loading process.
+ *
+ * @return true, if loading image is successful or image is null, overwise false.
+ */
+ public abstract boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer);
+
+ /**
+ * Scales the specified area of the specified image to fit in the rectangle area
+ * defined by its corners coordinates and draws the sub-image. The sub-image
+ * to be drawn is defined by its top left
+ * corner coordinates (sx1, sy1) and bottom right corner coordinates (sx2, sy2)
+ * computed with respect to the origin (top left corner) of the source image.
+ * The image loading process notifies specified Image Observer.
+ * This method returns true if the image
+ * has loaded, overwise it returns false.
+ *
+ * @param img the image which will be drawn.
+ * @param dx1 the X top left corner coordinate of the destination rectangle area.
+ * @param dy1 the Y top left corner coordinate of the destination rectangle area.
+ * @param dx2 the X bottom right corner coordinate of the destination rectangle area.
+ * @param dy2 the Y bottom right corner coordinate of the destination rectangle area.
+ * @param sx1 the X top left corner coordinate of the area to be drawn within the source image.
+ * @param sy1 the Y top left corner coordinate of the area to be drawn within the source image.
+ * @param sx2 the X bottom right corner coordinate of the area to be drawn within the source image.
+ * @param sy2 the Y bottom right corner coordinate of the area to be drawn within the source image.
+ * @param observer the ImageObserver object which should be notified about image loading process.
+ *
+ * @return true, if loading image is successful or image is null, overwise false.
+ */
+ public abstract boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer);
+
+ /**
+ * Draws a line from the point (x1, y1) to the point (x2, y2).
+ * This method draws the line with current color
+ * which can be changed by setColor(Color c) method.
+ *
+ * @param x1 the X coordinate of the first point.
+ * @param y1 the Y coordinate of the first point.
+ * @param x2 the X coordinate of the second point.
+ * @param y2 the Y coordinate of the second point.
+ */
+ public abstract void drawLine(int x1, int y1, int x2, int y2);
+
+ /**
+ * Draws the ouline of an oval to fit in the rectangle defined
+ * by the given width, height, and top left corner.
+ *
+ * @param x the X top left corner oval coordinate
+ * @param y the Y top left corner oval coordinate
+ * @param width the oval width
+ * @param height the oval height
+ */
+ public abstract void drawOval(int x, int y, int width, int height);
+
+ /**
+ * Draws the outline of a polygon. The polygon vertices are defined by points
+ * with xpoints[i], ypoints[i] as coordinates. The polygon edges are the
+ * lines from the points with (xpoints[i-1], ypoints[i-1]) coordinates to
+ * the points with (xpoints[i], ypoints[i]) coordinates, for 0 < i < npoints +1.
+ *
+ * @param xpoints the array of X coordinates of the polygon vertices.
+ * @param ypoints the array of Y coordinates of the polygon vertices.
+ * @param npoints the number of polygon vertices/points.
+ */
+ public abstract void drawPolygon(int[] xpoints, int[] ypoints, int npoints);
+
+ /**
+ * Draws a set of connected lines which are defined by the x and y coordinate arrays.
+ * The polyline is closed if coordinates of the first point are the same as
+ * coordinates of the last point.
+ *
+ * @param xpoints the array of X point coordinates.
+ * @param ypoints the array of Y point coordinates.
+ * @param npoints the number of points.
+ */
+ public abstract void drawPolyline(int[] xpoints, int[] ypoints, int npoints);
+
+ /**
+ * Draws the outline of a rectangle with round corners.
+ *
+ * @param x the X coordinate of the rectangle's top left corner.
+ * @param y the Y coordinate of the rectangle's top left corner.
+ * @param width the width of the rectangle.
+ * @param height the height of the rectangle.
+ * @param arcWidth the arc width for the corners.
+ * @param arcHeight the arc height for the corners.
+ */
+ public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight);
+
+ /**
+ * Draws a text defined by an iterator. The iterator should specify the font
+ * for every character.
+ *
+ * @param iterator the iterator.
+ * @param x the X coordinate of the firt character.
+ * @param y the Y coordinate of the first character.
+ */
+ public abstract void drawString(AttributedCharacterIterator iterator, int x, int y);
+
+ /**
+ * Draws a text defined by a string. This method draws the text with current
+ * font and color.
+ *
+ * @param str the string.
+ * @param x the X coordinate of the firt character.
+ * @param y the Y coordinate of the first character.
+ */
+ public abstract void drawString(String str, int x, int y);
+
+ /**
+ * Fills the arc covering the rectangle and using the current color.
+ * The rectangle is defined by the origin point (X, Y) and dimentions (width and height).
+ * The arc center is the the center of specified rectangle.
+ * The angle origin is at the 3 o'clock position, and a positive angle gives
+ * counter-clockwise rotation, a negative angle gives clockwise rotation.
+ *
+ * @param x the X origin coordinate of the rectangle which scales the arc.
+ * @param y the Y origin coordinate of the rectangle which scales the arc.
+ * @param width the width of the rectangle which scales the arc.
+ * @param height the height of the rectangle which scales the arc.
+ * @param sa start angle - the origin angle of arc.
+ * @param ea arc angle - the angular arc value relative to the start angle.
+ */
+ public abstract void fillArc(int x, int y, int width, int height, int sa, int ea);
+
+ /**
+ * Fills an oval with the current color where the oval is defined by the
+ * bounding rectangle with the given width, height, and top left corner.
+ *
+ * @param x the X top left corner oval coordinate.
+ * @param y the Y top left corner oval coordinate.
+ * @param width the oval width.
+ * @param height the oval height.
+ */
+ public abstract void fillOval(int x, int y, int width, int height);
+
+ /**
+ * Fills a polygon with the current color. The polygon vertices are defined by the points
+ * with xpoints[i], ypoints[i] as coordinates. The polygon edges are the
+ * lines from the points with (xpoints[i-1], ypoints[i-1]) coordinates to
+ * the points with (xpoints[i], ypoints[i]) coordinates, for 0 < i < npoints +1.
+ *
+ * @param xpoints the array of X coordinates of the polygon vertices.
+ * @param ypoints the array of Y coordinates of the polygon vertices.
+ * @param npoints the number of polygon vertices/points.
+ */
+ public abstract void fillPolygon(int[] xpoints, int[] ypoints, int npoints);
+
+ /**
+ * Fills a rectangle with the current color.
+ * The rectangle is defined by its width and length and top left corner coordinates.
+ *
+ * @param x the X coordinate of the rectangle's top left corner.
+ * @param y the Y coordinate of the rectangle's top left corner.
+ * @param width the width of rectangle.
+ * @param height the height of rectangle.
+ */
+ public abstract void fillRect(int x, int y, int width, int height);
+
+ /**
+ * Fills a round cornered rectangle with the current color.
+ *
+ * @param x the X coordinate of the top left corner of the bounding rectangle.
+ * @param y the Y coordinate of the top left corner of the bounding rectangle.
+ * @param width the width of the bounding rectangle.
+ * @param height the height of the bounding rectangle.
+ * @param arcWidth the arc width at the corners.
+ * @param arcHeight the arc height at the corners.
+ */
+ public abstract void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight);
+
+ /**
+ * Gets the clipping area.
+ * <br> <br>
+ *
+ * @return a Shape object of the clipping area or null if it is not set.
+ */
+ public abstract Shape getClip();
+
+ /**
+ * Gets the bounds of the current clipping area as a rectangle.
+ *
+ * @return a Rectangle object which represents the bounds of the current clipping area.
+ */
+ public abstract Rectangle getClipBounds();
+
+ /**
+ * Gets the current color of Graphics.
+ *
+ * @return the current color.
+ */
+ public abstract Color getColor();
+
+ /**
+ * Gets the current font of Graphics.
+ *
+ * @return the current font.
+ */
+ public abstract Font getFont();
+
+ /**
+ * Gets the font metrics of the specified font.
+ * The font metrics object contains information about the rendering of a particular font.
+ *
+ * @param font the specified font
+ *
+ * @return the font metrics for the specified font.
+ */
+ public abstract FontMetrics getFontMetrics(Font font);
+
+ /**
+ * Sets the new clipping area specified by rectangle. The new clipping area
+ * doesn't depend on the window's visibility. Rendering operations can't be performed
+ * outside new clipping area.
+ *
+ * @param x the X coordinate of the new clipping rectangle.
+ * @param y the Y coordinate of the new clipping rectangle.
+ * @param width the width of the new clipping rectangle.
+ * @param height the height of the new clipping rectangle.
+ */
+ public abstract void setClip(int x, int y, int width, int height);
+
+ /**
+ * Sets the new clipping area to be the area specified by Shape object.
+ * The new clipping area doesn't depend on the window's visibility.
+ * Rendering operations can't be performed outside new clipping area.
+ *
+ * @param clip a Shape object which representes new clipping area.
+ */
+ public abstract void setClip(Shape clip);
+
+ /**
+ * Sets the current Graphics color. All rendering operations with this Graphics
+ * will use this color.
+ *
+ * @param c the new color.
+ */
+ public abstract void setColor(Color c);
+
+ /**
+ * Sets the current Graphics font. All rendering operations with this Graphics
+ * will use this font.
+ *
+ * @param font the new font.
+ */
+ public abstract void setFont(Font font);
+
+ /**
+ * Sets the paint mode for the Graphics which overwrites all rendering
+ * operations with the current color.
+ *
+ */
+ public abstract void setPaintMode();
+
+ /**
+ * Sets the XOR mode for the Graphics which changes a pixel from
+ * the current color to the specified XOR color.
+ * <br> <br>
+ *
+ * @param color the new XOR mode
+ */
+ public abstract void setXORMode(Color color);
+
+ /**
+ * Translates the origin of Graphics current coordinate system
+ * to the point with X, Y coordinates in the current coordinate system.
+ * All rendering operation in this Graphics will be related to the new origin.
+ *
+ * @param x the X coordinate of the origin
+ * @param y the Y coordinate of the origin
+ */
+ public abstract void translate(int x, int y);
+}
diff --git a/awt/java/awt/Graphics2D.java b/awt/java/awt/Graphics2D.java
new file mode 100644
index 0000000..2ff5e0c
--- /dev/null
+++ b/awt/java/awt/Graphics2D.java
@@ -0,0 +1,456 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+import java.awt.font.GlyphVector;
+import java.awt.font.FontRenderContext;
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+import java.awt.image.BufferedImageOp;
+import java.awt.image.ImageObserver;
+import java.awt.image.RenderedImage;
+import java.awt.image.renderable.RenderableImage;
+import java.text.AttributedCharacterIterator;
+import java.util.Map;
+
+/**
+ * The Graphics2D class extends Graphics class and provides more capabilities
+ * for rendering text, images, shapes. This provides methods to peform
+ * transformation of coordinate system, color management, and text layout.
+ * The following attributes exist for rendering:
+ * <ul>
+ * <li>Color - current Graphics2D color;</li>
+ * <li>Font - current Graphics2D font;</li>
+ * <li>Stroke - pen with a width of 1 pixel;</li>
+ * <li>Transform - current Graphics2D Transformation;</li>
+ * <li>Composite - alpha compositing rules for combining source and destination colors.</li>
+ * </ul>
+ */
+public abstract class Graphics2D extends Graphics {
+
+ /**
+ * Instantiates a new Graphics2D object. This constructor should never be
+ * called directly.
+ */
+ protected Graphics2D() {
+ super();
+ }
+
+ /**
+ * Adds preferences for the rendering algorithms. The preferences
+ * are arbitrary and specified by Map objects. All specified by Map object
+ * preferencies can be modified.
+ *
+ * @param hints the rendering hints.
+ */
+ public abstract void addRenderingHints(Map<?, ?> hints);
+
+ /**
+ * Intersects the current clipping area with the specified Shape
+ * and the result becomes a new clipping area.
+ * If current clipping area is not defined, the Shape
+ * becomes the new clipping area. No rendering operations
+ * are allowed outside the clipping area.
+ *
+ * @param s the specified Shape object which will be intersected
+ * with current clipping area.
+ */
+ public abstract void clip(Shape s);
+
+ /**
+ * Draws the outline of the specified Shape.
+ *
+ * @param s the Shape which ouline is drawn.
+ */
+ public abstract void draw(Shape s);
+
+ /**
+ * Draws the specified GlyphVector object's text at the point x, y.
+ *
+ * @param g the GlyphVector object to be drawn.
+ * @param x the X position where the GlyphVector's text should
+ * be rendered.
+ * @param y the Y position where the GlyphVector's text should
+ * be rendered.
+ */
+ public abstract void drawGlyphVector(GlyphVector g, float x, float y);
+
+ /**
+ * Draws the BufferedImage -- modified according to the operation
+ * BufferedImageOp -- at the point x, y.
+ *
+ * @param img the BufferedImage to be rendered.
+ * @param op the filter to be applied to the image before rendering.
+ * @param x the X coordinate of the point where the image's upper left corner
+ * will be placed.
+ * @param y the Y coordinate of the point where the image's upper left corner
+ * will be placed.
+ */
+ public abstract void drawImage(BufferedImage img, BufferedImageOp op, int x, int y);
+
+ /**
+ * Draws BufferedImage transformed from image space into user space
+ * according to the AffineTransform xform and notifies the ImageObserver.
+ *
+ * @param img the BufferedImage to be rendered.
+ * @param xform the affine transformation from the image to the user space.
+ * @param obs the ImageObserver to be notified about the image conversion.
+ *
+ * @return true, if the image is successfully loaded and rendered,
+ * or it's null, otherwise false.
+ */
+ public abstract boolean drawImage(Image img, AffineTransform xform, ImageObserver obs);
+
+ /**
+ * Draws a RenderableImage which is transformed from image space into user
+ * according to the AffineTransform xform.
+ *
+ * @param img the RenderableImage to be rendered.
+ * @param xform the affine transformation from image to user space.
+ */
+ public abstract void drawRenderableImage(RenderableImage img, AffineTransform xform);
+
+ /**
+ * Draws a RenderedImage which is transformed from image space into user
+ * according to the AffineTransform xform.
+ *
+ * @param img the RenderedImage to be rendered.
+ * @param xform the affine transformation from image to user space.
+ */
+ public abstract void drawRenderedImage(RenderedImage img, AffineTransform xform);
+
+ /**
+ * Draws the string specified by the AttributedCharacterIterator.
+ * The first character's position is specified by the X, Y parameters.
+ *
+ * @param iterator whose text is drawn.
+ * @param x the X position where the first character is drawn.
+ * @param y the Y position where the first character is drawn.
+ */
+ public abstract void drawString(AttributedCharacterIterator iterator, float x, float y);
+
+ /**
+ * Draws the string specified by the AttributedCharacterIterator.
+ * The first character's position is specified by the X, Y parameters.
+ *
+ * @param iterator whose text is drawn.
+ * @param x the X position where the first character is drawn.
+ * @param y the Y position where the first character is drawn.
+ *
+ * @see java.awt.Graphics#drawString(AttributedCharacterIterator, int, int)
+ */
+ @Override
+ public abstract void drawString(AttributedCharacterIterator iterator, int x, int y);
+
+ /**
+ * Draws the String whose the first character position is specified
+ * by the parameters X, Y.
+ *
+ * @param s the String to be drawn.
+ * @param x the X position of the first character.
+ * @param y the Y position of the first character.
+ */
+ public abstract void drawString(String s, float x, float y);
+
+ /**
+ * Draws the String whose the first character coordinates are specified
+ * by the parameters X, Y.
+ *
+ * @param str the String to be drawn.
+ * @param x the X coordinate of the first character.
+ * @param y the Y coordinate of the first character.
+ *
+ * @see java.awt.Graphics#drawString(String, int, int)
+ */
+ @Override
+ public abstract void drawString(String str, int x, int y);
+
+ /**
+ * Fills the interior of the specified Shape.
+ *
+ * @param s the Shape to be filled.
+ */
+ public abstract void fill(Shape s);
+
+ /**
+ * Gets the background color.
+ *
+ * @return the current background color.
+ */
+ public abstract Color getBackground();
+
+ /**
+ * Gets the current composite of the Graphics2D.
+ *
+ * @return the current composite which specifies the compositing style.
+ */
+ public abstract Composite getComposite();
+
+ /**
+ * Gets the device configuration.
+ *
+ * @return the device configuration
+ */
+ public abstract GraphicsConfiguration getDeviceConfiguration();
+
+ /**
+ * Gets the rendering context of the Font.
+ *
+ * @return the FontRenderContext.
+ */
+ public abstract FontRenderContext getFontRenderContext();
+
+ /**
+ * Gets the current Paint of Graphics2D.
+ *
+ * @return the current Paint of Graphics2D.
+ */
+ public abstract Paint getPaint();
+
+ /**
+ * Gets the value of single preference for specified key.
+ *
+ * @param key the specified key of the rendering hint.
+ *
+ * @return the value of rendering hint for specified key.
+ */
+ public abstract Object getRenderingHint(RenderingHints.Key key);
+
+ /**
+ * Gets the set of the rendering preferences as a collection of
+ * key/value pairs.
+ *
+ * @return the RenderingHints which contains the rendering preferences.
+ */
+ public abstract RenderingHints getRenderingHints();
+
+ /**
+ * Gets current stroke of the Graphics2D.
+ *
+ * @return current stroke of the Graphics2D.
+ */
+ public abstract Stroke getStroke();
+
+ /**
+ * Gets current affine transform of the Graphics2D.
+ *
+ * @return current AffineTransform of the Graphics2D.
+ */
+ public abstract AffineTransform getTransform();
+
+ /**
+ * Determines wether or not the specified Shape intersects the specified
+ * Rectangle. If the onStroke parameter is true, this method
+ * checks whether or not the specified Shape outline intersects the specified
+ * Rectangle, otherwise this method checks whether or not the specified
+ * Shape's interior intersects the specified Rectangle.
+ *
+ * @param rect the specified Rectangle.
+ * @param s the Shape to check for intersection.
+ * @param onStroke the parameter determines whether or not this method checks
+ * for intersection of the Shape outline or of the Shape interior with
+ * the Rectangle.
+ *
+ * @return true, if there is a hit, otherwise false.
+ */
+ public abstract boolean hit(Rectangle rect, Shape s, boolean onStroke);
+
+ /**
+ * Performs a rotation transform relative to current Graphics2D Transform.
+ * The coordinate system is rotated by the specified angle in radians relative to
+ * current origin.
+ *
+ * @param theta the angle of rotation in radians.
+ */
+ public abstract void rotate(double theta);
+
+ /**
+ * Performs a translated rotation transform relative to current Graphics2D
+ * Transform. The coordinate system is rotated by the specified angle in radians
+ * relative to current origin and then moved to point (x, y).
+ *
+ * Is this right?
+ *
+ * @param theta the angle of rotation in radians.
+ * @param x the X coordinate.
+ * @param y the Y coordinate.
+ */
+ public abstract void rotate(double theta, double x, double y);
+
+ /**
+ * Performs a linear scale transform relative to current Graphics2D Transform.
+ * The coordinate system is rescaled vertically and horizontally
+ * by the specified parameters.
+ *
+ * @param sx the scaling factor by which the X coordinate is multiplied.
+ * @param sy the scaling factor by which the Y coordinate is multiplied.
+ */
+ public abstract void scale(double sx, double sy);
+
+ /**
+ * Sets a new background color for clearing rectangular areas.
+ * The clearRect method uses the current background color.
+ *
+ * @param color the new background color.
+ */
+ public abstract void setBackground(Color color);
+
+ /**
+ * Sets the current composite for Graphics2D.
+ *
+ * @param comp the Composite object.
+ */
+ public abstract void setComposite(Composite comp);
+
+ /**
+ * Sets the paint for Graphics2D.
+ *
+ * @param paint the Paint object.
+ */
+ public abstract void setPaint(Paint paint);
+
+ /**
+ * Sets a key-value pair in the current RenderingHints map.
+ *
+ * @param key the key of the rendering hint to set.
+ * @param value the value to set for the rendering hint.
+ */
+ public abstract void setRenderingHint(RenderingHints.Key key, Object value);
+
+ /**
+ * Replaces the current rendering hints with the specified rendering preferences.
+ *
+ * @param hints the new Map of rendering hints.
+ */
+ public abstract void setRenderingHints(Map<?, ?> hints);
+
+ /**
+ * Sets the stroke for the Graphics2D.
+ *
+ * @param s the Stroke object.
+ */
+ public abstract void setStroke(Stroke s);
+
+ /**
+ * Overwrite the current Transform of the Graphics2D. The specified Transform
+ * should be received from the getTransform() method and should be used
+ * only for restoring the original Graphics2D transform after calling
+ * draw or fill methods.
+ *
+ * @param Tx the specified Transform.
+ */
+ public abstract void setTransform(AffineTransform Tx);
+
+ /**
+ * Performs a shear transform relative to current Graphics2D Transform.
+ * The coordinate system is shifted by the specified multipliers relative to
+ * current position.
+ *
+ * @param shx the multiplier by which the X coordinates shift position
+ * along X axis as a function of Y coordinates.
+ * @param shy the multiplier by which the Y coordinates shift position
+ * along Y axis as a function of X coordinates.
+ */
+ public abstract void shear(double shx, double shy);
+
+ /**
+ * Concatenates the AffineTransform object with current Transform
+ * of this Graphics2D. The transforms are applied in reverse order
+ * with the last specified transform applied first and the next
+ * transformation applied to the result of previous transformation.
+ * More precisely, if Cx is the current Graphics2D transform, the
+ * transform method's result with Tx as the parameter
+ * is the transformation Rx, where Rx(p) = Cx(Tx(p)), for p - a point
+ * in current coordinate system. Rx becomes the current Transform
+ * for this Graphics2D.
+ *
+ * @param Tx the AffineTransform object to be concatenated with
+ * current Transform.
+ */
+ public abstract void transform(AffineTransform Tx);
+
+ /**
+ * Performs a translate transform relative to current Graphics2D Transform.
+ * The coordinate system is moved by the specified distance relative
+ * to current position.
+ *
+ * @param tx the translation distance along the X axis.
+ * @param ty the translation distance along the Y axis.
+ */
+ public abstract void translate(double tx, double ty);
+
+ /**
+ * Moves the origin Graphics2D Transform to the point with x, y
+ * coordinates in current coordinate system. The new origin of coordinate
+ * system is moved to the (x, y) point accordingly. All rendering and
+ * transform operations are performed relative to this new origin.
+ *
+ * @param x the X coordinate.
+ * @param y the Y coordinate.
+ *
+ * @see java.awt.Graphics#translate(int, int)
+ */
+ @Override
+ public abstract void translate(int x, int y);
+
+ /**
+ * Fills a 3D rectangle with the current color.
+ * The rectangle is specified by its width, height, and top left corner
+ * coordinates.
+ *
+ * @param x the X coordinate of the rectangle's top left corner.
+ * @param y the Y coordinate of the rectangle's top left corner.
+ * @param width the width of rectangle.
+ * @param height the height of rectangle.
+ * @param raised a boolean value that determines whether the rectangle
+ * is drawn as raised or indented.
+ *
+ * @see java.awt.Graphics#fill3DRect(int, int, int, int, boolean)
+ */
+ @Override
+ public void fill3DRect(int x, int y, int width, int height, boolean raised) {
+ // According to the spec, color should be used instead of paint,
+ // so Graphics.fill3DRect resets paint and
+ // it should be restored after the call
+ Paint savedPaint = getPaint();
+ super.fill3DRect(x, y, width, height, raised);
+ setPaint(savedPaint);
+ }
+
+ /**
+ * Draws the higlighted outline of a rectangle.
+ *
+ * @param x the X coordinate of the rectangle's top left corner.
+ * @param y the Y coordinate of the rectangle's top left corner.
+ * @param width the width of rectangle.
+ * @param height the height of rectangle.
+ * @param raised a boolean value that determines whether the rectangle
+ * is drawn as raised or indented.
+ *
+ * @see java.awt.Graphics#draw3DRect(int, int, int, int, boolean)
+ */
+ @Override
+ public void draw3DRect(int x, int y, int width, int height, boolean raised) {
+ // According to the spec, color should be used instead of paint,
+ // so Graphics.draw3DRect resets paint and
+ // it should be restored after the call
+ Paint savedPaint = getPaint();
+ super.draw3DRect(x, y, width, height, raised);
+ setPaint(savedPaint);
+ }
+}
\ No newline at end of file
diff --git a/awt/java/awt/GraphicsConfiguration.java b/awt/java/awt/GraphicsConfiguration.java
new file mode 100644
index 0000000..8bec253
--- /dev/null
+++ b/awt/java/awt/GraphicsConfiguration.java
@@ -0,0 +1,217 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
+import java.awt.image.VolatileImage;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The GraphicsConfiguration class contains the characteristics of graphics
+ * devices such as a printer or monitor, and represents device's capabilities
+ * and modes. Many GraphicsConfiguration objects can be associated with
+ * single graphics device.
+ */
+public abstract class GraphicsConfiguration {
+
+ /**
+ * Constructor could not be used directly and should be obtained in
+ * extended classes.
+ */
+
+ protected GraphicsConfiguration() {
+ }
+
+
+ /**
+ * Creates BufferedImage image object with a data layout and color model
+ * compatible with this GraphicsConfiguration with specified width
+ * and height parameters.
+ *
+ * @param width the width of BufferedImage.
+ * @param height the height of BufferedImage.
+ *
+ * @return the BufferedImage object with specified width and height
+ * parameters.
+ */
+ public abstract BufferedImage createCompatibleImage(int width, int height);
+
+ /**
+ * Creates a BufferedImage that has the specified width, height,
+ * transparency and has a data layout and color model compatible with this
+ * GraphicsConfiguration.
+ *
+ * @param width the width of image.
+ * @param height the height of image.
+ * @param transparency the transparency mode.
+ *
+ * @return the BufferedImage object.
+ */
+ public abstract BufferedImage createCompatibleImage(int width, int height, int transparency);
+
+ /**
+ * Creates a VolatileImage that has the specified width and height
+ * and has a data layout and color model compatible with this
+ * GraphicsConfiguration.
+ *
+ * @param width the width of image.
+ * @param height the height of image.
+ *
+ * @return the VolatileImage object.
+ */
+ public abstract VolatileImage createCompatibleVolatileImage(int width, int height);
+
+ /**
+ * Creates a VolatileImage that supports the specified width, height,
+ * transparency and has a data layout and color model compatible with this
+ * GraphicsConfiguration.
+ *
+ * @param width the width of image.
+ * @param height the height of image.
+ * @param transparency the transparency mode.
+ *
+ * @return the VolatileImage object.
+ */
+ public abstract VolatileImage createCompatibleVolatileImage(int width, int height, int transparency);
+
+ /**
+ * Gets the bounds of area covered by the GraphicsConfiguration in the
+ * device coordinates space.
+ *
+ * @return the Rectangle of GraphicsConfiguration's bounds.
+ */
+ public abstract Rectangle getBounds();
+
+ /**
+ * Gets the ColorModel of the GraphicsConfiguration.
+ *
+ * @return the ColorModel object of the GraphicsConfiguration.
+ */
+ public abstract ColorModel getColorModel();
+
+ /**
+ * Gets the ColorModel of the GraphicsConfiguration which
+ * supports specified Transparency.
+ *
+ * @param transparency the Transparency mode: OPAQUE, BITMASK, or
+ * TRANSLUCENT.
+ *
+ * @return the ColorModel of the GraphicsConfiguration which
+ * supports specified Transparency.
+ */
+ public abstract ColorModel getColorModel(int transparency);
+
+ /**
+ * Gets the default AffineTransform of the GraphicsConfiguration.
+ * This method translates user coordinates to device coordinates.
+ *
+ * @return the default AffineTransform of the GraphicsConfiguration.
+ */
+ public abstract AffineTransform getDefaultTransform();
+
+ /**
+ * Gets the GraphicsDevice of the GraphicsConfiguration.
+ *
+ * @return the GraphicsDevice of the GraphicsConfiguration.
+ */
+ public abstract GraphicsDevice getDevice();
+
+ /**
+ * Gets the normalizing AffineTransform of the GraphicsConfiguration.
+ *
+ * @return the normalizing AffineTransform of the GraphicsConfiguration.
+ */
+ public abstract AffineTransform getNormalizingTransform();
+
+
+ /**
+ * Creates VolatileImage with specified width, height, ImageCapabilities;
+ * a data layout and color model compatible with this GraphicsConfiguration.
+ *
+ * @param width the width of image.
+ * @param height the height of image.
+ * @param caps the ImageCapabilities object.
+ *
+ * @return the VolatileImage which data layout and color model compatible
+ * with this GraphicsConfiguration.
+ *
+ * @throws AWTException if ImageCapabilities is not supported by the
+ * GraphicsConfiguration.
+ */
+ public VolatileImage createCompatibleVolatileImage(int width, int height,
+ ImageCapabilities caps) throws AWTException {
+ VolatileImage res = createCompatibleVolatileImage(width, height);
+ if (!res.getCapabilities().equals(caps)) {
+ // awt.14A=Can not create VolatileImage with specified capabilities
+ throw new AWTException(Messages.getString("awt.14A")); //$NON-NLS-1$
+ }
+ return res;
+ }
+
+ /**
+ * Creates a VolatileImage with specified width, height, transparency
+ * and ImageCapabilities; a data layout and color model compatible with
+ * this GraphicsConfiguration.
+ *
+ * @param width the width of image.
+ * @param height the height of image.
+ * @param caps the ImageCapabilities object.
+ * @param transparency the Transparency mode: OPAQUE, BITMASK, or
+ * TRANSLUCENT.
+ *
+ * @return the VolatileImage which data layout and color model compatible
+ * with this GraphicsConfiguration.
+ *
+ * @throws AWTException if ImageCapabilities is not supported by the
+ * GraphicsConfiguration.
+ */
+ public VolatileImage createCompatibleVolatileImage(int width, int height,
+ ImageCapabilities caps, int transparency) throws AWTException {
+ VolatileImage res = createCompatibleVolatileImage(width, height, transparency);
+ if (!res.getCapabilities().equals(caps)) {
+ // awt.14A=Can not create VolatileImage with specified capabilities
+ throw new AWTException(Messages.getString("awt.14A")); //$NON-NLS-1$
+ }
+ return res;
+ }
+
+ /**
+ * Gets the buffering capabilities of the GraphicsConfiguration.
+ *
+ * @return the BufferCapabilities object.
+ */
+ public BufferCapabilities getBufferCapabilities() {
+ return new BufferCapabilities(new ImageCapabilities(false), new ImageCapabilities(false),
+ BufferCapabilities.FlipContents.UNDEFINED);
+ }
+
+ /**
+ * Gets the image capabilities of the GraphicsConfiguration.
+ *
+ * @return the ImageCapabilities object.
+ */
+ public ImageCapabilities getImageCapabilities() {
+ return new ImageCapabilities(false);
+ }
+}
diff --git a/awt/java/awt/GraphicsDevice.java b/awt/java/awt/GraphicsDevice.java
new file mode 100644
index 0000000..8cf700a
--- /dev/null
+++ b/awt/java/awt/GraphicsDevice.java
@@ -0,0 +1,199 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The GraphicsDevice class describes the graphics devices (such as screens
+ * or printers) which are available in a particular graphics environment.
+ * Many GraphicsDevice instances can be associated with a single
+ * GraphicsEnvironment. Each GraphicsDevice has one or more GraphicsConfiguration
+ * objects which specify the different configurations and modes of GraphicsDevice.
+ */
+public abstract class GraphicsDevice {
+
+ /** The display mode. */
+ private DisplayMode displayMode;
+
+ //???AWT
+// private Window fullScreenWindow = null;
+
+ /** The Constant TYPE_IMAGE_BUFFER indicates a image buffer device. */
+
+ public static final int TYPE_IMAGE_BUFFER = 2;
+
+ /** The Constant TYPE_PRINTER indicates a printer device. */
+ public static final int TYPE_PRINTER = 1;
+
+ /** The Constant TYPE_RASTER_SCREEN indicates a raster screen device. */
+ public static final int TYPE_RASTER_SCREEN = 0;
+
+ /**
+ * Constructor is not to be used directly as this class is abstract.
+ */
+ protected GraphicsDevice() {
+ displayMode = new DisplayMode(0, 0, DisplayMode.BIT_DEPTH_MULTI, DisplayMode.REFRESH_RATE_UNKNOWN);
+ }
+
+
+ /**
+ * Returns an array of GraphicsConfiguration objects associated
+ * with the GraphicsDevice.
+ *
+ * @return an array of GraphicsConfiguration objects associated
+ * with the GraphicsDevice.
+ */
+ public abstract GraphicsConfiguration[] getConfigurations();
+
+ /**
+ * Gets the default configuration for the GraphicsDevice.
+ *
+ * @return the default GraphicsConfiguration object for the GraphicsDevice.
+ */
+ public abstract GraphicsConfiguration getDefaultConfiguration();
+
+ /**
+ * Gets the String identifier which associated with the GraphicsDevice in
+ * the GraphicsEnvironment.
+ *
+ * @return the String identifier of the GraphicsDevice in
+ * the GraphicsEnvironment.
+ */
+ public abstract String getIDstring();
+
+ /**
+ * Gets the type of this GraphicsDevice:
+ * TYPE_IMAGE_BUFFER, TYPE_PRINTER or TYPE_RASTER_SCREEN.
+ *
+ * @return the type of this GraphicsDevice: TYPE_IMAGE_BUFFER,
+ * TYPE_PRINTER or TYPE_RASTER_SCREEN.
+ */
+ public abstract int getType();
+
+
+
+ /**
+ * Returns the number of bytes available in accelerated
+ * memory on this device.
+ *
+ * @return the number of bytes available accelerated memory.
+ */
+ public int getAvailableAcceleratedMemory() {
+ return 0;
+ }
+
+ /* ???AWT
+ public GraphicsConfiguration getBestConfiguration(GraphicsConfigTemplate gct) {
+ return gct.getBestConfiguration(getConfigurations());
+ }
+ */
+
+ /**
+ * Gets the current display mode of the GraphicsDevice.
+ *
+ * @return the current display mode of the GraphicsDevice.
+ */
+ public DisplayMode getDisplayMode() {
+ return displayMode;
+ }
+
+ /**
+ * Gets an array of display modes available in this GraphicsDevice.
+ *
+ * @return an array of display modes available in this GraphicsDevice.
+ */
+ public DisplayMode[] getDisplayModes() {
+ DisplayMode []dms = {displayMode};
+ return dms;
+ }
+
+ /* ???AWT
+ public Window getFullScreenWindow() {
+ return fullScreenWindow;
+ }
+ */
+
+ /**
+ * Returns true if this GraphicsDevice supports low-level
+ * display changes.
+ *
+ * @return true, if this GraphicsDevice supports low-level
+ * display changes; false otherwise.
+ */
+ public boolean isDisplayChangeSupported() {
+ return false;
+ }
+
+ /**
+ * Returns true if this GraphicsDevice supports full screen
+ * mode.
+ *
+ * @return true, if this GraphicsDevice supports full screen
+ * mode; otherwise false.
+ */
+ public boolean isFullScreenSupported() {
+ return false;
+ }
+ //an array of display modes available in this GraphicsDevice.
+
+ /**
+ * Sets the display mode of this GraphicsDevice.
+ *
+ * @param dm the new display mode of this GraphicsDevice.
+ */
+ public void setDisplayMode(DisplayMode dm) {
+ if (!isDisplayChangeSupported()) {
+ // awt.122=Does not support display mode changes
+ throw new UnsupportedOperationException(Messages.getString("awt.122")); //$NON-NLS-1$
+ }
+
+ DisplayMode []dms = getDisplayModes();
+ for (DisplayMode element : dms) {
+ if (element.equals(dm)) {
+ displayMode = dm;
+ return;
+ }
+ }
+ // awt.123=Unsupported display mode: {0}
+ throw new IllegalArgumentException(Messages.getString("awt.123", dm)); //$NON-NLS-1$
+ }
+
+ /* ???AWT
+ public void setFullScreenWindow(Window w) {
+ if (w == null) {
+ fullScreenWindow = null;
+ return;
+ }
+
+ fullScreenWindow = w;
+
+ if (isFullScreenSupported()) {
+ w.enableInputMethods(false);
+ } else {
+ w.setSize(displayMode.getWidth(), displayMode.getHeight());
+ w.setLocation(0, 0);
+ }
+ w.setVisible(true);
+ w.setAlwaysOnTop(true);
+ }
+ */
+}
diff --git a/awt/java/awt/GraphicsEnvironment.java b/awt/java/awt/GraphicsEnvironment.java
new file mode 100644
index 0000000..3b14f55
--- /dev/null
+++ b/awt/java/awt/GraphicsEnvironment.java
@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+
+package java.awt;
+
+import java.awt.image.BufferedImage;
+import java.util.Locale;
+
+import org.apache.harmony.awt.ContextStorage;
+import org.apache.harmony.awt.gl.CommonGraphics2DFactory;
+
+/**
+ * The GraphicsEnvironment class defines a collection of GraphicsDevice
+ * objects and Font objects which are available for Java application on
+ * current platform.
+ */
+public abstract class GraphicsEnvironment {
+
+ /**
+ * Constructor could not be used directly and should be obtained in
+ * extended classes.
+ */
+ protected GraphicsEnvironment() {}
+
+ /**
+ * Gets the local GraphicsEnvironment.
+ *
+ * @return the local GraphicsEnvironment.
+ */
+ public static GraphicsEnvironment getLocalGraphicsEnvironment() {
+ synchronized(ContextStorage.getContextLock()) {
+ if (ContextStorage.getGraphicsEnvironment() == null) {
+ if (isHeadless()) {
+ ContextStorage.setGraphicsEnvironment(new HeadlessGraphicsEnvironment());
+ } else {
+ CommonGraphics2DFactory g2df =
+ (CommonGraphics2DFactory) Toolkit.getDefaultToolkit().getGraphicsFactory();
+
+ ContextStorage.setGraphicsEnvironment(
+ g2df.createGraphicsEnvironment(ContextStorage.getWindowFactory())
+ );
+ }
+ }
+
+ return ContextStorage.getGraphicsEnvironment();
+ }
+ }
+
+ /**
+ * Returns whether or not a display, keyboard, and mouse are supported
+ * in this graphics environment.
+ *
+ * @return true, if HeadlessException will be thrown from areas of
+ * the graphics environment that are dependent on a display, keyboard,
+ * or mouse; false otherwise.
+ */
+ public boolean isHeadlessInstance() {
+ return false;
+ }
+
+ /**
+ * Checks whether or not a display, keyboard, and mouse are supported
+ * in this environment.
+ *
+ * @return true, if a HeadlessException is thrown from areas of
+ * the Toolkit and GraphicsEnvironment that are dependent on
+ * a display, keyboard, or mouse; false otherwise.
+ */
+ public static boolean isHeadless() {
+ return "true".equals(System.getProperty("java.awt.headless"));
+ }
+
+ /**
+ * Gets the maximum bounds of system centered windows.
+ *
+ * @return the maximum bounds of system centered windows.
+ *
+ * @throws HeadlessException if isHeadless() method returns true.
+ */
+ public Rectangle getMaximumWindowBounds() throws HeadlessException {
+ return getDefaultScreenDevice().getDefaultConfiguration().getBounds();
+ }
+
+ /**
+ * Gets the Point which should defines the center of system window.
+ *
+ * @return the Point where the system window should be centered.
+ *
+ * @throws HeadlessException if isHeadless() method returns true.
+ */
+ public Point getCenterPoint() throws HeadlessException {
+ Rectangle mwb = getMaximumWindowBounds();
+ return new Point(mwb.width >> 1, mwb.height >> 1);
+ }
+
+ /**
+ * Indicates that the primary font should be used.
+ * Primary font is specified by initial system locale or default encoding).
+ *
+ */
+ public void preferLocaleFonts() {
+ // Note: API specification says following:
+ // "The actual change in font rendering behavior resulting
+ // from a call to this method is implementation dependent;
+ // it may have no effect at all." So, doing nothing is an
+ // acceptable behavior for this method.
+
+ // For now FontManager uses 1.4 font.properties scheme for font mapping, so
+ // this method doesn't make any sense. The implementation of this method
+ // which will influence font mapping is postponed until
+ // 1.5 mapping scheme not implemented.
+
+ // todo - Implement non-default behavior with 1.5 font mapping scheme
+ }
+
+ /**
+ * Indicates that a proportional preference of the font should be used.
+ */
+ public void preferProportionalFonts() {
+ // Note: API specification says following:
+ // "The actual change in font rendering behavior resulting
+ // from a call to this method is implementation dependent;
+ // it may have no effect at all." So, doing nothing is an
+ // acceptable behavior for this method.
+
+ // For now FontManager uses 1.4 font.properties scheme for font mapping, so
+ // this method doesn't make any sense. The implementation of this method
+ // which will influence font mapping is postponed until
+ // 1.5 mapping scheme not implemented.
+
+ // todo - Implement non-default behavior with 1.5 font mapping scheme
+ }
+
+ /**
+ * Creates the Graphics2D object for rendering to the specified
+ * BufferedImage.
+ *
+ * @param bufferedImage the BufferedImage object.
+ *
+ * @return the Graphics2D object which allows to render to the specified
+ * BufferedImage.
+ */
+ public abstract Graphics2D createGraphics(BufferedImage bufferedImage);
+
+ /**
+ * Gets the array of all available fonts instances in this
+ * GraphicsEnviroments.
+ *
+ * @return the array of all available fonts instances in this
+ * GraphicsEnviroments.
+ */
+ public abstract Font[] getAllFonts();
+
+ /**
+ * Gets the array of all available font family names.
+ *
+ * @return the array of all available font family names.
+ */
+ public abstract String[] getAvailableFontFamilyNames();
+
+ /**
+ * Gets the array of all available font family names for the specified
+ * locale.
+ *
+ * @param locale the Locale object which represents geographical
+ * region. The default locale is used if locale is null.
+ *
+ * @return the array of available font family names for the specified
+ * locale.
+ */
+ public abstract String[] getAvailableFontFamilyNames(Locale locale);
+
+ /**
+ * Gets the default screen device as GraphicDevice object.
+ *
+ * @return the GraphicDevice object which represents default screen device.
+ *
+ * @throws HeadlessException if isHeadless() returns true.
+ */
+ public abstract GraphicsDevice getDefaultScreenDevice() throws HeadlessException;
+
+ /**
+ * Gets an array of all available screen devices.
+ *
+ * @return the array of GraphicsDevice obgects which represents
+ * all available screen devices.
+ *
+ * @throws HeadlessException if isHeadless() returns true.
+ */
+ public abstract GraphicsDevice[] getScreenDevices() throws HeadlessException;
+}
diff --git a/awt/java/awt/HeadlessException.java b/awt/java/awt/HeadlessException.java
new file mode 100644
index 0000000..28e463b
--- /dev/null
+++ b/awt/java/awt/HeadlessException.java
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ * The HeadlessException class provides notifications and error messages
+ * when code that is dependent on a keyboard, display, or mouse is called
+ * in an environment that does not support a keyboard, display, or mouse.
+ */
+public class HeadlessException extends UnsupportedOperationException {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 167183644944358563L;
+
+ /**
+ * Instantiates a new headless exception.
+ */
+ public HeadlessException() {
+ super();
+ }
+
+ /**
+ * Instantiates a new headless exception with the specified message.
+ *
+ * @param msg the String which represents error message.
+ */
+ public HeadlessException(String msg) {
+ super(msg);
+ }
+}
diff --git a/awt/java/awt/HeadlessGraphicsEnvironment.java b/awt/java/awt/HeadlessGraphicsEnvironment.java
new file mode 100644
index 0000000..97f88d1
--- /dev/null
+++ b/awt/java/awt/HeadlessGraphicsEnvironment.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+import java.awt.GraphicsDevice;
+import java.awt.HeadlessException;
+
+import org.apache.harmony.awt.gl.CommonGraphicsEnvironment;
+
+/**
+ * The HeadlessGraphicsEnvironment class is the CommonGraphicsEnvironment
+ * implementation to use in the case where the environment lacks display,
+ * keyboard, and mouse support.
+ */
+public class HeadlessGraphicsEnvironment extends CommonGraphicsEnvironment {
+
+ /**
+ * Returns whether or not a display, keyboard, and mouse are supported
+ * in this graphics environment.
+ *
+ * @return true, if HeadlessException will be thrown from areas of
+ * the graphics environment that are dependent on a display, keyboard,
+ * or mouse; false otherwise.
+ */
+ @Override
+ public boolean isHeadlessInstance() {
+ return true;
+ }
+
+ /**
+ * Gets the default screen device as GraphicDevice object.
+ *
+ * @return the GraphicDevice object which represents default screen device.
+ *
+ * @throws HeadlessException if isHeadless() returns true.
+ */
+ @Override
+ public GraphicsDevice getDefaultScreenDevice() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ /**
+ * Gets an array of all available screen devices.
+ *
+ * @return the array of GraphicsDevice objects which represents
+ * all available screen devices.
+ *
+ * @throws HeadlessException if isHeadless() returns true.
+ */
+ @Override
+ public GraphicsDevice[] getScreenDevices() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+}
diff --git a/awt/java/awt/HeadlessToolkit.java b/awt/java/awt/HeadlessToolkit.java
new file mode 100644
index 0000000..a7dd557
--- /dev/null
+++ b/awt/java/awt/HeadlessToolkit.java
@@ -0,0 +1,301 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+//???AWT
+//import java.awt.datatransfer.Clipboard;
+//import java.awt.dnd.DragGestureEvent;
+//import java.awt.dnd.DragGestureListener;
+//import java.awt.dnd.DragGestureRecognizer;
+//import java.awt.dnd.DragSource;
+//import java.awt.dnd.InvalidDnDOperationException;
+//import java.awt.dnd.peer.DragSourceContextPeer;
+import java.awt.im.InputMethodHighlight;
+import java.awt.image.ColorModel;
+//import java.awt.peer.*;
+//import java.beans.PropertyChangeSupport;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import org.apache.harmony.awt.ComponentInternals;
+//import org.apache.harmony.awt.datatransfer.DTK;
+import org.apache.harmony.awt.wtk.GraphicsFactory;
+import org.apache.harmony.awt.wtk.NativeEventQueue;
+import org.apache.harmony.awt.wtk.WindowFactory;
+
+/**
+ * The HeadlessToolkit class is a subclass of ToolkitImpl to
+ * be used for graphical environments that lack keyboard and
+ * mouse capabilities.
+ */
+public final class HeadlessToolkit extends ToolkitImpl {
+
+ //???AWT
+ /*
+ @Override
+ protected ButtonPeer createButton(Button a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected CheckboxPeer createCheckbox(Checkbox a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected ChoicePeer createChoice(Choice a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ public Cursor createCustomCursor(Image img, Point hotSpot, String name)
+ throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected DialogPeer createDialog(Dialog a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public <T extends DragGestureRecognizer> T createDragGestureRecognizer(
+ Class<T> recognizerAbstractClass, DragSource ds, Component c, int srcActions,
+ DragGestureListener dgl) {
+ return null;
+ }
+
+ @Override
+ public DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge)
+ throws InvalidDnDOperationException {
+ throw new InvalidDnDOperationException();
+ }
+
+ @Override
+ protected FileDialogPeer createFileDialog(FileDialog a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected FramePeer createFrame(Frame a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected LabelPeer createLabel(Label a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected ListPeer createList(List a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected MenuPeer createMenu(Menu a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected MenuBarPeer createMenuBar(MenuBar a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected MenuItemPeer createMenuItem(MenuItem a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected PopupMenuPeer createPopupMenu(PopupMenu a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected ScrollbarPeer createScrollbar(Scrollbar a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected ScrollPanePeer createScrollPane(ScrollPane a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected TextAreaPeer createTextArea(TextArea a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected TextFieldPeer createTextField(TextField a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected WindowPeer createWindow(Window a0) throws HeadlessException {
+ throw new HeadlessException();
+ }
+ */
+
+ @Override
+ public Dimension getBestCursorSize(int prefWidth, int prefHeight) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public ColorModel getColorModel() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public GraphicsFactory getGraphicsFactory() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public boolean getLockingKeyState(int keyCode) throws UnsupportedOperationException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public int getMaximumCursorColors() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public int getMenuShortcutKeyMask() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ //???AWT
+ /*
+ @Override
+ NativeEventQueue getNativeEventQueue() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public PrintJob getPrintJob(Frame frame, String jobtitle, JobAttributes jobAttributes,
+ PageAttributes pageAttributes) throws IllegalArgumentException {
+ throw new IllegalArgumentException();
+ }
+
+ @Override
+ public PrintJob getPrintJob(Frame frame, String jobtitle, Properties props) throws NullPointerException {
+ throw new NullPointerException();
+ }
+ */
+
+ @Override
+ public Insets getScreenInsets(GraphicsConfiguration gc) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public int getScreenResolution() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public Dimension getScreenSize() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ //???AWT
+ /*
+ @Override
+ public Clipboard getSystemClipboard() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public Clipboard getSystemSelection() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ WindowFactory getWindowFactory() throws HeadlessException {
+ throw new HeadlessException();
+ }
+ */
+
+ @Override
+ protected void init() {
+ lockAWT();
+ try {
+ ComponentInternals.setComponentInternals(new ComponentInternalsImpl());
+ //???AWT: new EventQueue(this); // create the system EventQueue
+ //???AWT: dispatcher = new Dispatcher(this);
+ desktopProperties = new HashMap<String, Object>();
+ //???AWT: desktopPropsSupport = new PropertyChangeSupport(this);
+// ???AWT: awtEventsManager = new AWTEventsManager();
+// ???AWT: dispatchThread = new HeadlessEventDispatchThread(this, dispatcher);
+// ???AWT: dtk = DTK.getDTK();
+ dispatchThread.start();
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public boolean isDynamicLayoutActive() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected boolean isDynamicLayoutSet() throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public boolean isFrameStateSupported(int state) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ protected void loadSystemColors(int[] systemColors) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public Map<java.awt.font.TextAttribute, ?> mapInputMethodHighlight(
+ InputMethodHighlight highlight) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ Map<java.awt.font.TextAttribute, ?> mapInputMethodHighlightImpl(
+ InputMethodHighlight highlight) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public void setDynamicLayout(boolean dynamic) throws HeadlessException {
+ throw new HeadlessException();
+ }
+
+ @Override
+ public void setLockingKeyState(int keyCode, boolean on) throws UnsupportedOperationException {
+ throw new HeadlessException();
+ }
+}
diff --git a/awt/java/awt/IllegalComponentStateException.java b/awt/java/awt/IllegalComponentStateException.java
new file mode 100644
index 0000000..21dc35f
--- /dev/null
+++ b/awt/java/awt/IllegalComponentStateException.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ * The IllegalComponentStateException class is used to provide
+ * notification that AWT component is not in an appropriate state
+ * for the requested operation.
+ */
+public class IllegalComponentStateException extends IllegalStateException {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -1889339587208144238L;
+
+ /**
+ * Instantiates a new IllegalComponentStateException with
+ * the specified message.
+ *
+ * @param s the String message which describes the exception.
+ */
+ public IllegalComponentStateException(String s) {
+ super(s);
+ }
+
+ /**
+ * Instantiates a new IllegalComponentStateException without
+ * detailed message.
+ */
+ public IllegalComponentStateException() {
+ }
+
+}
+
diff --git a/awt/java/awt/Image.java b/awt/java/awt/Image.java
new file mode 100644
index 0000000..c217e38
--- /dev/null
+++ b/awt/java/awt/Image.java
@@ -0,0 +1,203 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.image.AreaAveragingScaleFilter;
+import java.awt.image.FilteredImageSource;
+import java.awt.image.ImageFilter;
+import java.awt.image.ImageObserver;
+import java.awt.image.ImageProducer;
+import java.awt.image.ReplicateScaleFilter;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Image abstract class represents the graphic images.
+ */
+public abstract class Image {
+
+ /**
+ * The UndefinedProperty object should be returned if
+ * property is not defined for a particular image.
+ */
+ public static final Object UndefinedProperty = new Object(); //$NON-LOCK-1$
+
+ /**
+ * The Constant SCALE_DEFAULT indicates the default image
+ * scaling algorithm.
+ */
+ public static final int SCALE_DEFAULT = 1;
+
+ /**
+ * The Constant SCALE_FAST indicates an image scaling algorithm which
+ * places a higher priority on scaling speed than on the image's smoothness.
+ */
+ public static final int SCALE_FAST = 2;
+
+ /**
+ * The Constant SCALE_SMOOTH indicates an image scaling algorithm which
+ * places a higher priority on image smoothness than on scaling speed.
+ */
+ public static final int SCALE_SMOOTH = 4;
+
+ /**
+ * The Constant SCALE_REPLICATE indicates the image scaling
+ * algorithm in the ReplicateScaleFilter class.
+ */
+ public static final int SCALE_REPLICATE = 8;
+
+ /**
+ * The Constant SCALE_AREA_AVERAGING indicates
+ * the area averaging image scaling algorithm.
+ */
+ public static final int SCALE_AREA_AVERAGING = 16;
+
+ /**
+ * The acceleration priority indicates image acceleration.
+ */
+ protected float accelerationPriority = 0.5f;
+
+ /** The Constant capabilities. */
+ private static final ImageCapabilities capabilities = new ImageCapabilities(false);
+
+ /**
+ * Gets the image property with the specified name.
+ * The UndefinedProperty object should be return if the property is
+ * not specified for this image. The return value should be null if the
+ * property is currently unknown yet and the specified ImageObserver is
+ * to be notified later.
+ *
+ * @param name the name of image's property.
+ * @param observer the ImageObserver.
+ *
+ * @return the Object which represents value of the specified property.
+ */
+ public abstract Object getProperty(String name, ImageObserver observer);
+
+ /**
+ * Gets the ImageProducer object which represents data of this Image.
+ *
+ * @return the ImageProducer object which represents data of this Image.
+ */
+ public abstract ImageProducer getSource();
+
+ /**
+ * Gets the width of this image. The specified ImageObserver object
+ * is notified when the width of this image is available.
+ *
+ * @param observer the ImageObserver object which is
+ * is notified when the width of this image is available.
+ *
+ * @return the width of image, or -1 if the width of this image
+ * is not available.
+ */
+ public abstract int getWidth(ImageObserver observer);
+
+ /**
+ * Gets the height of this image. The specified ImageObserver object
+ * is notified when the height of this image is available.
+ *
+ * @param observer the ImageObserver object which is
+ * is notified when the height of this image is available.
+ *
+ * @return the height of image, or -1 if the height of this image
+ * is not available.
+ */
+ public abstract int getHeight(ImageObserver observer);
+
+ /**
+ * Gets the scaled instance of this Image. This method returns
+ * an Image object constructed from the source of this image
+ * with the specified width, height, and applied scaling
+ * alghorithm.
+ *
+ * @param width the width of scaled Image.
+ * @param height the height of scaled Image.
+ * @param hints the constant which indicates scaling algorithm.
+ *
+ * @return the scaled Image.
+ */
+ public Image getScaledInstance(int width, int height, int hints) {
+ ImageFilter filter;
+ if ((hints & (SCALE_SMOOTH | SCALE_AREA_AVERAGING)) != 0) {
+ filter = new AreaAveragingScaleFilter(width, height);
+ } else {
+ filter = new ReplicateScaleFilter(width, height);
+ }
+ ImageProducer producer = new FilteredImageSource(getSource(), filter);
+ return Toolkit.getDefaultToolkit().createImage(producer);
+ }
+
+ /**
+ * Gets a Graphics object for rendering this image.
+ * This method can be used for off-screen images.
+ *
+ * @return a Graphics object for rendering to this image.
+ */
+ public abstract Graphics getGraphics();
+
+ /**
+ * Flushes resources which are used by this Image object.
+ * This method resets the image to the reconstructered state
+ * from the image's source.
+ */
+ public abstract void flush();
+
+ /**
+ * Gets the acceleration priority of this image.
+ *
+ * @return the acceleration priority of this image.
+ */
+ public float getAccelerationPriority() {
+ return accelerationPriority;
+ }
+
+ /**
+ * Sets the acceleration priority for this image.
+ *
+ * @param priority the new acceleration priority (value in the
+ * range 0-1).
+ */
+ public void setAccelerationPriority(float priority) {
+ if (priority < 0 || priority > 1) {
+ // awt.10A=Priority must be a value between 0 and 1, inclusive
+ throw new IllegalArgumentException(Messages.getString("awt.10A")); //$NON-NLS-1$
+ }
+ accelerationPriority = priority;
+ }
+
+ /**
+ * Gets an ImageCapabilities object of this Image object
+ * for the specified GraphicsConfiguration.
+ *
+ * @param gc the specified GraphicsConfiguration object
+ * (null value means default GraphicsConfiguration).
+ *
+ * @return an ImageCapabilities object of this Image object
+ * for the specified GraphicsConfiguration.
+ */
+ public ImageCapabilities getCapabilities(GraphicsConfiguration gc) {
+ // Note: common image is not accelerated.
+ return capabilities;
+ }
+}
+
+
diff --git a/awt/java/awt/ImageCapabilities.java b/awt/java/awt/ImageCapabilities.java
new file mode 100644
index 0000000..6e9ecfc
--- /dev/null
+++ b/awt/java/awt/ImageCapabilities.java
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ * The ImageCapabilities class gives information about an image's capabilities.
+ */
+public class ImageCapabilities implements Cloneable {
+
+ /** The accelerated. */
+ private final boolean accelerated;
+
+ /**
+ * Instantiates a new ImageCapabilities with the specified
+ * acceleration flag which indicates whether acceleration
+ * is desired or not.
+ *
+ * @param accelerated the accelerated flag.
+ */
+ public ImageCapabilities(boolean accelerated) {
+ this.accelerated = accelerated;
+ }
+
+ /**
+ * Returns a copy of this ImageCapabilities object.
+ *
+ * @return the copy of this ImageCapabilities object.
+ */
+ @Override
+ public Object clone() {
+ return new ImageCapabilities(accelerated);
+ }
+
+ /**
+ * Returne true if the Image of this ImageCapabilities is or can be
+ * accelerated.
+ *
+ * @return true, if the Image of this ImageCapabilities is or can be
+ * accelerated, false otherwise.
+ */
+ public boolean isAccelerated() {
+ return accelerated;
+ }
+
+ /**
+ * Returns true if this ImageCapabilities applies to
+ * the VolatileImage which can lose its surfaces.
+ *
+ * @return true if this ImageCapabilities applies to
+ * the VolatileImage which can lose its surfaces,
+ * false otherwise.
+ */
+ public boolean isTrueVolatile() {
+ return true;
+ }
+}
diff --git a/awt/java/awt/Insets.java b/awt/java/awt/Insets.java
new file mode 100644
index 0000000..61f3fd8
--- /dev/null
+++ b/awt/java/awt/Insets.java
@@ -0,0 +1,165 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Dmitry A. Durnev
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.io.Serializable;
+
+import org.apache.harmony.misc.HashCode;
+
+
+/**
+ * The Insets class represents the borders of a container.
+ * This class describes the space that a container should leave at each edge:
+ * the top, the bottom, the right side, and the left side.
+ * The space can be filled with a border, a blank space, or a title.
+ */
+public class Insets implements Cloneable, Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -2272572637695466749L;
+
+ /**
+ * The top inset indicates the size of the space added to the
+ * top of the rectangle.
+ */
+ public int top;
+
+ /**
+ * The left inset indicates the size of the space added to the
+ * left side of the rectangle.
+ */
+ public int left;
+
+ /**
+ * The bottom inset indicates the size of the space subtracted from
+ * the bottom of the rectangle.
+ */
+ public int bottom;
+
+ /** The right inset indicates the size of the space subtracted from
+ * the right side of the rectangle.
+ */
+ public int right;
+
+ /**
+ * Instantiates a new Inset object with the specified top, left, bottom,
+ * right parameters.
+ *
+ * @param top the top inset.
+ * @param left the left inset.
+ * @param bottom the bottom inset.
+ * @param right the right inset.
+ */
+ public Insets(int top, int left, int bottom, int right) {
+ setValues(top, left, bottom, right);
+ }
+
+ /**
+ * Returns a hash code of the Insets object.
+ *
+ * @return a hash code of the Insets object.
+ */
+ @Override
+ public int hashCode() {
+ int hashCode = HashCode.EMPTY_HASH_CODE;
+ hashCode = HashCode.combine(hashCode, top);
+ hashCode = HashCode.combine(hashCode, left);
+ hashCode = HashCode.combine(hashCode, bottom);
+ hashCode = HashCode.combine(hashCode, right);
+ return hashCode;
+ }
+
+ /**
+ * Returns a copy of this Insets object.
+ *
+ * @return a copy of this Insets object.
+ */
+ @Override
+ public Object clone() {
+ return new Insets(top, left, bottom, right);
+ }
+
+ /**
+ * Checks if this Insets object is equal to the specified object.
+ *
+ * @param o the Object to be compared.
+ *
+ * @return true, if the object is an Insets object whose data values
+ * are equal to those of this object, false otherwise.
+ */
+ @Override
+ public boolean equals(Object o) {
+ if (o == this) {
+ return true;
+ }
+ if (o instanceof Insets) {
+ Insets i = (Insets) o;
+ return ((i.left == left) && (i.bottom == bottom) &&
+ (i.right == right) && (i.top == top));
+ }
+ return false;
+ }
+
+ /**
+ * Returns a String representation of this Insets object.
+ *
+ * @return a String representation of this Insets object.
+ */
+ @Override
+ public String toString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ * System.out.println(new Insets(1, 2, 3, 4));
+ */
+
+ return (getClass().getName() +
+ "[left=" + left + ",top=" + top + //$NON-NLS-1$ //$NON-NLS-2$
+ ",right=" + right + ",bottom=" + bottom + "]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+ /**
+ * Sets top, left, bottom, and right insets to the specified values.
+ *
+ * @param top the top inset.
+ * @param left the left inset.
+ * @param bottom the bottom inset.
+ * @param right the right inset.
+ */
+ public void set(int top, int left, int bottom, int right) {
+ setValues(top, left, bottom, right);
+ }
+
+ /**
+ * Sets the values.
+ *
+ * @param top the top
+ * @param left the left
+ * @param bottom the bottom
+ * @param right the right
+ */
+ private void setValues(int top, int left, int bottom, int right) {
+ this.top = top;
+ this.left = left;
+ this.bottom = bottom;
+ this.right = right;
+ }
+}
+
diff --git a/awt/java/awt/ItemSelectable.java b/awt/java/awt/ItemSelectable.java
new file mode 100644
index 0000000..a46364b
--- /dev/null
+++ b/awt/java/awt/ItemSelectable.java
@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.event.ItemListener;
+
+/**
+ * The ItemSelectable interface represents a set of items which can be selected.
+ */
+public interface ItemSelectable {
+
+ /**
+ * Adds an ItemListener for receiving item events when the state of an item
+ * is changed by the user.
+ *
+ * @param l the ItemListener.
+ */
+ public void addItemListener(ItemListener l);
+
+ /**
+ * Gets an array of the selected objects or null if there is no selected object.
+ *
+ * @return an array of the selected objects or null if there is no selected
+ * object.
+ */
+ public Object[] getSelectedObjects();
+
+ /**
+ * Removes the specified ItemListener.
+ *
+ * @param l the ItemListener which will be removed.
+ */
+ public void removeItemListener(ItemListener l);
+
+}
diff --git a/awt/java/awt/MenuComponent.java b/awt/java/awt/MenuComponent.java
new file mode 100644
index 0000000..9eb4f3d
--- /dev/null
+++ b/awt/java/awt/MenuComponent.java
@@ -0,0 +1,1041 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+import java.awt.event.FocusListener;
+import java.awt.event.MouseEvent;
+import java.awt.peer.MenuComponentPeer;
+import java.io.Serializable;
+import java.util.Locale;
+//import javax.accessibility.Accessible;
+//import javax.accessibility.AccessibleComponent;
+//import javax.accessibility.AccessibleContext;
+//import javax.accessibility.AccessibleRole;
+//import javax.accessibility.AccessibleSelection;
+//import javax.accessibility.AccessibleStateSet;
+import org.apache.harmony.awt.gl.MultiRectArea;
+import org.apache.harmony.awt.state.MenuItemState;
+import org.apache.harmony.awt.state.MenuState;
+
+/**
+ * The MenuComponent abstract class is the superclass for menu
+ * components. Menu components receive and process AWT events.
+ */
+public abstract class MenuComponent implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -4536902356223894379L;
+
+ /** The name. */
+ private String name;
+
+ /** The font. */
+ private Font font;
+
+ /** The parent. */
+ MenuContainer parent;
+
+ /** The deprecated event handler. */
+ boolean deprecatedEventHandler = true;
+
+ /** The selected item index. */
+ private int selectedItemIndex;
+
+ //???AWT: private AccessibleContext accessibleContext;
+
+ /** The toolkit. */
+ final Toolkit toolkit = Toolkit.getDefaultToolkit();
+
+ //???AWT
+ /*
+ protected abstract class AccessibleAWTMenuComponent extends AccessibleContext implements
+ Serializable, AccessibleComponent, AccessibleSelection {
+ private static final long serialVersionUID = -4269533416223798698L;
+
+ public void addFocusListener(FocusListener listener) {
+ }
+
+ public boolean contains(Point pt) {
+ return false;
+ }
+
+ public Accessible getAccessibleAt(Point pt) {
+ return null;
+ }
+
+ public Color getBackground() {
+ return null;
+ }
+
+ public Rectangle getBounds() {
+ return null;
+ }
+
+ public Cursor getCursor() {
+ return null;
+ }
+
+ public Font getFont() {
+ return MenuComponent.this.getFont();
+ }
+
+ public FontMetrics getFontMetrics(Font font) {
+ return null;
+ }
+
+ public Color getForeground() {
+ return null;
+ }
+
+ public Point getLocation() {
+ return null;
+ }
+
+ public Point getLocationOnScreen() {
+ return null;
+ }
+
+ public Dimension getSize() {
+ return null;
+ }
+
+ public boolean isEnabled() {
+ return true; // always enabled
+ }
+
+ public boolean isFocusTraversable() {
+ return true; // always focus traversable
+ }
+
+ public boolean isShowing() {
+ return true;// always showing
+ }
+
+ public boolean isVisible() {
+ return true; // always visible
+ }
+
+ public void removeFocusListener(FocusListener listener) {
+ }
+
+ public void requestFocus() {
+ }
+
+ public void setBackground(Color color) {
+ }
+
+ public void setBounds(Rectangle rect) {
+ }
+
+ public void setCursor(Cursor cursor) {
+ }
+
+ public void setEnabled(boolean enabled) {
+ }
+
+ public void setFont(Font font) {
+ MenuComponent.this.setFont(font);
+ }
+
+ public void setForeground(Color color) {
+ }
+
+ public void setLocation(Point pt) {
+ }
+
+ public void setSize(Dimension pt) {
+ }
+
+ public void setVisible(boolean visible) {
+ }
+
+ public void addAccessibleSelection(int index) {
+ }
+
+ public void clearAccessibleSelection() {
+ }
+
+ public Accessible getAccessibleSelection(int index) {
+ return null;
+ }
+
+ public int getAccessibleSelectionCount() {
+ return 0;
+ }
+
+ public boolean isAccessibleChildSelected(int index) {
+ return false;
+ }
+
+ public void removeAccessibleSelection(int index) {
+ }
+
+ public void selectAllAccessibleSelection() {
+ }
+
+ @Override
+ public Accessible getAccessibleChild(int index) {
+ return null;
+ }
+
+ @Override
+ public int getAccessibleChildrenCount() {
+ return 0;
+ }
+
+ @Override
+ public AccessibleComponent getAccessibleComponent() {
+ return this;
+ }
+
+ @Override
+ public String getAccessibleDescription() {
+ return super.getAccessibleDescription();
+ }
+
+ @Override
+ public int getAccessibleIndexInParent() {
+ toolkit.lockAWT();
+ try {
+ Accessible aParent = getAccessibleParent();
+ int aIndex = -1;
+ if (aParent instanceof MenuComponent) {
+ MenuComponent parent = (MenuComponent) aParent;
+ int count = parent.getItemCount();
+ for (int i = 0; i < count; i++) {
+ MenuComponent comp = parent.getItem(i);
+ if (comp instanceof Accessible) {
+ aIndex++;
+ if (comp == MenuComponent.this) {
+ return aIndex;
+ }
+ }
+ }
+ }
+ return -1;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Override
+ public String getAccessibleName() {
+ return super.getAccessibleName();
+ }
+
+ @Override
+ public Accessible getAccessibleParent() {
+ toolkit.lockAWT();
+ try {
+ Accessible aParent = super.getAccessibleParent();
+ if (aParent != null) {
+ return aParent;
+ }
+ MenuContainer parent = getParent();
+ if (parent instanceof Accessible) {
+ aParent = (Accessible) parent;
+ }
+ return aParent;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ @Override
+ public AccessibleRole getAccessibleRole() {
+ return AccessibleRole.AWT_COMPONENT;
+ }
+
+ @Override
+ public AccessibleSelection getAccessibleSelection() {
+ return this;
+ }
+
+ @Override
+ public AccessibleStateSet getAccessibleStateSet() {
+ return new AccessibleStateSet();
+ }
+
+ @Override
+ public Locale getLocale() {
+ return Locale.getDefault();
+ }
+ }
+ */
+
+ /**
+ * The accessor to MenuComponent internal state,
+ * utilized by the visual theme.
+ *
+ * @throws HeadlessException the headless exception
+ */
+ //???AWT
+ /*
+ class State implements MenuState {
+ Dimension size;
+
+ Dimension getSize() {
+ if (size == null) {
+ calculate();
+ }
+ return size;
+ }
+
+ public int getWidth() {
+ return getSize().width;
+ }
+
+ public int getHeight() {
+ return getSize().height;
+ }
+
+ public Font getFont() {
+ return MenuComponent.this.getFont();
+ }
+
+ public int getItemCount() {
+ return MenuComponent.this.getItemCount();
+ }
+
+ public int getSelectedItemIndex() {
+ return MenuComponent.this.getSelectedItemIndex();
+ }
+
+ public boolean isFontSet() {
+ return MenuComponent.this.isFontSet();
+ }
+
+ @SuppressWarnings("deprecation")
+ public FontMetrics getFontMetrics(Font f) {
+ return MenuComponent.this.toolkit.getFontMetrics(f);
+ }
+
+ public Point getLocation() {
+ return MenuComponent.this.getLocation();
+ }
+
+ public MenuItemState getItem(int index) {
+ MenuItem item = MenuComponent.this.getItem(index);
+ return item.itemState;
+ }
+
+ public void setSize(int w, int h) {
+ this.size = new Dimension(w, h);
+ }
+
+ void calculate() {
+ size = new Dimension();
+ size.setSize(toolkit.theme.calculateMenuSize(this));
+ }
+
+ void reset() {
+ for (int i = 0; i < getItemCount(); i++) {
+ ((MenuItem.State) getItem(i)).reset();
+ }
+ }
+
+ }
+ */
+
+ /**
+ * Pop-up box for menu. It transfers the paint events,
+ * keyboard and mouse events to the menu component itself
+ */
+ //???AWT
+ /*
+ class MenuPopupBox extends PopupBox {
+ private final Point lastMousePos = new Point();
+
+ @Override
+ boolean isMenu() {
+ return true;
+ }
+
+ @Override
+ void paint(Graphics gr) {
+ MenuComponent.this.paint(gr);
+ }
+
+ @Override
+ void onKeyEvent(int eventId, int vKey, long when, int modifiers) {
+ MenuComponent.this.onKeyEvent(eventId, vKey, when, modifiers);
+ }
+
+ @Override
+ void onMouseEvent(int eventId, Point where, int mouseButton, long when, int modifiers,
+ int wheelRotation) {
+ // prevent conflict of mouse and keyboard
+ // when sub-menu drops down due to keyboard navigation
+ if (lastMousePos.equals(where)
+ && (eventId == MouseEvent.MOUSE_MOVED || eventId == MouseEvent.MOUSE_ENTERED)) {
+ return;
+ }
+ lastMousePos.setLocation(where);
+ MenuComponent.this.onMouseEvent(eventId, where, mouseButton, when, modifiers);
+ }
+ }
+ */
+
+ /**
+ * Instantiates a new MenuComponent object.
+ *
+ * @throws HeadlessException if the graphical interface
+ * environment can't support MenuComponents
+ */
+ public MenuComponent() throws HeadlessException {
+ toolkit.lockAWT();
+ try {
+ Toolkit.checkHeadless();
+ name = autoName();
+ selectedItemIndex = -1;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the name of the MenuComponent object.
+ *
+ * @return the name of the MenuComponent object.
+ */
+ public String getName() {
+ toolkit.lockAWT();
+ try {
+ return name;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Returns a String representation of the MenuComponent object.
+ *
+ * @return a String representation of the MenuComponent object.
+ */
+ @Override
+ public String toString() {
+ toolkit.lockAWT();
+ try {
+ return getClass().getName() + "[" + paramString() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the Parent menu Container .
+ *
+ * @return the parent
+ */
+ public MenuContainer getParent() {
+ toolkit.lockAWT();
+ try {
+ return parent;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the name of the MenuComponent to the specified string.
+ *
+ * @param name the new name of the MenuComponent object.
+ */
+ public void setName(String name) {
+ toolkit.lockAWT();
+ try {
+ this.name = name;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Dispatches AWT event.
+ *
+ * @param event the AWTEvent.
+ */
+ public final void dispatchEvent(AWTEvent event) {
+ toolkit.lockAWT();
+ try {
+ processEvent(event);
+ if (deprecatedEventHandler) {
+ postDeprecatedEvent(event);
+ }
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Post deprecated event.
+ *
+ * @param event the event
+ */
+ void postDeprecatedEvent(AWTEvent event) {
+ Event evt = event.getEvent();
+ if (evt != null) {
+ postEvent(evt);
+ }
+ }
+
+ /**
+ * Gets the peer of the MenuComponent; an application must not
+ * use this method directly.
+ *
+ * @return the MenuComponentPeer object.
+ *
+ * @deprecated an application must not use this method directly.
+ */
+ @Deprecated
+ public MenuComponentPeer getPeer() throws org.apache.harmony.luni.util.NotImplementedException {
+ toolkit.lockAWT();
+ try {
+ } finally {
+ toolkit.unlockAWT();
+ }
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //TODO: implement //$NON-NLS-1$
+ }
+ return null;
+ }
+
+ /**
+ * Gets the locking object of this MenuComponent.
+ *
+ * @return the locking object of this MenuComponent.
+ */
+ protected final Object getTreeLock() {
+ return toolkit.awtTreeLock;
+ }
+
+ /**
+ * Posts the Event to the MenuComponent.
+ *
+ * @param e the Event.
+ *
+ * @return true, if the event is posted successfully;
+ * false otherwise.
+ *
+ * @deprecated Replaced dispatchEvent method.
+ */
+ @SuppressWarnings("deprecation")
+ @Deprecated
+ public boolean postEvent(Event e) {
+ toolkit.lockAWT();
+ try {
+ if (parent != null) {
+ return parent.postEvent(e);
+ }
+ return false;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Returns the string representation of the MenuComponent state.
+ *
+ * @return returns the string representation of the MenuComponent
+ * state.
+ */
+ protected String paramString() {
+ toolkit.lockAWT();
+ try {
+ return getName();
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ //???AWT
+ /*
+ public AccessibleContext getAccessibleContext() {
+ toolkit.lockAWT();
+ try {
+ if (accessibleContext == null) {
+ accessibleContext = createAccessibleContext();
+ }
+ return accessibleContext;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+ */
+
+ /**
+ * Gets the font of the MenuComponent object.
+ *
+ * @return the Font of the MenuComponent object.
+ */
+ public Font getFont() {
+ toolkit.lockAWT();
+ try {
+ if (font == null && hasDefaultFont()) {
+ return toolkit.getDefaultFont();
+ }
+ if (font == null && parent != null) {
+ return parent.getFont();
+ }
+ return font;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Checks if is font set.
+ *
+ * @return true, if is font set
+ */
+ boolean isFontSet() {
+ return font != null
+ || ((parent instanceof MenuComponent) && ((MenuComponent) parent).isFontSet());
+ }
+
+ /**
+ * Checks for default font.
+ *
+ * @return true, if successful
+ */
+ boolean hasDefaultFont() {
+ return false;
+ }
+
+ /**
+ * Processes an AWTEevent on this menu component.
+ *
+ * @param event the AWTEvent.
+ */
+ protected void processEvent(AWTEvent event) {
+ toolkit.lockAWT();
+ try {
+ // do nothing
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Removes the peer of the MenuComponent.
+ */
+ public void removeNotify() {
+ toolkit.lockAWT();
+ try {
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the Font for this MenuComponent object.
+ *
+ * @param font the new Font to be used for this MenuComponent.
+ */
+ public void setFont(Font font) {
+ toolkit.lockAWT();
+ try {
+ this.font = font;
+ } finally {
+ toolkit.unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the parent.
+ *
+ * @param parent the new parent
+ */
+ void setParent(MenuContainer parent) {
+ this.parent = parent;
+ }
+
+ /**
+ * Gets the location.
+ *
+ * @return the location
+ */
+ Point getLocation() {
+ // to be overridden
+ return new Point(0, 0);
+ }
+
+ /**
+ * Gets the width.
+ *
+ * @return the width
+ */
+ int getWidth() {
+ // to be overridden
+ return 1;
+ }
+
+ /**
+ * Gets the height.
+ *
+ * @return the height
+ */
+ int getHeight() {
+ // to be overridden
+ return 1;
+ }
+
+ /**
+ * Recursively find the menu item for a menu shortcut.
+ *
+ * @param gr the gr
+ *
+ * @return the menu item;
+ * or null if the item is not available for this shortcut
+ */
+ //???AWT
+ /*
+ MenuItem getShortcutMenuItemImpl(MenuShortcut ms) {
+ if (ms == null) {
+ return null;
+ }
+ for (int i = 0; i < getItemCount(); i++) {
+ MenuItem mi = getItem(i);
+ if (mi instanceof Menu) {
+ mi = ((Menu) mi).getShortcutMenuItemImpl(ms);
+ if (mi != null) {
+ return mi;
+ }
+ } else if (ms.equals(mi.getShortcut())) {
+ return mi;
+ }
+ }
+ return null;
+ }
+ */
+
+ void paint(Graphics gr) {
+ gr.setColor(Color.LIGHT_GRAY);
+ gr.fillRect(0, 0, getWidth(), getHeight());
+ gr.setColor(Color.BLACK);
+ }
+
+ /**
+ * Mouse events handler.
+ *
+ * @param eventId - one of the MouseEvent.MOUSE_* constants
+ * @param where - mouse location
+ * @param mouseButton - mouse button that was pressed or released
+ * @param when - event time
+ * @param modifiers - input event modifiers
+ */
+ void onMouseEvent(int eventId, Point where, int mouseButton, long when, int modifiers) {
+ // to be overridden
+ }
+
+ /**
+ * Keyboard event handler.
+ *
+ * @param eventId - one of the KeyEvent.KEY_* constants
+ * @param vKey - the key code
+ * @param when - event time
+ * @param modifiers - input event modifiers
+ */
+ void onKeyEvent(int eventId, int vKey, long when, int modifiers) {
+ // to be overridden
+ }
+
+ /**
+ * Post the ActionEvent or ItemEvent,
+ * depending on type of the menu item.
+ *
+ * @param index the index
+ *
+ * @return the item rect
+ */
+ //???AWT
+ /*
+ void fireItemAction(int item, long when, int modifiers) {
+ MenuItem mi = getItem(item);
+ mi.itemSelected(when, modifiers);
+ }
+
+ MenuItem getItem(int index) {
+ // to be overridden
+ return null;
+ }
+
+ int getItemCount() {
+ return 0;
+ }
+ */
+
+ /**
+ * @return The sub-menu of currently selecetd item,
+ * or null if such a sub-menu is not available
+ */
+ //???AWT
+ /*
+ Menu getSelectedSubmenu() {
+ if (selectedItemIndex < 0) {
+ return null;
+ }
+ MenuItem item = getItem(selectedItemIndex);
+ return (item instanceof Menu) ? (Menu) item : null;
+ }
+ */
+
+ /**
+ * Convenience method for selectItem(index, true)
+ */
+ //???AWT
+ /*
+ void selectItem(int index) {
+ selectItem(index, true);
+ }
+ */
+
+ /**
+ * Change the selection in the menu
+ * @param index - new selecetd item's index
+ * @param showSubMenu - if new selected item has a sub-menu,
+ * should that sub-menu be displayed
+ */
+ //???AWT
+ /*
+ void selectItem(int index, boolean showSubMenu) {
+ if (selectedItemIndex == index) {
+ return;
+ }
+ if (selectedItemIndex >= 0 && getItem(selectedItemIndex) instanceof Menu) {
+ ((Menu) getItem(selectedItemIndex)).hide();
+ }
+ MultiRectArea clip = getUpdateClip(index, selectedItemIndex);
+ selectedItemIndex = index;
+ Graphics gr = getGraphics(clip);
+ if (gr != null) {
+ paint(gr);
+ }
+ if (showSubMenu) {
+ showSubMenu(selectedItemIndex);
+ }
+ }
+ */
+
+ /**
+ * Change the selected item to the next one in the requested direction
+ * moving cyclically, skipping separators
+ * @param forward - the direction to move the selection
+ * @param showSubMenu - if new selected item has a sub-menu,
+ * should that sub-menu be displayed
+ */
+ //???AWT
+ /*
+ void selectNextItem(boolean forward, boolean showSubMenu) {
+ int selected = getSelectedItemIndex();
+ int count = getItemCount();
+ if (count == 0) {
+ return;
+ }
+ if (selected < 0) {
+ selected = (forward ? count - 1 : 0);
+ }
+ int i = selected;
+ do {
+ i = (forward ? (i + 1) : (i + count - 1)) % count;
+ i %= count;
+ MenuItem item = getItem(i);
+ if (!"-".equals(item.getLabel())) { //$NON-NLS-1$
+ selectItem(i, showSubMenu);
+ return;
+ }
+ } while (i != selected);
+ }
+
+
+ void showSubMenu(int index) {
+ if ((index < 0) || !isActive()) {
+ return;
+ }
+ MenuItem item = getItem(index);
+ if (item instanceof Menu) {
+ Menu menu = ((Menu) getItem(index));
+ if (menu.getItemCount() == 0) {
+ return;
+ }
+ Point location = getSubmenuLocation(index);
+ menu.show(location.x, location.y, false);
+ }
+ }
+ */
+
+ /**
+ * @return - the menu bar which is the root of crrent menu's hierarchy;
+ * or null if the hierarchy root is not a menu bar
+ */
+ //???AWT
+ /*
+ MenuBar getMenuBar() {
+ if (parent instanceof MenuBar) {
+ return (MenuBar) parent;
+ }
+ if (parent instanceof MenuComponent) {
+ return ((MenuComponent) parent).getMenuBar();
+ }
+ return null;
+ }
+
+ PopupBox getPopupBox() {
+ return null;
+ }
+ */
+
+ Rectangle getItemRect(int index) {
+ // to be overridden
+ return null;
+ }
+
+ /**
+ * Determine the clip region when menu selection is changed
+ * from index1 to index2.
+ *
+ * @param index1 - old selected intem
+ * @param index2 - new selected item
+ *
+ * @return - the region to repaint
+ */
+ final MultiRectArea getUpdateClip(int index1, int index2) {
+ MultiRectArea clip = new MultiRectArea();
+ if (index1 >= 0) {
+ clip.add(getItemRect(index1));
+ }
+ if (index2 >= 0) {
+ clip.add(getItemRect(index2));
+ }
+ return clip;
+ }
+
+ /**
+ * Gets the submenu location.
+ *
+ * @param index the index
+ *
+ * @return the submenu location
+ */
+ Point getSubmenuLocation(int index) {
+ // to be overridden
+ return new Point(0, 0);
+ }
+
+ /**
+ * Gets the selected item index.
+ *
+ * @return the selected item index
+ */
+ int getSelectedItemIndex() {
+ return selectedItemIndex;
+ }
+
+ /**
+ * Hide.
+ */
+ void hide() {
+ selectedItemIndex = -1;
+ if (parent instanceof MenuComponent) {
+ ((MenuComponent) parent).itemHidden(this);
+ }
+ }
+
+ /**
+ * Item hidden.
+ *
+ * @param mc the mc
+ */
+ void itemHidden(MenuComponent mc) {
+ // to be overridden
+ }
+
+ /**
+ * Checks if is visible.
+ *
+ * @return true, if is visible
+ */
+ boolean isVisible() {
+ return true;
+ }
+
+ /**
+ * Checks if is active.
+ *
+ * @return true, if is active
+ */
+ boolean isActive() {
+ return true;
+ }
+
+ /**
+ * Hide all menu hierarchy.
+ */
+ void endMenu() {
+ //???AWT: toolkit.dispatcher.popupDispatcher.deactivateAll();
+ }
+
+ /**
+ * Handle the mouse click or Enter key event on a menu's item.
+ *
+ * @param when - the event time
+ * @param modifiers - input event modifiers
+ */
+ void itemSelected(long when, int modifiers) {
+ endMenu();
+ }
+
+ /**
+ * Auto name.
+ *
+ * @return the string
+ */
+ String autoName() {
+ String name = getClass().getName();
+ if (name.indexOf("$") != -1) { //$NON-NLS-1$
+ return null;
+ }
+ //???AWT: int number = toolkit.autoNumber.nextMenuComponent++;
+ int number = 0;
+ name = name.substring(name.lastIndexOf(".") + 1) + Integer.toString(number); //$NON-NLS-1$
+ return name;
+ }
+
+ /**
+ * Creates the Graphics object for the pop-up box of this menu component.
+ *
+ * @param clip - the clip to set on this Graphics
+ *
+ * @return - the created Graphics object,
+ * or null if such object is not available.
+ */
+ Graphics getGraphics(MultiRectArea clip) {
+ // to be overridden
+ return null;
+ }
+
+ /**
+ * @return accessible context specific for particular menu component
+ */
+ //???AWT
+ /*
+ AccessibleContext createAccessibleContext() {
+ return null;
+ }
+ */
+}
diff --git a/awt/java/awt/MenuContainer.java b/awt/java/awt/MenuContainer.java
new file mode 100644
index 0000000..7a48f13
--- /dev/null
+++ b/awt/java/awt/MenuContainer.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ * The MenuContainer interface represents all menu containers.
+ */
+public interface MenuContainer {
+
+ /**
+ * Removes the specified MenuComponent from the MenuContainer.
+ *
+ * @param c the MenuComponent.
+ */
+ public void remove(MenuComponent c);
+
+ /**
+ * Gets the Font of the MenuContainer.
+ *
+ * @return the font of the MenuContainer.
+ */
+ public Font getFont();
+
+ /**
+ * Posts an Event.
+ *
+ * @param e the Event.
+ *
+ * @return true if the event is posted successfully;
+ * false otherwise.
+ *
+ * @deprecated Replaced by dispatchEvent method.
+ */
+ @Deprecated
+ public boolean postEvent(Event e);
+
+}
+
diff --git a/awt/java/awt/ModalContext.java b/awt/java/awt/ModalContext.java
new file mode 100644
index 0000000..32a5912
--- /dev/null
+++ b/awt/java/awt/ModalContext.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ *
+ * The context for nested event loop. It can be dialog, popup menu etc.
+ */
+class ModalContext {
+
+ private boolean running = false;
+
+ private final Toolkit toolkit;
+
+ ModalContext() {
+ toolkit = Toolkit.getDefaultToolkit();
+ }
+
+ /**
+ * Set up and run modal loop in this context
+ *
+ */
+ void runModalLoop() {
+ running = true;
+ toolkit.dispatchThread.runModalLoop(this);
+ }
+
+ /**
+ * Leave the modal loop running in this context
+ * This method doesn't stops the loop immediately,
+ * it just sets the flag that says the modal loop to stop
+ *
+ */
+ void endModalLoop() {
+ running = false;
+ }
+
+ /**
+ *
+ * @return modal loop is currently running in this context
+ */
+ boolean isModalLoopRunning() {
+ return running;
+ }
+
+}
diff --git a/awt/java/awt/MouseDispatcher.java b/awt/java/awt/MouseDispatcher.java
new file mode 100644
index 0000000..df48f9d
--- /dev/null
+++ b/awt/java/awt/MouseDispatcher.java
@@ -0,0 +1,418 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Dmitry A. Durnev, Michael Danilov, Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.event.MouseMotionListener;
+import java.awt.event.MouseWheelEvent;
+import java.awt.event.MouseWheelListener;
+import java.awt.Dispatcher.MouseGrabManager;
+import java.util.EventListener;
+
+import org.apache.harmony.awt.wtk.NativeEvent;
+import org.apache.harmony.awt.wtk.NativeWindow;
+
+
+class MouseDispatcher {
+
+ // Fields for synthetic mouse click events generation
+ private static final int clickDelta = 5;
+ private final long[] lastPressTime = new long[] {0l, 0l, 0l};
+ private final Point[] lastPressPos = new Point[] {null, null, null};
+ private final boolean[] buttonPressed = new boolean[] {false, false, false};
+ private final int[] clickCount = new int[] {0, 0, 0};
+
+ // Fields for mouse entered/exited support
+ private Component lastUnderPointer = null;
+ private final Point lastScreenPos = new Point(-1, -1);
+
+ // Fields for redundant mouse moved/dragged filtering
+ private Component lastUnderMotion = null;
+ private Point lastLocalPos = new Point(-1, -1);
+
+ private final MouseGrabManager mouseGrabManager;
+ private final Toolkit toolkit;
+
+ static Point convertPoint(Component src, int x, int y, Component dest) {
+ Point srcPoint = getAbsLocation(src);
+ Point destPoint = getAbsLocation(dest);
+
+ return new Point(x + (srcPoint.x - destPoint.x),
+ y + (srcPoint.y - destPoint.y));
+ }
+
+ static Point convertPoint(Component src, Point p, Component dst) {
+ return convertPoint(src, p.x, p.y, dst);
+ }
+
+ private static Point getAbsLocation(Component comp) {
+ Point location = new Point(0, 0);
+// BEGIN android-changed: AWT components not supported
+// for (Component parent = comp; parent != null; parent = parent.parent) {
+// Point parentPos = (parent instanceof EmbeddedWindow ?
+// parent.getNativeWindow().getScreenPos() :
+// parent.getLocation());
+//
+// location.translate(parentPos.x, parentPos.y);
+//
+// if (parent instanceof Window) {
+// break;
+// }
+// }
+// END android-changed
+
+ return location;
+ }
+
+ MouseDispatcher(MouseGrabManager mouseGrabManager,
+ Toolkit toolkit) {
+ this.mouseGrabManager = mouseGrabManager;
+ this.toolkit = toolkit;
+ }
+
+ Point getPointerPos() {
+ return lastScreenPos;
+ }
+
+ boolean dispatch(Component src, NativeEvent event) {
+ int id = event.getEventId();
+
+ lastScreenPos.setLocation(event.getScreenPos());
+ checkMouseEnterExit(event.getInputModifiers(), event.getTime());
+
+ if (id == MouseEvent.MOUSE_WHEEL) {
+// BEGIN android-changed: AWT components not supported
+// dispatchWheelEvent(src, event);
+// END android-changed
+ } else if ((id != MouseEvent.MOUSE_ENTERED) &&
+ (id != MouseEvent.MOUSE_EXITED)) {
+ PointerInfo info = new PointerInfo(src, event.getLocalPos());
+
+ mouseGrabManager.preprocessEvent(event);
+ findEventSource(info);
+ if ((id == MouseEvent.MOUSE_PRESSED) ||
+ (id == MouseEvent.MOUSE_RELEASED)) {
+
+ dispatchButtonEvent(info, event);
+ } else if ((id == MouseEvent.MOUSE_MOVED) ||
+ (id == MouseEvent.MOUSE_DRAGGED)) {
+
+ dispatchMotionEvent(info, event);
+ }
+ }
+
+ return false;
+ }
+
+ private void checkMouseEnterExit(int modifiers, long when) {
+// BEGIN android-changed: AWT components not supported
+// PointerInfo info = findComponentUnderPointer();
+// Component curUnderPointer =
+// propagateEvent(info, AWTEvent.MOUSE_EVENT_MASK,
+// MouseListener.class, false).src;
+//
+// if (curUnderPointer != lastUnderPointer) {
+// Point pos = info.position;
+// if ((lastUnderPointer != null) &&
+// lastUnderPointer.isMouseExitedExpected()) {
+//
+// Point exitPos = convertPoint(null, lastScreenPos.x,
+// lastScreenPos.y, lastUnderPointer);
+//
+// postMouseEnterExit(MouseEvent.MOUSE_EXITED, modifiers, when,
+// exitPos.x, exitPos.y, lastUnderPointer);
+// }
+// setCursor(curUnderPointer);
+// if (curUnderPointer != null) {
+// postMouseEnterExit(MouseEvent.MOUSE_ENTERED, modifiers, when,
+// pos.x, pos.y, curUnderPointer);
+// }
+// lastUnderPointer = curUnderPointer;
+// }
+// END android-changed
+ }
+
+ private void setCursor(Component comp) {
+ if (comp == null) {
+ return;
+ }
+ Component grabOwner = mouseGrabManager.getSyntheticGrabOwner();
+ Component cursorComp = ((grabOwner != null) &&
+ grabOwner.isShowing() ? grabOwner : comp);
+ cursorComp.setCursor();
+ }
+
+ private void postMouseEnterExit(int id, int mod, long when,
+ int x, int y, Component comp) {
+ if (comp.isIndirectlyEnabled()) {
+ toolkit.getSystemEventQueueImpl().postEvent(
+ new MouseEvent(comp, id, when, mod, x, y, 0, false));
+ comp.setMouseExitedExpected(id == MouseEvent.MOUSE_ENTERED);
+ } else {
+ comp.setMouseExitedExpected(false);
+ }
+ }
+
+ // BEGIN android-changed: AWT components not supported
+// private PointerInfo findComponentUnderPointer() {
+// NativeWindow nativeWindow = toolkit.getWindowFactory().
+// getWindowFromPoint(lastScreenPos);
+//
+// if (nativeWindow != null) {
+// Component comp = toolkit.getComponentById(nativeWindow.getId());
+//
+// if (comp != null) {
+// Window window = comp.getWindowAncestor();
+// Point pointerPos = convertPoint(null, lastScreenPos.x,
+// lastScreenPos.y, window);
+//
+// if (window.getClient().contains(pointerPos)) {
+// PointerInfo info = new PointerInfo(window, pointerPos);
+//
+// fall2Child(info);
+//
+// return info;
+// }
+// }
+// }
+//
+// return new PointerInfo(null, null);
+// }
+// END android-changed
+
+ private void findEventSource(PointerInfo info) {
+ Component grabOwner = mouseGrabManager.getSyntheticGrabOwner();
+
+ if (grabOwner != null && grabOwner.isShowing()) {
+ info.position = convertPoint(info.src, info.position, grabOwner);
+ info.src = grabOwner;
+ } else {
+ //???AWT: rise2TopLevel(info);
+ //???AWT: fall2Child(info);
+ }
+ }
+
+ // BEGIN android-changed: AWT components not supported
+// private void rise2TopLevel(PointerInfo info) {
+// while (!(info.src instanceof Window)) {
+// info.position.translate(info.src.x, info.src.y);
+// info.src = info.src.parent;
+// }
+// }
+//
+// private void fall2Child(PointerInfo info) {
+// Insets insets = info.src.getInsets();
+//
+// final Point pos = info.position;
+// final int x = pos.x;
+// final int y = pos.y;
+// if ((x >= insets.left) && (y >= insets.top) &&
+// (x < (info.src.w - insets.right)) &&
+// (y < (info.src.h - insets.bottom)))
+// {
+// Component[] children = ((Container) info.src).getComponents();
+//
+// for (Component child : children) {
+// if (child.isShowing()) {
+// if (child.contains(x - child.getX(),
+// y - child.getY()))
+// {
+// info.src = child;
+// pos.translate(-child.x, -child.y);
+//
+// if (child instanceof Container) {
+// fall2Child(info);
+// }
+//
+// return;
+// }
+// }
+// }
+// }
+// }
+// END android-changed
+
+ private void dispatchButtonEvent(PointerInfo info, NativeEvent event) {
+ int button = event.getMouseButton();
+ long time = event.getTime();
+ int id = event.getEventId();
+ int index = button - 1;
+ boolean clickRequired = false;
+
+ propagateEvent(info, AWTEvent.MOUSE_EVENT_MASK,
+ MouseListener.class, false);
+ if (id == MouseEvent.MOUSE_PRESSED) {
+ int clickInterval = toolkit.dispatcher.clickInterval;
+ mouseGrabManager.onMousePressed(info.src);
+ buttonPressed[index] = true;
+ clickCount[index] = (!deltaExceeded(index, info) &&
+ ((time - lastPressTime[index]) <= clickInterval)) ?
+ clickCount[index] + 1 : 1;
+ lastPressTime[index] = time;
+ lastPressPos[index] = info.position;
+ } else {
+ mouseGrabManager.onMouseReleased(info.src);
+ // set cursor back on synthetic mouse grab end:
+// BEGIN android-changed: AWT components not supported
+// setCursor(findComponentUnderPointer().src);
+// END android-changed
+ if (buttonPressed[index]) {
+ buttonPressed[index] = false;
+ clickRequired = !deltaExceeded(index, info);
+ } else {
+ clickCount[index] = 0;
+ }
+ }
+ if (info.src.isIndirectlyEnabled()) {
+ final Point pos = info.position;
+ final int mod = event.getInputModifiers();
+ toolkit.getSystemEventQueueImpl().postEvent(
+ new MouseEvent(info.src, id, time, mod, pos.x,
+ pos.y, clickCount[index],
+ event.getTrigger(), button));
+ if (clickRequired) {
+ toolkit.getSystemEventQueueImpl().postEvent(
+ new MouseEvent(info.src,
+ MouseEvent.MOUSE_CLICKED,
+ time, mod, pos.x, pos.y,
+ clickCount[index], false,
+ button));
+ }
+ }
+ }
+
+ private boolean deltaExceeded(int index, PointerInfo info) {
+ final Point lastPos = lastPressPos[index];
+ if (lastPos == null) {
+ return true;
+ }
+ return ((Math.abs(lastPos.x - info.position.x) > clickDelta) ||
+ (Math.abs(lastPos.y - info.position.y) > clickDelta));
+ }
+
+ private void dispatchMotionEvent(PointerInfo info, NativeEvent event) {
+ propagateEvent(info, AWTEvent.MOUSE_MOTION_EVENT_MASK,
+ MouseMotionListener.class, false);
+ final Point pos = info.position;
+ if ((lastUnderMotion != info.src) ||
+ !lastLocalPos.equals(pos)) {
+
+ lastUnderMotion = info.src;
+ lastLocalPos = pos;
+
+ if (info.src.isIndirectlyEnabled()) {
+ toolkit.getSystemEventQueueImpl().postEvent(
+ new MouseEvent(info.src, event.getEventId(),
+ event.getTime(),
+ event.getInputModifiers(),
+ pos.x, pos.y, 0, false));
+ }
+ }
+ }
+
+ MouseWheelEvent createWheelEvent(Component src, NativeEvent event,
+ Point where) {
+
+ Integer scrollAmountProperty =
+ (Integer)toolkit.getDesktopProperty("awt.wheelScrollingSize"); //$NON-NLS-1$
+ int amount = 1;
+ int type = MouseWheelEvent.WHEEL_UNIT_SCROLL;
+
+ if (scrollAmountProperty != null) {
+ amount = scrollAmountProperty.intValue();
+ if (amount == -1) {
+ type = MouseWheelEvent.WHEEL_BLOCK_SCROLL;
+ amount = 1;
+ }
+ }
+ return new MouseWheelEvent(src, event.getEventId(),
+ event.getTime(), event.getInputModifiers(),
+ where.x, where.y, 0, false, type, amount,
+ event.getWheelRotation());
+ }
+
+// BEGIN android-changed: AWT components not supported
+// private void dispatchWheelEvent(Component src, NativeEvent event) {
+// PointerInfo info = findComponentUnderPointer();
+//
+// if (info.src == null) {
+// info.src = src;
+// info.position = event.getLocalPos();
+// }
+//
+// propagateEvent(info, AWTEvent.MOUSE_WHEEL_EVENT_MASK,
+// MouseWheelListener.class, true);
+// if ((info.src != null) && info.src.isIndirectlyEnabled()) {
+// toolkit.getSystemEventQueueImpl().postEvent(
+// createWheelEvent(info.src, event, info.position));
+// }
+// }
+// END android-changed
+
+ private PointerInfo propagateEvent(PointerInfo info, long mask,
+ Class<? extends EventListener> type, boolean pierceHW) {
+ Component src = info.src;
+ while ((src != null) &&
+ (src.isLightweight() || pierceHW) &&
+ !(src.isMouseEventEnabled(mask) ||
+ (src.getListeners(type).length > 0))) {
+
+ info.position.translate(src.x, src.y);
+// BEGIN android-changed: AWT components not supported
+// src = src.parent;
+// END android-changed
+ info.src = src;
+ }
+
+ return info;
+ }
+
+// BEGIN android-changed: AWT components not supported
+// Window findWindowAt(Point p) {
+// NativeWindow nativeWindow =
+// toolkit.getWindowFactory().getWindowFromPoint(p);
+//
+// Window window = null;
+// if (nativeWindow != null) {
+// Component comp = toolkit.getComponentById(nativeWindow.getId());
+//
+// if (comp != null) {
+// window = comp.getWindowAncestor();
+// }
+// }
+// return window;
+// }
+// END android-changed
+
+ private class PointerInfo {
+
+ Component src;
+ Point position;
+
+ PointerInfo(Component src, Point position) {
+ this.src = src;
+ this.position = position;
+ }
+
+ }
+
+}
diff --git a/awt/java/awt/Paint.java b/awt/java/awt/Paint.java
new file mode 100644
index 0000000..f8732c8
--- /dev/null
+++ b/awt/java/awt/Paint.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.ColorModel;
+
+/**
+ * The Paint interface provides possibility of generating
+ * color patterns in device space for fill, draw, or stroke operations
+ * in a Graphics2D.
+ */
+public interface Paint extends Transparency {
+
+ /**
+ * Creates the PaintContext which is used to generate color
+ * patterns for rendering operations of Graphics2D.
+ *
+ * @param cm the ColorModel object, or null.
+ * @param deviceBounds the Rectangle represents the bounding box of
+ * device space for the graphics rendering operations.
+ * @param userBounds the Rectangle represents bounding box of
+ * user space for the graphics rendering operations.
+ * @param xform the AffineTransform for translation from user space
+ * to device space.
+ * @param hints the RenderingHints preferences.
+ *
+ * @return the PaintContext for generating color patterns.
+ */
+ PaintContext createContext(ColorModel cm, Rectangle deviceBounds,
+ Rectangle2D userBounds, AffineTransform xform,
+ RenderingHints hints);
+}
diff --git a/awt/java/awt/PaintContext.java b/awt/java/awt/PaintContext.java
new file mode 100644
index 0000000..647de8b
--- /dev/null
+++ b/awt/java/awt/PaintContext.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.image.ColorModel;
+import java.awt.image.Raster;
+
+/**
+ * The PaintContext interface determines the specific environment for
+ * generating color patterns in device space for fill, draw, or stroke
+ * rendering operations using Graphics2D. This interface provides colors
+ * through the Raster object associated with the specific ColorModel
+ * for Graphics2D rendering operations.
+ */
+public interface PaintContext {
+
+ /**
+ * Releases the resources allocated for the operation.
+ */
+ void dispose();
+
+ /**
+ * Gets the color model.
+ *
+ * @return the ColorModel object.
+ */
+ ColorModel getColorModel();
+
+ /**
+ * Gets the Raster which defines the colors of the specified rectangular
+ * area for Graphics2D rendering operations.
+ *
+ * @param x the X coordinate of the device space area for which
+ * colors are generated.
+ * @param y the Y coordinate of the device space area for which
+ * colors are generated.
+ * @param w the width of the device space area for which
+ * colors are generated.
+ * @param h the height of the device space area for which
+ * colors are generated.
+ *
+ * @return the Raster object which contains the colors of the specified
+ * rectangular area for Graphics2D rendering operations.
+ */
+ Raster getRaster(int x, int y, int w, int h);
+}
diff --git a/awt/java/awt/Point.java b/awt/java/awt/Point.java
new file mode 100644
index 0000000..99418ed
--- /dev/null
+++ b/awt/java/awt/Point.java
@@ -0,0 +1,195 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.geom.Point2D;
+import java.io.Serializable;
+
+/**
+ * The Point class represents a point location with coordinates X, Y in
+ * current coordinate system.
+ */
+public class Point extends Point2D implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -5276940640259749850L;
+
+ /** The X coordinate of Point. */
+ public int x;
+
+ /** The Y coordinate of Point. */
+ public int y;
+
+ /**
+ * Instantiates a new point with (0, O) coordinates, the origin of
+ * coordinate system.
+ */
+ public Point() {
+ setLocation(0, 0);
+ }
+
+ /**
+ * Instantiates a new point with (x, y) coordinates.
+ *
+ * @param x the X coordinate of Point.
+ * @param y the Y coordinate of Point.
+ */
+ public Point(int x, int y) {
+ setLocation(x, y);
+ }
+
+ /**
+ * Instantiates a new point, giving it the same locaion as
+ * the parameter p.
+ *
+ * @param p the Point object giving the coordinates of the new point.
+ */
+ public Point(Point p) {
+ setLocation(p.x, p.y);
+ }
+
+ /**
+ * Compares current Point with the specified object.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if the Object being compared is a Point
+ * whose coordinates are equal to the coordinates of this
+ * Point, otherwise false.
+ *
+ * @see java.awt.geom.Point2D#equals(Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (obj instanceof Point) {
+ Point p = (Point)obj;
+ return x == p.x && y == p.y;
+ }
+ return false;
+ }
+
+ /**
+ * Returns string representation of the current Point object.
+ *
+ * @return a string representation of the current Point object.
+ */
+ @Override
+ public String toString() {
+ return getClass().getName() + "[x=" + x + ",y=" + y + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+ /**
+ * Gets X coordinate of Point as a double.
+ *
+ * @return X coordinate of the point as a double.
+ *
+ * @see java.awt.geom.Point2D#getX()
+ */
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ /**
+ * Gets Y coordinate of Point as a double.
+ *
+ * @return Y coordinate of the point as a double.
+ *
+ * @see java.awt.geom.Point2D#getY()
+ */
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ /**
+ * Gets the location of the Point as a new Point object.
+ *
+ * @return a copy of the Point.
+ */
+ public Point getLocation() {
+ return new Point(x, y);
+ }
+
+ /**
+ * Sets the location of the Point to the same coordinates as p.
+ *
+ * @param p the Point that gives the new location.
+ */
+ public void setLocation(Point p) {
+ setLocation(p.x, p.y);
+ }
+
+ /**
+ * Sets the location of the Point to the coordinates X, Y.
+ *
+ * @param x the X coordinate of the Point's new location.
+ * @param y the Y coordinate of the Point's new location.
+ */
+ public void setLocation(int x, int y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ /**
+ * Sets the location of Point to the specified double coordinates.
+ *
+ * @param x the X the Point's new location.
+ * @param y the Y the Point's new location.
+ *
+ * @see java.awt.geom.Point2D#setLocation(double, double)
+ */
+ @Override
+ public void setLocation(double x, double y) {
+ x = x < Integer.MIN_VALUE ? Integer.MIN_VALUE : x > Integer.MAX_VALUE ? Integer.MAX_VALUE : x;
+ y = y < Integer.MIN_VALUE ? Integer.MIN_VALUE : y > Integer.MAX_VALUE ? Integer.MAX_VALUE : y;
+ setLocation((int)Math.round(x), (int)Math.round(y));
+ }
+
+ /**
+ * Moves the Point to the specified (x, y) location.
+ *
+ * @param x the X coordinate of the new location.
+ * @param y the Y coordinate of the new location.
+ */
+ public void move(int x, int y) {
+ setLocation(x, y);
+ }
+
+ /**
+ * Translates current Point moving it from the position (x, y)
+ * to the new position given by (x+dx, x+dy) coordinates.
+ *
+ * @param dx the horizontal delta - the Point is moved to this distance along
+ * X axis.
+ * @param dy the vertical delta - the Point is moved to this distance along
+ * Y axis.
+ */
+ public void translate(int dx, int dy) {
+ x += dx;
+ y += dy;
+ }
+
+}
+
diff --git a/awt/java/awt/Polygon.java b/awt/java/awt/Polygon.java
new file mode 100644
index 0000000..6f3fc97
--- /dev/null
+++ b/awt/java/awt/Polygon.java
@@ -0,0 +1,494 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.PathIterator;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.io.Serializable;
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.gl.*;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Polygon class defines an closed area specified by n vertices and
+ * n edges. The coordinates of the vertices are specified by x, y arrays.
+ * The edges are the line segments from the point (x[i], y[i]) to the point
+ * (x[i+1], y[i+1]), for -1 < i < (n-1) plus the line segment from
+ * the point (x[n-1], y[n-1]) to the point (x[0], y[0]) point.
+ * The Polygon is empty if the number of vertices is zero.
+ */
+public class Polygon implements Shape, Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -6460061437900069969L;
+
+ /** The points buffer capacity. */
+ private static final int BUFFER_CAPACITY = 4;
+
+ /** The number of Polygon vertices.*/
+ public int npoints;
+
+ /** The array of X coordinates of the vertices. */
+ public int[] xpoints;
+
+ /** The array of Y coordinates of the vertices. */
+ public int[] ypoints;
+
+ /**
+ * The smallest Rectangle that completely contains this Polygon.
+ */
+ protected Rectangle bounds;
+
+ /*
+ * Polygon path iterator
+ */
+ /**
+ * The internal Class Iterator.
+ */
+ class Iterator implements PathIterator {
+
+ /** The source Polygon object. */
+ public Polygon p;
+
+ /** The path iterator transformation. */
+ public AffineTransform t;
+
+ /** The current segmenet index. */
+ public int index;
+
+ /**
+ * Constructs a new Polygon.Iterator for the given polygon and transformation
+ *
+ * @param at - the AffineTransform object to apply rectangle path
+ * @param p the p
+ */
+ public Iterator(AffineTransform at, Polygon p) {
+ this.p = p;
+ this.t = at;
+ if (p.npoints == 0) {
+ index = 1;
+ }
+ }
+
+ public int getWindingRule() {
+ return WIND_EVEN_ODD;
+ }
+
+ public boolean isDone() {
+ return index > p.npoints;
+ }
+
+ public void next() {
+ index++;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ // awt.110=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.110")); //$NON-NLS-1$
+ }
+ if (index == p.npoints) {
+ return SEG_CLOSE;
+ }
+ coords[0] = p.xpoints[index];
+ coords[1] = p.ypoints[index];
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, 1);
+ }
+ return index == 0 ? SEG_MOVETO : SEG_LINETO;
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ // awt.110=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.110")); //$NON-NLS-1$
+ }
+ if (index == p.npoints) {
+ return SEG_CLOSE;
+ }
+ coords[0] = p.xpoints[index];
+ coords[1] = p.ypoints[index];
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, 1);
+ }
+ return index == 0 ? SEG_MOVETO : SEG_LINETO;
+ }
+ }
+
+ /**
+ * Instantiates a new empty polygon.
+ */
+ public Polygon() {
+ xpoints = new int[BUFFER_CAPACITY];
+ ypoints = new int[BUFFER_CAPACITY];
+ }
+
+ /**
+ * Instantiates a new polygon with the specified number of vertices,
+ * and the given arrays of x, y vertex coordinates. The length of
+ * each coordinate array may not be less than the specified number of
+ * vertices but may be greater. Only the first n elements are used from
+ * each coordinate array.
+ *
+ * @param xpoints the array of X vertex coordinates.
+ * @param ypoints the array of Y vertex coordinates.
+ * @param npoints the number vertices of the polygon.
+ * @throws IndexOutOfBoundsException if the length of xpoints or ypoints
+ * is less than n.
+ * @throws NegativeArraySizeException if n is negative.
+ */
+ public Polygon(int[] xpoints, int[] ypoints, int npoints) {
+ if (npoints > xpoints.length || npoints > ypoints.length) {
+ // awt.111=Parameter npoints is greater than array length
+ throw new IndexOutOfBoundsException(Messages.getString("awt.111")); //$NON-NLS-1$
+ }
+ if (npoints < 0) {
+ // awt.112=Negative number of points
+ throw new NegativeArraySizeException(Messages.getString("awt.112")); //$NON-NLS-1$
+ }
+ this.npoints = npoints;
+ this.xpoints = new int[npoints];
+ this.ypoints = new int[npoints];
+ System.arraycopy(xpoints, 0, this.xpoints, 0, npoints);
+ System.arraycopy(ypoints, 0, this.ypoints, 0, npoints);
+ }
+
+ /**
+ * Resets the current Polygon to an empty Polygon. More precisely,
+ * the number of Polygon vertices is set to zero, but x, y coordinates
+ * arrays are not affected.
+ */
+ public void reset() {
+ npoints = 0;
+ bounds = null;
+ }
+
+ /**
+ * Invalidates the data that depends on the vertex coordinates.
+ * This method should be called after direct manipulations
+ * of the x, y vertex coordinates arrays to avoid unpredictable
+ * results of methods which rely on the bounding box.
+ */
+ public void invalidate() {
+ bounds = null;
+ }
+
+ /**
+ * Adds the point to the Polygon and updates the bounding box
+ * accordingly.
+ *
+ * @param px the X coordinate of the added vertex.
+ * @param py the Y coordinate of the added vertex.
+ */
+ public void addPoint(int px, int py) {
+ if (npoints == xpoints.length) {
+ int[] tmp;
+
+ tmp = new int[xpoints.length + BUFFER_CAPACITY];
+ System.arraycopy(xpoints, 0, tmp, 0, xpoints.length);
+ xpoints = tmp;
+
+ tmp = new int[ypoints.length + BUFFER_CAPACITY];
+ System.arraycopy(ypoints, 0, tmp, 0, ypoints.length);
+ ypoints = tmp;
+ }
+
+ xpoints[npoints] = px;
+ ypoints[npoints] = py;
+ npoints++;
+
+ if (bounds != null) {
+ bounds.setFrameFromDiagonal(
+ Math.min(bounds.getMinX(), px),
+ Math.min(bounds.getMinY(), py),
+ Math.max(bounds.getMaxX(), px),
+ Math.max(bounds.getMaxY(), py));
+ }
+ }
+
+ /**
+ * Gets the bounding rectangle of the Polygon. The bounding rectangle
+ * is the smallest rectangle which contains the Polygon.
+ *
+ * @return the bounding rectangle of the Polygon.
+ *
+ * @see java.awt.Shape#getBounds()
+ */
+ public Rectangle getBounds() {
+ if (bounds != null) {
+ return bounds;
+ }
+ if (npoints == 0) {
+ return new Rectangle();
+ }
+
+ int bx1 = xpoints[0];
+ int by1 = ypoints[0];
+ int bx2 = bx1;
+ int by2 = by1;
+
+ for (int i = 1; i < npoints; i++) {
+ int x = xpoints[i];
+ int y = ypoints[i];
+ if (x < bx1) {
+ bx1 = x;
+ } else if (x > bx2) {
+ bx2 = x;
+ }
+ if (y < by1) {
+ by1 = y;
+ } else if (y > by2) {
+ by2 = y;
+ }
+ }
+
+ return bounds = new Rectangle(bx1, by1, bx2 - bx1, by2 - by1);
+ }
+
+ /**
+ * Gets the bounding rectangle of the Polygon. The bounding rectangle
+ * is the smallest rectangle which contains the Polygon.
+ *
+ * @return the bounding rectangle of the Polygon.
+ *
+ * @deprecated Use getBounds() method.
+ */
+ @Deprecated
+ public Rectangle getBoundingBox() {
+ return getBounds();
+ }
+
+ /**
+ * Gets the Rectangle2D which represents Polygon bounds.
+ * The bounding rectangle is the smallest rectangle which contains
+ * the Polygon.
+ *
+ * @return the bounding rectangle of the Polygon.
+ *
+ * @see java.awt.Shape#getBounds2D()
+ */
+ public Rectangle2D getBounds2D() {
+ return getBounds().getBounds2D();
+ }
+
+ /**
+ * Translates all vertices of Polygon the specified distances
+ * along X, Y axis.
+ *
+ * @param mx the distance to translate horizontally.
+ * @param my the distance to translate vertically.
+ */
+ public void translate(int mx, int my) {
+ for (int i = 0; i < npoints; i++) {
+ xpoints[i] += mx;
+ ypoints[i] += my;
+ }
+ if (bounds != null) {
+ bounds.translate(mx, my);
+ }
+ }
+
+ /**
+ * Checks whether or not the point given by the coordinates x, y lies inside
+ * the Polygon.
+ *
+ * @param x the X coordinate of the point to check.
+ * @param y the Y coordinate of the point to check.
+ *
+ * @return true, if the specified point lies inside the Polygon,
+ * otherwise false.
+ *
+ * @deprecated Use contains(int, int) method.
+ */
+ @Deprecated
+ public boolean inside(int x, int y) {
+ return contains((double) x, (double) y);
+ }
+
+ /**
+ * Checks whether or not the point given by the coordinates x, y lies inside
+ * the Polygon.
+ *
+ * @param x the X coordinate of the point to check.
+ * @param y the Y coordinate of the point to check.
+ *
+ * @return true, if the specified point lies inside the Polygon,
+ * otherwise false.
+ */
+ public boolean contains(int x, int y) {
+ return contains((double) x, (double) y);
+ }
+
+ /**
+ * Checks whether or not the point with specified double coordinates
+ * lies inside the Polygon.
+ *
+ * @param x the X coordinate of the point to check.
+ * @param y the Y coordinate of the point to check.
+ *
+ * @return true, if the point given by the double coordinates
+ * lies inside the Polygon, otherwise false.
+ *
+ * @see java.awt.Shape#contains(double, double)
+ */
+ public boolean contains(double x, double y) {
+ return Crossing.isInsideEvenOdd(Crossing.crossShape(this, x, y));
+ }
+
+ /**
+ * Checks whether or not the rectangle determined by the parameters
+ * [x, y, width, height] lies inside the Polygon.
+ *
+ * @param x the X coordinate of the rectangles's left upper
+ * corner as a double.
+ * @param y the Y coordinate of the rectangles's left upper
+ * corner as a double.
+ * @param width the width of rectangle as a double.
+ * @param width the height of rectangle as a double.
+ *
+ * @return true, if the specified rectangle lies inside the Polygon,
+ * otherwise false.
+ *
+ * @see java.awt.Shape#contains(double, double, double, double)
+ */
+ public boolean contains(double x, double y, double width, double height) {
+ int cross = Crossing.intersectShape(this, x, y, width, height);
+ return cross != Crossing.CROSSING && Crossing.isInsideEvenOdd(cross);
+ }
+
+ /**
+ * Checks whether or not the rectangle determined by the parameters
+ * [x, y, width, height] intersects the interior of
+ * the Polygon.
+ *
+ * @param x the X coordinate of the rectangles's left upper
+ * corner as a double.
+ * @param y the Y coordinate of the rectangles's left upper
+ * corner as a double.
+ * @param width the width of rectangle as a double.
+ * @param width the height of rectangle as a double.
+ *
+ * @return true, if the specified rectangle intersects the interior of
+ * the Polygon, otherwise false.
+ *
+ * @see java.awt.Shape#intersects(double, double, double, double)
+ */
+ public boolean intersects(double x, double y, double width, double height) {
+ int cross = Crossing.intersectShape(this, x, y, width, height);
+ return cross == Crossing.CROSSING || Crossing.isInsideEvenOdd(cross);
+ }
+
+ /**
+ * Checks whether or not the specified rectangle lies inside the Polygon.
+ *
+ * @param rect the Rectangle2D object.
+ *
+ * @return true, if the specified rectangle lies inside the Polygon,
+ * otherwise false.
+ *
+ * @see java.awt.Shape#contains(java.awt.geom.Rectangle2D)
+ */
+ public boolean contains(Rectangle2D rect) {
+ return contains(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
+ }
+
+ /**
+ * Checks whether or not the specified Point lies inside the Polygon.
+ *
+ * @param point the Point object.
+ *
+ * @return true, if the specified Point lies inside the Polygon,
+ * otherwise false.
+ */
+ public boolean contains(Point point) {
+ return contains(point.getX(), point.getY());
+ }
+
+ /**
+ * Checks whether or not the specified Point2D lies inside the Polygon.
+ *
+ * @param point the Point2D object.
+ *
+ * @return true, if the specified Point2D lies inside the Polygon,
+ * otherwise false.
+ *
+ * @see java.awt.Shape#contains(java.awt.geom.Point2D)
+ */
+ public boolean contains(Point2D point) {
+ return contains(point.getX(), point.getY());
+ }
+
+ /**
+ * Checks whether or not the interior of rectangle specified by
+ * the Rectangle2D object intersects the interior of the Polygon.
+ *
+ * @param rect the Rectangle2D object.
+ *
+ * @return true, if the Rectangle2D intersects the interior of
+ * the Polygon, otherwise false.
+ *
+ * @see java.awt.Shape#intersects(java.awt.geom.Rectangle2D)
+ */
+ public boolean intersects(Rectangle2D rect) {
+ return intersects(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
+ }
+
+ /**
+ * Gets the PathIterator object which gives the coordinates of
+ * the polygon, transformed according to the specified AffineTransform.
+ *
+ * @param t the specified AffineTransform object, or null.
+ *
+ * @return PathIterator object for the Polygon.
+ *
+ * @see java.awt.Shape#getPathIterator(java.awt.geom.AffineTransform)
+ */
+ public PathIterator getPathIterator(AffineTransform t) {
+ return new Iterator(t, this);
+ }
+
+ /**
+ * Gets the PathIterator object which gives the coordinates of
+ * the polygon, transformed according to the specified AffineTransform.
+ * The flatness parameter is ignored.
+ *
+ * @param t the specified AffineTransform object, or null.
+ * @param flatness the maximum number of the control points for
+ * a given curve which varies from colinear before a subdivided curve
+ * is replaced by a straight line connecting the endpoints.
+ * This parameter is ignored for the Polygon class.
+ *
+ * @return PathIterator object for the Polygon.
+ *
+ * @see java.awt.Shape#getPathIterator(java.awt.geom.AffineTransform, double)
+ */
+ public PathIterator getPathIterator(AffineTransform t, double flatness) {
+ return new Iterator(t, this);
+ }
+
+}
+
diff --git a/awt/java/awt/Rectangle.java b/awt/java/awt/Rectangle.java
new file mode 100644
index 0000000..86c4dfc
--- /dev/null
+++ b/awt/java/awt/Rectangle.java
@@ -0,0 +1,686 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.geom.Rectangle2D;
+import java.io.Serializable;
+
+/**
+ * The Rectangle class defines the rectangular area in terms of its
+ * upper left corner coordinates [x,y], its width, and its height.
+ * A Rectangle specified by [x, y, width, height] parameters has an
+ * outline path with corners at [x, y], [x + width,y], [x + width,y + height],
+ * and [x, y + height].
+ * <br><br>
+ * The rectangle is empty if the width or height is negative or zero.
+ * In this case the isEmpty method returns true.
+ */
+public class Rectangle extends Rectangle2D implements Shape, Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -4345857070255674764L;
+
+ /** The X coordinate of the rectangle's left upper corner. */
+ public int x;
+
+ /** The Y coordinate of the rectangle's left upper corner. */
+ public int y;
+
+ /** The width of rectangle. */
+ public int width;
+
+ /** The height of rectangle. */
+ public int height;
+
+ /**
+ * Instantiates a new rectangle with [0, 0] upper left corner coordinates,
+ * the width and the height are zero.
+ */
+ public Rectangle() {
+ setBounds(0, 0, 0, 0);
+ }
+
+ /**
+ * Instantiates a new rectangle whose upper left corner coordinates are
+ * given by the Point object (p.X and p.Y), and the width and
+ * the height are zero.
+ *
+ * @param p the Point specifies the upper left corner coordinates of
+ * the rectangle.
+ */
+ public Rectangle(Point p) {
+ setBounds(p.x, p.y, 0, 0);
+ }
+
+ /**
+ * Instantiates a new rectangle whose upper left corner coordinates are
+ * given by the Point object (p.X and p.Y), and the width and the height
+ * are given by Dimension object (d.width and d.height).
+ *
+ * @param p the Point specifies the upper left corner coordinates of
+ * the rectangle.
+ * @param d the Dimention specifies the width and the height of the rectangle.
+ */
+ public Rectangle(Point p, Dimension d) {
+ setBounds(p.x, p.y, d.width, d.height);
+ }
+
+ /**
+ * Instantiates a new rectangle determined by the upper left corner
+ * coordinates (x, y), width and height.
+ *
+ * @param x the X upper left corner coordinate of the rectangle.
+ * @param y the Y upper left corner coordinate of the rectangle.
+ * @param width the width of rectangle.
+ * @param height the height of rectangle.
+ */
+ public Rectangle(int x, int y, int width, int height) {
+ setBounds(x, y, width, height);
+ }
+
+ /**
+ * Instantiates a new rectangle with [0, 0] as its upper left
+ * corner coordinates and the specified width and height.
+ *
+ * @param width the width of rectangle.
+ * @param height the height of rectangle.
+ */
+ public Rectangle(int width, int height) {
+ setBounds(0, 0, width, height);
+ }
+
+ /**
+ * Instantiates a new rectangle with the same coordinates
+ * as the given source rectangle.
+ *
+ * @param r the Rectangle object which parameters will be used for
+ * instantiating a new Rectangle.
+ */
+ public Rectangle(Rectangle r) {
+ setBounds(r.x, r.y, r.width, r.height);
+ }
+/*
+ public Rectangle(Dimension d) {
+ setBounds(0, 0, d.width, d.height);
+ }
+*/
+ /**
+ * Gets the X coordinate of bound as a double.
+ *
+ * @return the X coordinate of bound as a double.
+ *
+ * @see java.awt.geom.RectangularShape#getX()
+ */
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ /**
+ * Gets the Y coordinate of bound as a double.
+ *
+ * @return the Y coordinate of bound as a double.
+ *
+ * @see java.awt.geom.RectangularShape#getY()
+ */
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ /**
+ * Gets the height of the rectangle as a double.
+ *
+ * @return the height of the rectangle as a double.
+ *
+ * @see java.awt.geom.RectangularShape#getHeight()
+ */
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ /**
+ * Gets the width of the rectangle as a double.
+ *
+ * @return the width of the rectangle as a double.
+ *
+ * @see java.awt.geom.RectangularShape#getWidth()
+ */
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+ /**
+ * Determines whether or not the rectangle is empty. The rectangle is empty if
+ * its width or height is negative or zero.
+ *
+ * @return true, if the rectangle is empty, otherwise false.
+ *
+ * @see java.awt.geom.RectangularShape#isEmpty()
+ */
+ @Override
+ public boolean isEmpty() {
+ return width <= 0 || height <= 0;
+ }
+
+ /**
+ * Gets the size of a Rectangle as Dimention object.
+ *
+ * @return a Dimention object which represents size of the rectangle.
+ */
+ public Dimension getSize() {
+ return new Dimension(width, height);
+ }
+
+ /**
+ * Sets the size of the Rectangle.
+ *
+ * @param width the new width of the rectangle.
+ * @param height the new height of the rectangle.
+ */
+ public void setSize(int width, int height) {
+ this.width = width;
+ this.height = height;
+ }
+
+ /**
+ * Sets the size of a Rectangle specified as Dimension object.
+ *
+ * @param d a Dimension object which represents new size of a rectangle.
+ */
+ public void setSize(Dimension d) {
+ setSize(d.width, d.height);
+ }
+
+ /**
+ * Gets the location of a rectangle's upper left corner as a Point object.
+ *
+ * @return the Point object with coordinates equal to the upper left corner
+ * of the rectangle.
+ */
+ public Point getLocation() {
+ return new Point(x, y);
+ }
+
+ /**
+ * Sets the location of the rectangle in terms of its upper left
+ * corner coordinates X and Y.
+ *
+ * @param x the X coordinate of the rectangle's upper left corner.
+ * @param y the Y coordinate of the rectangle's upper left corner.
+ */
+ public void setLocation(int x, int y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ /**
+ * Sets the location of a rectangle using a Point object to give the
+ * coordinates of the upper left corner.
+ *
+ * @param p the Point object which represents the new upper left corner
+ * coordinates of rectangle.
+ */
+ public void setLocation(Point p) {
+ setLocation(p.x, p.y);
+ }
+
+ /**
+ * Moves a rectangle to the new location by moving its upper left corner
+ * to the point with coordinates X and Y.
+ *
+ * @param x the new X coordinate of the rectangle's upper left corner.
+ * @param y the new Y coordinate of the rectangle's upper left corner.
+ *
+ * @deprecated Use setLocation(int, int) method.
+ */
+ @Deprecated
+ public void move(int x, int y) {
+ setLocation(x, y);
+ }
+
+ /**
+ * Sets the rectangle to be the nearest rectangle with integer coordinates
+ * bounding the rectangle defined by the double-valued parameters.
+ *
+ * @param x the X coordinate of the upper left corner of the double-valued
+ * rectangle to be bounded.
+ * @param y the Y coordinate of the upper left corner of the double-valued
+ * rectangle to be bounded.
+ * @param width the width of the rectangle to be bounded.
+ * @param height the height of the rectangle to be bounded.
+ *
+ * @see java.awt.geom.Rectangle2D#setRect(double, double, double, double)
+ */
+ @Override
+ public void setRect(double x, double y, double width, double height) {
+ int x1 = (int)Math.floor(x);
+ int y1 = (int)Math.floor(y);
+ int x2 = (int)Math.ceil(x + width);
+ int y2 = (int)Math.ceil(y + height);
+ setBounds(x1, y1, x2 - x1, y2 - y1);
+ }
+
+ /**
+ * Sets a new size for the rectangle.
+ *
+ * @param width the rectangle's new width.
+ * @param height the rectangle's new height.
+ *
+ * @deprecated use the setSize(int, int) method.
+ */
+ @Deprecated
+ public void resize(int width, int height) {
+ setBounds(x, y, width, height);
+ }
+
+ /**
+ * Resets the bounds of a rectangle to the specified x, y, width and height
+ * parameters.
+ *
+ * @param x the new X coordinate of the upper left corner.
+ * @param y the new Y coordinate of the upper left corner.
+ * @param width the new width of rectangle.
+ * @param height the new height of rectangle.
+ *
+ * @deprecated use setBounds(int, int, int, int) method
+ */
+ @Deprecated
+ public void reshape(int x, int y, int width, int height) {
+ setBounds(x, y, width, height);
+ }
+
+ /**
+ * Gets bounds of the rectangle as a new Rectangle object.
+ *
+ * @return the Rectangle object with the same bounds as
+ * the original rectangle.
+ *
+ * @see java.awt.geom.RectangularShape#getBounds()
+ */
+ @Override
+ public Rectangle getBounds() {
+ return new Rectangle(x, y, width, height);
+ }
+
+ /**
+ * Gets the bounds of the original rectangle as a Rectangle2D object.
+ *
+ * @return the Rectangle2D object which represents the bounds of
+ * the original rectangle.
+ *
+ * @see java.awt.geom.Rectangle2D#getBounds2D()
+ */
+ @Override
+ public Rectangle2D getBounds2D() {
+ return getBounds();
+ }
+
+ /**
+ * Sets the bounds of a rectangle to the specified x, y, width, and height
+ * parameters.
+ *
+ * @param x the X coordinate of the upper left corner.
+ * @param y the Y coordinate of the upper left corner.
+ * @param width the width of rectangle.
+ * @param height the height of rectangle.
+ */
+ public void setBounds(int x, int y, int width, int height) {
+ this.x = x;
+ this.y = y;
+ this.height = height;
+ this.width = width;
+ }
+
+ /**
+ * Sets the bounds of the rectangle to match the bounds of the
+ * Rectangle object sent as a parameter.
+ *
+ * @param r the Rectangle object which specifies the new bounds.
+ */
+ public void setBounds(Rectangle r) {
+ setBounds(r.x, r.y, r.width, r.height);
+ }
+
+ /**
+ * Enlarges the rectangle by moving each corner outward from the
+ * center by a distance of dx horizonally and a distance of dy
+ * vertically. Specifically, changes a rectangle with
+ * [x, y, width, height] parameters to
+ * a rectangle with [x-dx, y-dy, width+2*dx, height+2*dy]
+ * parameters.
+ *
+ * @param dx the horizontal distance to move each corner coordinate.
+ * @param dy the vertical distance to move each corner coordinate.
+ */
+ public void grow(int dx, int dy) {
+ x -= dx;
+ y -= dy;
+ width += dx + dx;
+ height += dy + dy;
+ }
+
+ /**
+ * Moves a rectangle a distance of mx along the x coordinate axis
+ * and a distance of my along y coordinate axis.
+ *
+ * @param mx the horizontal translation increment.
+ * @param my the vertical translation increment.
+ */
+ public void translate(int mx, int my) {
+ x += mx;
+ y += my;
+ }
+
+ /**
+ * Enlarges the rectangle to cover the specified point.
+ *
+ * @param px the X coordinate of the new point to be covered by the rectangle.
+ * @param py the Y coordinate of the new point to be covered by the rectangle.
+ */
+ public void add(int px, int py) {
+ int x1 = Math.min(x, px);
+ int x2 = Math.max(x + width, px);
+ int y1 = Math.min(y, py);
+ int y2 = Math.max(y + height, py);
+ setBounds(x1, y1, x2 - x1, y2 - y1);
+ }
+
+ /**
+ * Enlarges the rectangle to cover the specified point with the
+ * new point given as a Point object.
+ *
+ * @param p the Point object that specifies the new point to
+ * be covered by the rectangle.
+ */
+ public void add(Point p) {
+ add(p.x, p.y);
+ }
+
+ /**
+ * Adds a new rectangle to the original rectangle, the result is an union of
+ * the specified specified rectangle and original rectangle.
+ *
+ * @param r the Rectangle which is added to the original rectangle.
+ */
+ public void add(Rectangle r) {
+ int x1 = Math.min(x, r.x);
+ int x2 = Math.max(x + width, r.x + r.width);
+ int y1 = Math.min(y, r.y);
+ int y2 = Math.max(y + height, r.y + r.height);
+ setBounds(x1, y1, x2 - x1, y2 - y1);
+ }
+
+ /**
+ * Determines whether or not the point with specified coordinates [px, py]
+ * is within the bounds of the rectangle.
+ *
+ * @param px the X coordinate of point.
+ * @param py the Y coordinate of point.
+ *
+ * @return true, if the point with specified coordinates [px, py] is
+ * within the bounds of the rectangle, otherwise false.
+ */
+ public boolean contains(int px, int py) {
+ if (isEmpty()) {
+ return false;
+ }
+ if (px < x || py < y) {
+ return false;
+ }
+ px -= x;
+ py -= y;
+ return px < width && py < height;
+ }
+
+ /**
+ * Determines whether or not the point given as a Point object
+ * is within the bounds of the rectangle.
+ *
+ * @param p the Point object
+ *
+ * @return true, if the point p is within the bounds of the
+ * rectangle, otherwise false.
+ */
+ public boolean contains(Point p) {
+ return contains(p.x, p.y);
+ }
+
+ /**
+ * Determines whether or not the rectangle specified by [rx, ry, rw, rh]
+ * parameters is located inside the original rectangle.
+ *
+ * @param rx the X coordinate of the rectangle to compare.
+ * @param ry the Y coordinate of the rectangle to compare.
+ * @param rw the width of the rectangle to compare.
+ * @param rh the height of the rectangle to compare.
+ *
+ * @return true, if a rectangle with [rx, ry, rw, rh] parameters is entirely
+ * contained in the original rectangle, otherwise false.
+ */
+ public boolean contains(int rx, int ry, int rw, int rh) {
+ return contains(rx, ry) && contains(rx + rw - 1, ry + rh - 1);
+ }
+
+ /**
+ * Compares whether or not the rectangle specified by the Rectangle object
+ * is located inside the original rectangle.
+ *
+ * @param r the Rectangle object.
+ *
+ * @return true, if the rectangle specified by Rectangle object is entirely
+ * contained in the original rectangle, otherwise false.
+ */
+ public boolean contains(Rectangle r) {
+ return contains(r.x, r.y, r.width, r.height);
+ }
+
+ /**
+ * Compares whether or not a point with specified coordinates [px, py] belongs
+ * to a rectangle.
+ *
+ * @param px the X coordinate of a point.
+ * @param py the Y coordinate of a point.
+ *
+ * @return true, if a point with specified coordinates [px, py] belongs
+ * to a rectangle, otherwise false.
+ *
+ * @deprecated use contains(int, int) method.
+ */
+ @Deprecated
+ public boolean inside(int px, int py) {
+ return contains(px, py);
+ }
+
+ /**
+ * Returns the intersection of the original rectangle with the
+ * specified Rectangle2D.
+ *
+ * @param r the Rectangle2D object.
+ *
+ * @return the Rectangle2D object that is the result of intersecting
+ * the original rectangle with the specified Rectangle2D.
+ *
+ * @see java.awt.geom.Rectangle2D#createIntersection(java.awt.geom.Rectangle2D)
+ */
+ @Override
+ public Rectangle2D createIntersection(Rectangle2D r) {
+ if (r instanceof Rectangle) {
+ return intersection((Rectangle) r);
+ }
+ Rectangle2D dst = new Rectangle2D.Double();
+ Rectangle2D.intersect(this, r, dst);
+ return dst;
+ }
+
+ /**
+ * Returns the intersection of the original rectangle with the
+ * specified rectangle. An empty rectangle is returned if there is no
+ * intersection.
+ *
+ * @param r the Rectangle object.
+ *
+ * @return the Rectangle object is result of the original rectangle with the
+ * specified rectangle.
+ */
+ public Rectangle intersection(Rectangle r) {
+ int x1 = Math.max(x, r.x);
+ int y1 = Math.max(y, r.y);
+ int x2 = Math.min(x + width, r.x + r.width);
+ int y2 = Math.min(y + height, r.y + r.height);
+ return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+ }
+
+ /**
+ * Determines whether or not the original rectangle intersects
+ * the specified rectangle.
+ *
+ * @param r the Rectangle object.
+ *
+ * @return true, if the two rectangles overlap; otherwise false.
+ */
+ public boolean intersects(Rectangle r) {
+ return !intersection(r).isEmpty();
+ }
+
+ /**
+ * Determines where the specified Point is located with respect to
+ * the rectangle. This method computes whether the point is to the
+ * right or to the left of the rectangle and whether it is above
+ * or below the rectangle, and packs the result into an int by
+ * using a binary OR operation with the following masks:
+ * <ul>
+ *<li>Rectangle2D.OUT_LEFT</li>
+ *<li>Rectangle2D.OUT_TOP</li>
+ *<li>Rectangle2D.OUT_RIGHT</li>
+ *<li>Rectangle2D.OUT_BOTTOM</li>
+ *</ul>
+ *
+ * If the rectangle is empty, all masks are set, and if the
+ * point is inside the rectangle, none are set.
+ *
+ * @param px the X coordinate of the specified point.
+ * @param py the Y coordinate of the specified point.
+ *
+ * @return the location of the Point relative to the rectangle
+ * as the result of logical OR operation with all out masks.
+ *
+ * @see java.awt.geom.Rectangle2D#outcode(double, double)
+ */
+ @Override
+ public int outcode(double px, double py) {
+ int code = 0;
+
+ if (width <= 0) {
+ code |= OUT_LEFT | OUT_RIGHT;
+ } else
+ if (px < x) {
+ code |= OUT_LEFT;
+ } else
+ if (px > x + width) {
+ code |= OUT_RIGHT;
+ }
+
+ if (height <= 0) {
+ code |= OUT_TOP | OUT_BOTTOM;
+ } else
+ if (py < y) {
+ code |= OUT_TOP;
+ } else
+ if (py > y + height) {
+ code |= OUT_BOTTOM;
+ }
+
+ return code;
+ }
+
+ /**
+ * Enlarges the rectangle to cover the specified Rectangle2D.
+ *
+ * @param r the Rectangle2D object.
+ *
+ * @return the union of the original and the specified Rectangle2D.
+ *
+ * @see java.awt.geom.Rectangle2D#createUnion(java.awt.geom.Rectangle2D)
+ */
+ @Override
+ public Rectangle2D createUnion(Rectangle2D r) {
+ if (r instanceof Rectangle) {
+ return union((Rectangle)r);
+ }
+ Rectangle2D dst = new Rectangle2D.Double();
+ Rectangle2D.union(this, r, dst);
+ return dst;
+ }
+
+ /**
+ * Enlarges the rectangle to cover the specified rectangle.
+ *
+ * @param r the Rectangle.
+ *
+ * @return the union of the original and the specified rectangle.
+ */
+ public Rectangle union(Rectangle r) {
+ Rectangle dst = new Rectangle(this);
+ dst.add(r);
+ return dst;
+ }
+
+ /**
+ * Compares the original Rectangle with the specified object.
+ *
+ * @param obj the specified Object for comparison.
+ *
+ * @return true, if the specified Object is a rectangle with the
+ * same dimensions as the original rectangle, otherwise false.
+ *
+ * @see java.awt.geom.Rectangle2D#equals(Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (obj instanceof Rectangle) {
+ Rectangle r = (Rectangle)obj;
+ return r.x == x && r.y == y && r.width == width && r.height == height;
+ }
+ return false;
+ }
+
+ /**
+ * Returns a string representation of the rectangle; the string contains
+ * [x, y, width, height] parameters of the rectangle.
+ *
+ * @return the string representation of the rectangle.
+ */
+ @Override
+ public String toString() {
+ // The output format based on 1.5 release behaviour. It could be obtained in the following way
+ // System.out.println(new Rectangle().toString())
+ return getClass().getName() + "[x=" + x + ",y=" + y + //$NON-NLS-1$ //$NON-NLS-2$
+ ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+}
+
diff --git a/awt/java/awt/RenderingHints.java b/awt/java/awt/RenderingHints.java
new file mode 100644
index 0000000..4957884
--- /dev/null
+++ b/awt/java/awt/RenderingHints.java
@@ -0,0 +1,601 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * The RenderingHints class represents preferences for the rendering algorithms.
+ * The preferences are arbitrary and can be specified by Map objects or by
+ * key-value pairs.
+ */
+public class RenderingHints implements Map<Object, Object>, Cloneable {
+
+ /**
+ * The Constant KEY_ALPHA_INTERPOLATION - alpha interpolation rendering
+ * hint key.
+ */
+ public static final Key KEY_ALPHA_INTERPOLATION = new KeyImpl(1);
+
+ /**
+ * The Constant VALUE_ALPHA_INTERPOLATION_DEFAULT - alpha interpolation
+ * rendering hint value.
+ */
+ public static final Object VALUE_ALPHA_INTERPOLATION_DEFAULT = new KeyValue(KEY_ALPHA_INTERPOLATION);
+
+ /**
+ * The Constant VALUE_ALPHA_INTERPOLATION_SPEED - alpha interpolation
+ * rendering hint value.
+ */
+ public static final Object VALUE_ALPHA_INTERPOLATION_SPEED = new KeyValue(KEY_ALPHA_INTERPOLATION);
+
+ /**
+ * The Constant VALUE_ALPHA_INTERPOLATION_QUALITY - alpha interpolation
+ * rendering hint value.
+ */
+ public static final Object VALUE_ALPHA_INTERPOLATION_QUALITY = new KeyValue(KEY_ALPHA_INTERPOLATION);
+
+ /**
+ * The Constant KEY_ANTIALIASING - antialiasing rendering
+ * hint key.
+ */
+ public static final Key KEY_ANTIALIASING = new KeyImpl(2);
+
+ /**
+ * The Constant VALUE_ANTIALIAS_DEFAULT - antialiasing
+ * rendering hint value.
+ */
+ public static final Object VALUE_ANTIALIAS_DEFAULT = new KeyValue(KEY_ANTIALIASING);
+
+ /**
+ * The Constant VALUE_ANTIALIAS_ON - antialiasing
+ * rendering hint value.
+ */
+ public static final Object VALUE_ANTIALIAS_ON = new KeyValue(KEY_ANTIALIASING);
+
+ /**
+ * The Constant VALUE_ANTIALIAS_OFF - antialiasing
+ * rendering hint value.
+ */
+ public static final Object VALUE_ANTIALIAS_OFF = new KeyValue(KEY_ANTIALIASING);
+
+ /**
+ * The Constant KEY_COLOR_RENDERING - color rendering
+ * hint key.
+ */
+ public static final Key KEY_COLOR_RENDERING = new KeyImpl(3);
+
+ /**
+ * The Constant VALUE_COLOR_RENDER_DEFAULT - color
+ * rendering hint value.
+ */
+ public static final Object VALUE_COLOR_RENDER_DEFAULT = new KeyValue(KEY_COLOR_RENDERING);
+
+ /**
+ * The Constant VALUE_COLOR_RENDER_SPEED - color
+ * rendering hint value.
+ */
+ public static final Object VALUE_COLOR_RENDER_SPEED = new KeyValue(KEY_COLOR_RENDERING);
+
+ /**
+ * The Constant VALUE_COLOR_RENDER_QUALITY - color
+ * rendering hint value.
+ */
+ public static final Object VALUE_COLOR_RENDER_QUALITY = new KeyValue(KEY_COLOR_RENDERING);
+
+ /**
+ * The Constant KEY_DITHERING - dithering
+ * rendering hint key.
+ */
+ public static final Key KEY_DITHERING = new KeyImpl(4);
+
+ /**
+ * The Constant VALUE_DITHER_DEFAULT - dithering
+ * rendering hint value.
+ */
+ public static final Object VALUE_DITHER_DEFAULT = new KeyValue(KEY_DITHERING);
+
+ /**
+ * The Constant VALUE_DITHER_DISABLE - dithering
+ * rendering hint value.
+ */
+ public static final Object VALUE_DITHER_DISABLE = new KeyValue(KEY_DITHERING);
+
+ /**
+ * The Constant VALUE_DITHER_DISABLE - dithering
+ * rendering hint value.
+ */
+ public static final Object VALUE_DITHER_ENABLE = new KeyValue(KEY_DITHERING);
+
+ /**
+ * The Constant KEY_FRACTIONALMETRICS - fractional metrics
+ * rendering hint key.
+ */
+ public static final Key KEY_FRACTIONALMETRICS = new KeyImpl(5);
+
+ /**
+ * The Constant VALUE_FRACTIONALMETRICS_DEFAULT - fractional metrics
+ * rendering hint value.
+ */
+ public static final Object VALUE_FRACTIONALMETRICS_DEFAULT = new KeyValue(KEY_FRACTIONALMETRICS);
+
+ /**
+ * The Constant VALUE_FRACTIONALMETRICS_ON - fractional metrics
+ * rendering hint value.
+ */
+ public static final Object VALUE_FRACTIONALMETRICS_ON = new KeyValue(KEY_FRACTIONALMETRICS);
+
+ /**
+ * The Constant VALUE_FRACTIONALMETRICS_OFF - fractional metrics
+ * rendering hint value.
+ */
+ public static final Object VALUE_FRACTIONALMETRICS_OFF = new KeyValue(KEY_FRACTIONALMETRICS);
+
+ /**
+ * The Constant KEY_INTERPOLATION - interpolation
+ * rendering hint key.
+ */
+ public static final Key KEY_INTERPOLATION = new KeyImpl(6);
+
+ /**
+ * The Constant VALUE_INTERPOLATION_BICUBIC - interpolation
+ * rendering hint value.
+ */
+ public static final Object VALUE_INTERPOLATION_BICUBIC = new KeyValue(KEY_INTERPOLATION);
+
+ /**
+ * The Constant VALUE_INTERPOLATION_BILINEAR - interpolation
+ * rendering hint value.
+ */
+ public static final Object VALUE_INTERPOLATION_BILINEAR = new KeyValue(KEY_INTERPOLATION);
+
+ /** The Constant VALUE_INTERPOLATION_NEAREST_NEIGHBOR - interpolation
+ * rendering hint value.
+ */
+ public static final Object VALUE_INTERPOLATION_NEAREST_NEIGHBOR = new KeyValue(KEY_INTERPOLATION);
+
+ /**
+ * The Constant KEY_RENDERING - rendering hint key.
+ */
+ public static final Key KEY_RENDERING = new KeyImpl(7);
+
+ /**
+ * The Constant VALUE_RENDER_DEFAULT - rendering hint value.
+ */
+ public static final Object VALUE_RENDER_DEFAULT = new KeyValue(KEY_RENDERING);
+
+ /**
+ * The Constant VALUE_RENDER_SPEED - rendering hint value.
+ */
+ public static final Object VALUE_RENDER_SPEED = new KeyValue(KEY_RENDERING);
+
+ /**
+ * The Constant VALUE_RENDER_QUALITY - rendering hint value.
+ */
+ public static final Object VALUE_RENDER_QUALITY = new KeyValue(KEY_RENDERING);
+
+ /**
+ * The Constant KEY_STROKE_CONTROL - stroke control hint key.
+ */
+ public static final Key KEY_STROKE_CONTROL = new KeyImpl(8);
+
+ /**
+ * The Constant VALUE_STROKE_DEFAULT - stroke hint value.
+ */
+ public static final Object VALUE_STROKE_DEFAULT = new KeyValue(KEY_STROKE_CONTROL);
+
+ /**
+ * The Constant VALUE_STROKE_NORMALIZE - stroke hint value.
+ */
+ public static final Object VALUE_STROKE_NORMALIZE = new KeyValue(KEY_STROKE_CONTROL);
+
+ /**
+ * The Constant VALUE_STROKE_PURE - stroke hint value.
+ */
+ public static final Object VALUE_STROKE_PURE = new KeyValue(KEY_STROKE_CONTROL);
+
+ /**
+ * The Constant KEY_TEXT_ANTIALIASING - text antialiasing hint key.
+ */
+ public static final Key KEY_TEXT_ANTIALIASING = new KeyImpl(9);
+
+ /**
+ * The Constant VALUE_TEXT_ANTIALIAS_DEFAULT - text antialiasing hint key.
+ */
+ public static final Object VALUE_TEXT_ANTIALIAS_DEFAULT = new KeyValue(KEY_TEXT_ANTIALIASING);
+
+ /**
+ * The Constant VALUE_TEXT_ANTIALIAS_ON - text antialiasing hint key.
+ */
+ public static final Object VALUE_TEXT_ANTIALIAS_ON = new KeyValue(KEY_TEXT_ANTIALIASING);
+
+ /**
+ * The Constant VALUE_TEXT_ANTIALIAS_OFF - text antialiasing hint key.
+ */
+ public static final Object VALUE_TEXT_ANTIALIAS_OFF = new KeyValue(KEY_TEXT_ANTIALIASING);
+
+ /** The map. */
+ private HashMap<Object, Object> map = new HashMap<Object, Object>();
+
+ /**
+ * Instantiates a new rendering hints object from specified Map object with defined
+ * key/value pairs or null for empty RenderingHints.
+ *
+ * @param map the Map object with defined key/value pairs or null for
+ * empty RenderingHints.
+ */
+ public RenderingHints(Map<Key, ?> map) {
+ super();
+ if (map != null) {
+ putAll(map);
+ }
+ }
+
+ /**
+ * Instantiates a new rendering hints object with the specified key/value pair.
+ *
+ * @param key the key of hint property.
+ * @param value the value of hint property.
+ */
+ public RenderingHints(Key key, Object value) {
+ super();
+ put(key, value);
+ }
+
+ /**
+ * Adds the properties represented by key/value pairs from the specified
+ * RenderingHints object to current object.
+ *
+ * @param hints the RenderingHints to be added.
+ */
+ public void add(RenderingHints hints) {
+ map.putAll(hints.map);
+ }
+
+ /**
+ * Puts the specified value to the specified key. Neither the key nor
+ * the value can be null.
+ *
+ * @param key the rendering hint key.
+ * @param value the rendering hint value.
+ *
+ * @return the previous rendering hint value assigned to the key or null.
+ *
+ */
+ public Object put(Object key, Object value) {
+ if (!((Key)key).isCompatibleValue(value)) {
+ throw new IllegalArgumentException();
+ }
+
+ return map.put(key, value);
+ }
+
+ /**
+ * Removes the specified key and corresponding value from
+ * the RenderingHints object.
+ *
+ * @param key the specified hint key to be removed.
+ *
+ * @return the object of previous rendering hint value which is
+ * assigned to the specified key, or null.
+ */
+ public Object remove(Object key) {
+ return map.remove(key);
+ }
+
+ /**
+ * Gets the value assigned to the specified key.
+ *
+ * @param key the rendering hint key.
+ *
+ * @return the object assigned to the specified key.
+ */
+ public Object get(Object key) {
+ return map.get(key);
+ }
+
+ /**
+ * Returns a set of rendering hints keys for current RenderingHints object.
+ *
+ * @return the set of rendering hints keys.
+ */
+ public Set<Object> keySet() {
+ return map.keySet();
+ }
+
+ /**
+ * Returns a set of Map.Entry objects which contain current RenderingHint
+ * key/value pairs.
+ *
+ * @return the a set of mapped RenderingHint key/value pairs.
+ */
+ public Set<Map.Entry<Object, Object>> entrySet() {
+ return map.entrySet();
+ }
+
+ /**
+ * Puts all of the preferences from the specified Map into
+ * the current RenderingHints object. These mappings replace
+ * all existing preferences.
+ *
+ * @param m the specified Map of preferences.
+ */
+ public void putAll(Map<?, ?> m) {
+ if (m instanceof RenderingHints) {
+ map.putAll(((RenderingHints) m).map);
+ } else {
+ Set<?> entries = m.entrySet();
+
+ if (entries != null){
+ Iterator<?> it = entries.iterator();
+ while (it.hasNext()) {
+ Map.Entry<?, ?> entry = (Map.Entry<?, ?>) it.next();
+ Key key = (Key) entry.getKey();
+ Object val = entry.getValue();
+ put(key, val);
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns a Collection of values contained in current RenderingHints object.
+ *
+ * @return the Collection of RenderingHints's values.
+ */
+ public Collection<Object> values() {
+ return map.values();
+ }
+
+ /**
+ * Checks whether or not current RenderingHints object contains at least one
+ * the value which is equal to the specified Object.
+ *
+ * @param value the specified Object.
+ *
+ * @return true, if the specified object is assigned to at least one
+ * RenderingHint's key, false otherwise.
+ */
+ public boolean containsValue(Object value) {
+ return map.containsValue(value);
+ }
+
+ /**
+ * Checks whether or not current RenderingHints object contains the key
+ * which is equal to the specified Object.
+ *
+ * @param key the specified Object.
+ *
+ * @return true, if the RenderingHints object contains the specified Object
+ * as a key, false otherwise.
+ *
+ */
+ public boolean containsKey(Object key) {
+ if (key == null) {
+ throw new NullPointerException();
+ }
+
+ return map.containsKey(key);
+ }
+
+ /**
+ * Checks whether or not the RenderingHints object contains any
+ * key/value pairs.
+ *
+ * @return true, if the RenderingHints object is empty, false otherwise.
+ */
+ public boolean isEmpty() {
+ return map.isEmpty();
+ }
+
+ /**
+ * Clears the RenderingHints of all key/value pairs.
+ */
+ public void clear() {
+ map.clear();
+ }
+
+ /**
+ * Returns the number of key/value pairs in the RenderingHints.
+ *
+ * @return the number of key/value pairs.
+ */
+ public int size() {
+ return map.size();
+ }
+
+ /**
+ * Compares the RenderingHints object with the specified object.
+ *
+ * @param o the specified Object to be compaired.
+ *
+ * @return true, if the Object is a Map whose key/value pairs
+ * match this RenderingHints' key/value pairs,
+ * false otherwise.
+ */
+ @Override
+ public boolean equals(Object o) {
+ if (!(o instanceof Map)) {
+ return false;
+ }
+
+ Map<?, ?> m = (Map<?, ?>)o;
+ Set<?> keys = keySet();
+ if (!keys.equals(m.keySet())) {
+ return false;
+ }
+
+ Iterator<?> it = keys.iterator();
+ while (it.hasNext()) {
+ Key key = (Key)it.next();
+ Object v1 = get(key);
+ Object v2 = m.get(key);
+ if (!(v1==null?v2==null:v1.equals(v2))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Returns the hash code for this RenderingHints object.
+ *
+ * @return the hash code for this RenderingHints object.
+ */
+ @Override
+ public int hashCode() {
+ return map.hashCode();
+ }
+
+ /**
+ * Returns the clone of the RenderingHints object with the same contents.
+ *
+ * @return the clone of the RenderingHints instance.
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public Object clone() {
+ RenderingHints clone = new RenderingHints(null);
+ clone.map = (HashMap<Object, Object>)this.map.clone();
+ return clone;
+ }
+
+ /**
+ * Returns the string representation of the RenderingHints object.
+ *
+ * @return the String object which represents RenderingHints object.
+ */
+ @Override
+ public String toString() {
+ return "RenderingHints["+map.toString()+"]"; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ /**
+ * The RenderingHints.Key class is abstract and defines a base type for
+ * all RenderingHints keys.
+ */
+ public abstract static class Key {
+
+ /** The key. */
+ private final int key;
+
+ /**
+ * Instantiates a new key with unique int identifier.
+ * No two objects of the same subclass with the same integer key
+ * can be instantiated.
+ *
+ * @param key the unique key.
+ */
+ protected Key(int key) {
+ this.key = key;
+ }
+
+ /**
+ * Compares the Key object with the specified object.
+ *
+ * @param o the specified Object to be compaired.
+ *
+ * @return true, if the Key is equal to the specified object,
+ * false otherwise.
+ */
+ @Override
+ public final boolean equals(Object o) {
+ return this == o;
+ }
+
+ /**
+ * Returns the hash code for this Key object.
+ *
+ * @return the hash code for this Key object.
+ */
+ @Override
+ public final int hashCode() {
+ return System.identityHashCode(this);
+ }
+
+ /**
+ * Returns int unique key with which this Key object has been
+ * instantiated.
+ *
+ * @return the int unique key with which this Key object has been
+ * instantiated.
+ */
+ protected final int intKey() {
+ return key;
+ }
+
+ /**
+ * Checks whether or not specified value is compatible with the Key.
+ *
+ * @param val the Object.
+ *
+ * @return true, if the specified value is compatible with the Key,
+ * false otherwise.
+ */
+ public abstract boolean isCompatibleValue(Object val);
+ }
+
+ /**
+ * Private implementation of Key class.
+ */
+ private static class KeyImpl extends Key {
+
+ /**
+ * Instantiates a new key impl.
+ *
+ * @param key the key
+ */
+ protected KeyImpl(int key) {
+ super(key);
+ }
+
+ @Override
+ public boolean isCompatibleValue(Object val) {
+ if (!(val instanceof KeyValue)) {
+ return false;
+ }
+
+ return ((KeyValue)val).key == this;
+ }
+ }
+
+ /**
+ * Private class KeyValue is used as value for Key class instance.
+ */
+ private static class KeyValue {
+
+ /** The key. */
+ private final Key key;
+
+ /**
+ * Instantiates a new key value.
+ *
+ * @param key the key
+ */
+ protected KeyValue(Key key) {
+ this.key = key;
+ }
+ }
+}
diff --git a/awt/java/awt/Shape.java b/awt/java/awt/Shape.java
new file mode 100644
index 0000000..3dbad25
--- /dev/null
+++ b/awt/java/awt/Shape.java
@@ -0,0 +1,162 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.PathIterator;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * The Shape interface defines a geometric shape defined by a boundary
+ * (outline) path. The path outline can be accessed through a
+ * PathIterator object. The Shape
+ * interface provides methods for obtaining the bounding box (which is
+ * the smallest rectangle containing the shape and for obtaining a PathIterator
+ * object for current Shape, as well as utility methods which
+ * determine if the Shape contains or intersects a Rectangle or contains a Point.
+ */
+public interface Shape {
+
+ /**
+ * Checks whether or not the point with specified coordinates lies inside
+ * the Shape.
+ *
+ * @param x the X coordinate.
+ * @param y the Y coordinate.
+ *
+ * @return true, if the specified coordinates lie inside the Shape,
+ * otherwise false.
+ */
+ public boolean contains(double x, double y);
+
+ /**
+ * Checks whether or not the rectangle with specified
+ * [x, y, width, height] parameters lies inside the Shape.
+ *
+ * @param x the X double coordinate of the rectangle's upper left
+ * corner.
+ * @param y the Y double coordinate of the rectangle's upper left
+ * corner.
+ * @param w the width of rectangle.
+ * @param h the height of rectangle.
+ *
+ * @return true, if the specified rectangle lies inside the Shape,
+ * otherwise false.
+ */
+ public boolean contains(double x, double y, double w, double h);
+
+ /**
+ * Checks whether or not the specified Point2D lies inside the Shape.
+ *
+ * @param point the Point2D object.
+ *
+ * @return true, if the specified Point2D lies inside the Shape,
+ * otherwise false.
+ */
+ public boolean contains(Point2D point);
+
+ /**
+ * Checks whether or not the specified rectangle lies inside the Shape.
+ *
+ * @param r the Rectangle2D object.
+ *
+ * @return true, if the specified rectangle lies inside the Shape,
+ * otherwise false.
+ */
+ public boolean contains(Rectangle2D r);
+
+ /**
+ * Gets the bounding rectangle of the Shape. The bounding rectangle
+ * is the smallest rectangle which contains the Shape.
+ *
+ * @return the bounding rectangle of the Shape.
+ */
+ public Rectangle getBounds();
+
+ /**
+ * Gets the Rectangle2D which represents Shape bounds.
+ * The bounding rectangle is the smallest rectangle which contains
+ * the Shape.
+ *
+ * @return the bounding rectangle of the Shape.
+ */
+ public Rectangle2D getBounds2D();
+
+ /**
+ * Gets the PathIterator object of the Shape which provides
+ * access to the shape's boundary modified
+ * by the specified AffineTransform.
+ *
+ * @param at the specified AffineTransform object, or null.
+ *
+ * @return PathIterator object for the Shape.
+ */
+ public PathIterator getPathIterator(AffineTransform at);
+
+ /**
+ * Gets the PathIterator object of the Shape which provides
+ * access to the coordinates of the shapes boundary modified
+ * by the specified AffineTransform. The flatness parameter
+ * defines the amount of subdivision of the curved segments and
+ * specifies the maximum distance which every point on the
+ * unflattened transformed curve can deviate from the returned
+ * flattened path segments.
+ *
+ * @param at the specified AffineTransform object, or null.
+ * @param flatness the maximum number of the control points for
+ * a given curve which varies from colinear before a subdivided
+ * curve is replaced by a straight line connecting the endpoints.
+ *
+ * @return PathIterator object for the Shape.
+ */
+ public PathIterator getPathIterator(AffineTransform at, double flatness);
+
+ /**
+ * Checks whether or not the interior of rectangular specified by
+ * [x, y, width, height] parameters intersects the interior of
+ * the Shape.
+ *
+ * @param x the X double coordinate of the rectangle's upper left
+ * corner.
+ * @param y the Y double coordinate of the rectangle's upper left
+ * corner.
+ * @param w the width of rectangle.
+ * @param h the height of rectangle.
+ *
+ * @return true, if the rectangle specified by
+ * [x, y, width, height] parameters intersects the interior of
+ * the Shape, otherwise false.
+ *
+ */
+ public boolean intersects(double x, double y, double w, double h);
+
+ /**
+ * Checks whether or not the interior of rectangl specified by
+ * Rectangle2D object intersects the interior of the Shape.
+ *
+ * @param r the Rectangle2D object.
+ *
+ * @return true, if the Rectangle2D intersects the interior of
+ * the Shape, otherwise false.
+ */
+ public boolean intersects(Rectangle2D r);
+}
diff --git a/awt/java/awt/Stroke.java b/awt/java/awt/Stroke.java
new file mode 100644
index 0000000..e6d683d
--- /dev/null
+++ b/awt/java/awt/Stroke.java
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ * The Stroke interface gives a pen style to be used by the
+ * Graphics2D interface. It provides a means for getting a stroked version
+ * of a shape, which is the version that is suitable for drawing via
+ * the Graphics2D interface. Stroking a shape gives the shape's outline
+ * a width or drawing style.
+ * <p>
+ * The Draw methods from Graphics2D interface should use the Stroke object for
+ * rendering the shape's outline. The stroke should be set by
+ * setStroke(java.awt.Stroke) method of the Graphics2D interface.
+ * @see java.awt.Graphics2D#setStroke(java.awt.Stroke)
+ */
+public interface Stroke {
+
+ /**
+ * Creates the stroked shape, which is the version that is suitable for drawing via
+ * the Graphics2D interface. Stroking a shape gives the shape's outline
+ * a width or drawing style.
+ *
+ * @param p the original shape.
+ *
+ * @return the stroked shape.
+ */
+ public Shape createStrokedShape(Shape p);
+}
diff --git a/awt/java/awt/Toolkit.java b/awt/java/awt/Toolkit.java
new file mode 100644
index 0000000..0c066b2
--- /dev/null
+++ b/awt/java/awt/Toolkit.java
@@ -0,0 +1,1338 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+import java.awt.event.AWTEventListener;
+import java.awt.event.AWTEventListenerProxy;
+import java.awt.event.InputEvent;
+import java.awt.im.InputMethodHighlight;
+import java.awt.image.ColorModel;
+import java.awt.image.ImageObserver;
+import java.awt.image.ImageProducer;
+import java.awt.peer.FontPeer;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Collections;
+import java.util.EventListener;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.Properties;
+import java.util.ResourceBundle;
+
+import org.apache.harmony.awt.ChoiceStyle;
+import org.apache.harmony.awt.ComponentInternals;
+import org.apache.harmony.awt.ContextStorage;
+import org.apache.harmony.awt.ReadOnlyIterator;
+import org.apache.harmony.awt.internal.nls.Messages;
+import org.apache.harmony.awt.wtk.CreationParams;
+import org.apache.harmony.awt.wtk.GraphicsFactory;
+import org.apache.harmony.awt.wtk.NativeCursor;
+
+import org.apache.harmony.awt.wtk.NativeEventQueue;
+import org.apache.harmony.awt.wtk.NativeEventThread;
+import org.apache.harmony.awt.wtk.ShutdownWatchdog;
+import org.apache.harmony.awt.wtk.Synchronizer;
+import org.apache.harmony.awt.wtk.WTK;
+
+/**
+ * The Toolkit class is the representation of the platform-specific
+ * Abstract Window Toolkit implementation. Toolkit's subclasses
+ * are used to bind the various components to particular native
+ * toolkit implementations.
+ */
+public abstract class Toolkit {
+
+ /** The Constant RECOURCE_PATH. */
+ private static final String RECOURCE_PATH = "org.apache.harmony.awt.resources.AWTProperties"; //$NON-NLS-1$
+
+ /** The Constant properties. */
+ private static final ResourceBundle properties = loadResources(RECOURCE_PATH);
+
+ /** The dispatcher. */
+ Dispatcher dispatcher;
+
+ /** The system event queue core. */
+ private EventQueueCore systemEventQueueCore;
+
+ /** The dispatch thread. */
+ EventDispatchThread dispatchThread;
+
+ /** The native thread. */
+ NativeEventThread nativeThread;
+
+ /** The awt events manager. */
+ protected AWTEventsManager awtEventsManager;
+
+ /**
+ * The Class AWTTreeLock.
+ */
+ private class AWTTreeLock {
+ }
+
+ /** The awt tree lock. */
+ final Object awtTreeLock = new AWTTreeLock();
+
+ /** The synchronizer. */
+ private final Synchronizer synchronizer = ContextStorage.getSynchronizer();
+
+ /** The shutdown watchdog. */
+ final ShutdownWatchdog shutdownWatchdog = new ShutdownWatchdog();
+
+ /** The auto number. */
+ final AutoNumber autoNumber = new AutoNumber();
+
+ /** The event type lookup. */
+ final AWTEvent.EventTypeLookup eventTypeLookup = new AWTEvent.EventTypeLookup();
+
+ /** The b dynamic layout set. */
+ private boolean bDynamicLayoutSet = true;
+
+ /** The set of desktop properties that user set directly. */
+ private final HashSet<String> userPropSet = new HashSet<String>();
+
+ /** The desktop properties. */
+ protected Map<String, Object> desktopProperties;
+
+ /** The desktop props support. */
+ protected PropertyChangeSupport desktopPropsSupport;
+
+ /**
+ * For this component the native window is being created
+ * It is used in the callback-driven window creation
+ * (e.g. on Windows in the handler of WM_CREATE event)
+ * to establish the connection between this component
+ * and its native window.
+ */
+ private Object recentNativeWindowComponent;
+
+ /** The wtk. */
+ private WTK wtk;
+
+ /**
+ * The Class ComponentInternalsImpl.
+ */
+ protected final class ComponentInternalsImpl extends ComponentInternals {
+
+ /**
+ * Shutdown.
+ */
+ @Override
+ public void shutdown() {
+ dispatchThread.shutdown();
+ }
+
+ /**
+ * Sets the desktop property to the specified value and fires a property
+ * change event.
+ *
+ * @param name the name of property.
+ * @param value the new value of property.
+ */
+ @Override
+ public void setDesktopProperty(String name, Object value) {
+ Toolkit.this.setDesktopProperty(name, value);
+ }
+ }
+
+
+ /**
+ * A lot of methods must throw HeadlessException
+ * if <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>.
+ *
+ * @throws HeadlessException the headless exception
+ */
+ static void checkHeadless() throws HeadlessException {
+ if (GraphicsEnvironment.getLocalGraphicsEnvironment().isHeadlessInstance())
+ throw new HeadlessException();
+ }
+
+ /**
+ * Lock awt.
+ */
+ final void lockAWT() {
+ synchronizer.lock();
+ }
+
+ /**
+ * Static lock awt.
+ */
+ static final void staticLockAWT() {
+ ContextStorage.getSynchronizer().lock();
+ }
+
+ /**
+ * Unlock awt.
+ */
+ final void unlockAWT() {
+ synchronizer.unlock();
+ }
+
+ /**
+ * Static unlock awt.
+ */
+ static final void staticUnlockAWT() {
+ ContextStorage.getSynchronizer().unlock();
+ }
+
+ /**
+ * InvokeAndWait under AWT lock. W/o this method system can hang up.
+ * Added to support modality (Dialog.show() & PopupMenu.show()) from
+ * not event dispatch thread. Use in other cases is not recommended.
+ *
+ * Still can be called only for whole API methods that
+ * cannot be called from other classes API methods.
+ * Examples:
+ * show() for modal dialogs - correct, only user can call it,
+ * directly or through setVisible(true)
+ * setBounds() for components - incorrect, setBounds()
+ * can be called from layoutContainer()
+ * for layout managers
+ *
+ * @param runnable the runnable
+ *
+ * @throws InterruptedException the interrupted exception
+ * @throws InvocationTargetException the invocation target exception
+ */
+ final void unsafeInvokeAndWait(Runnable runnable) throws InterruptedException,
+ InvocationTargetException {
+ synchronizer.storeStateAndFree();
+ try {
+ EventQueue.invokeAndWait(runnable);
+ } finally {
+ synchronizer.lockAndRestoreState();
+ }
+ }
+
+ /**
+ * Gets the synchronizer.
+ *
+ * @return the synchronizer
+ */
+ final Synchronizer getSynchronizer() {
+ return synchronizer;
+ }
+
+ /**
+ * Gets the wTK.
+ *
+ * @return the wTK
+ */
+ final WTK getWTK() {
+ return wtk;
+ }
+
+ /**
+ * Gets the property with the specified key and default value.
+ * This method returns the defValue if the property is not found.
+ *
+ * @param propName the name of property.
+ * @param defVal the default value.
+ *
+ * @return the property value.
+ */
+ public static String getProperty(String propName, String defVal) {
+ if (propName == null) {
+ // awt.7D=Property name is null
+ throw new NullPointerException(Messages.getString("awt.7D")); //$NON-NLS-1$
+ }
+ staticLockAWT();
+ try {
+ String retVal = null;
+ if (properties != null) {
+ try {
+ retVal = properties.getString(propName);
+ } catch (MissingResourceException e) {
+ } catch (ClassCastException e) {
+ }
+ }
+ return (retVal == null) ? defVal : retVal;
+ } finally {
+ staticUnlockAWT();
+ }
+ }
+
+ /**
+ * Gets the default Toolkit.
+ *
+ * @return the default Toolkit
+ */
+ public static Toolkit getDefaultToolkit() {
+ synchronized (ContextStorage.getContextLock()) {
+ if (ContextStorage.shutdownPending()) {
+ return null;
+ }
+ Toolkit defToolkit = ContextStorage.getDefaultToolkit();
+ if (defToolkit != null) {
+ return defToolkit;
+ }
+ staticLockAWT();
+ try {
+ defToolkit = GraphicsEnvironment.isHeadless() ?
+ new HeadlessToolkit() : new ToolkitImpl();
+ ContextStorage.setDefaultToolkit(defToolkit);
+ return defToolkit;
+ } finally {
+ staticUnlockAWT();
+ }
+ //TODO: read system property named awt.toolkit
+ //and create an instance of the specified class,
+ //by default use ToolkitImpl
+ }
+ }
+
+ /**
+ * Gets the default Font.
+ *
+ * @return the derault Font for Toolkit.
+ */
+ Font getDefaultFont() {
+ return wtk.getSystemProperties().getDefaultFont();
+ }
+
+ /**
+ * Load resources.
+ *
+ * @param path the path
+ *
+ * @return the resource bundle
+ */
+ private static ResourceBundle loadResources(String path) {
+ try {
+ return ResourceBundle.getBundle(path);
+ } catch (MissingResourceException e) {
+ return null;
+ }
+ }
+
+ /**
+ * Gets the wTK class name.
+ *
+ * @return the wTK class name
+ */
+ private static String getWTKClassName() {
+ return "com.android.internal.awt.AndroidWTK";
+ }
+
+ /**
+ * Gets the component by id.
+ *
+ * @param id the id
+ *
+ * @return the component by id
+ */
+ Component getComponentById(long id) {
+ if (id == 0) {
+ return null;
+ }
+ return null;
+ }
+
+ /**
+ * Gets the GraphicsFactory.
+ *
+ * @return the GraphicsFactory object.
+ */
+ public GraphicsFactory getGraphicsFactory() {
+ return wtk.getGraphicsFactory();
+ }
+
+ /**
+ * Instantiates a new toolkit.
+ */
+ public Toolkit() {
+ init();
+ }
+
+ /**
+ * Inits AWT.
+ */
+ protected void init() {
+ lockAWT();
+ try {
+ ComponentInternals.setComponentInternals(new ComponentInternalsImpl());
+ new EventQueue(this); // create the system EventQueue
+ dispatcher = new Dispatcher(this);
+ final String className = getWTKClassName();
+ desktopProperties = new HashMap<String, Object>();
+ desktopPropsSupport = new PropertyChangeSupport(this);
+ awtEventsManager = new AWTEventsManager();
+ dispatchThread = new EventDispatchThread(this, dispatcher);
+ nativeThread = new NativeEventThread();
+ NativeEventThread.Init init = new NativeEventThread.Init() {
+ public WTK init() {
+ wtk = createWTK(className);
+ wtk.getNativeEventQueue().setShutdownWatchdog(shutdownWatchdog);
+ synchronizer.setEnvironment(wtk, dispatchThread);
+ ContextStorage.setWTK(wtk);
+ return wtk;
+ }
+ };
+ nativeThread.start(init);
+ dispatchThread.start();
+ wtk.getNativeEventQueue().awake();
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Synchronizes this toolkit's graphics.
+ */
+ public abstract void sync();
+
+ /**
+ * Returns the construction status of a specified image that is being created.
+ *
+ * @param a0 the image to be checked.
+ * @param a1 the width of scaled image for which the status is being checked, or -1.
+ * @param a2 the height of scaled image for which the status is being checked, or -1.
+ * @param a3 the ImageObserver object to be notified while
+ * the image is being prepared.
+ *
+ * @return the ImageObserver flags which give the current state of the image data.
+ */
+ public abstract int checkImage(Image a0, int a1, int a2, ImageObserver a3);
+
+ /**
+ * Creates the image with the specified ImageProducer.
+ *
+ * @param a0 the ImageProducer to be used for image creation.
+ *
+ * @return the image with the specified ImageProducer.
+ */
+ public abstract Image createImage(ImageProducer a0);
+
+ /**
+ * Creates the image from the specified byte array, offset and length.
+ * The byte array should contain data with image format supported by
+ * Toolkit such as JPEG, GIF, or PNG.
+ *
+ * @param a0 the byte array with the image data.
+ * @param a1 the offset of the beggining the image data in the byte array.
+ * @param a2 the length of the image data in the byte array.
+ *
+ * @return the created Image.
+ */
+ public abstract Image createImage(byte[] a0, int a1, int a2);
+
+ /**
+ * Creates the image using image data from the specified URL.
+ *
+ * @param a0 the URL for extracting image data.
+ *
+ * @return the Image.
+ */
+ public abstract Image createImage(URL a0);
+
+ /**
+ * Creates the image using image data from the specified file.
+ *
+ * @param a0 the file name which contains image data of supported format.
+ *
+ * @return the Image.
+ */
+ public abstract Image createImage(String a0);
+
+ /**
+ * Gets the color model.
+ *
+ * @return the ColorModel of Toolkit's screen.
+ *
+ * @throws HeadlessException if the
+ * GraphicsEnvironment.isHeadless() method returns true.
+ */
+ public abstract ColorModel getColorModel() throws HeadlessException;
+
+ /**
+ * Gets the screen device metrics for the specified font.
+ *
+ * @param font the Font.
+ *
+ * @return the FontMetrics for the specified Font.
+ *
+ * @deprecated Use getLineMetrics method from Font class.
+ */
+
+ @Deprecated
+ public abstract FontMetrics getFontMetrics(Font font);
+
+ /**
+ * Prepares the specified image for rendering on the screen with the
+ * specified size.
+ *
+ * @param a0 the Image to be prepared.
+ * @param a1 the width of the screen representation or -1 for the current screen.
+ * @param a2 the height of the screen representation or -1 for the current screen.
+ * @param a3 the ImageObserver object to be notified as soon as
+ * the image is prepared.
+ *
+ * @return true, if image is fully prepared; false otherwise.
+ */
+ public abstract boolean prepareImage(Image a0, int a1, int a2, ImageObserver a3);
+
+ /**
+ * Creates an audio beep.
+ */
+ public abstract void beep();
+
+ /**
+ * Returns the array of font names which are available in this Toolkit.
+ *
+ * @return the array of font names which are available in this Toolkit.
+ *
+ * @deprecated use GraphicsEnvironment.getAvailableFontFamilyNames() method.
+ */
+ @Deprecated
+ public abstract String[] getFontList();
+
+ /**
+ * Gets the the Font implementation using the specified peer
+ * interface.
+ *
+ * @param a0 the Font name to be implemented.
+ * @param a1 the the font style: PLAIN, BOLD, ITALIC.
+ *
+ * @return the FontPeer implementation of the specified Font.
+ *
+ * @deprecated use java.awt.GraphicsEnvironment.getAllFonts method.
+ */
+
+ @Deprecated
+ protected abstract FontPeer getFontPeer(String a0, int a1);
+
+ /**
+ * Gets the image from the specified file which contains image data in
+ * a supported image format (such as JPEG, GIF, or PNG); this method
+ * should return the same Image for multiple calls of this method with
+ * the same image file name.
+ *
+ * @param a0 the file name which contains image data in
+ * a supported image format (such as JPEG, GIF, or PNG).
+ *
+ * @return the Image.
+ */
+ public abstract Image getImage(String a0);
+
+ /**
+ * Gets the image from the specified URL which contains image data in
+ * a supported image format (such as JPEG, GIF, or PNG); this method
+ * should return the same Image for multiple calls of this method with
+ * the same image URL.
+ *
+ * @param a0 the URL which contains image data in
+ * a supported image format (such as JPEG, GIF, or PNG).
+ *
+ * @return the Image.
+ */
+ public abstract Image getImage(URL a0);
+
+ /**
+ * Gets the screen resolution.
+ *
+ * @return the screen resolution.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ public abstract int getScreenResolution() throws HeadlessException;
+
+ /**
+ * Gets the screen size.
+ *
+ * @return a Dimension object containing the width and height of
+ * the screen.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ public abstract Dimension getScreenSize() throws HeadlessException;
+
+ /**
+ * Gets the EventQueue instance without checking access.
+ *
+ * @return the system EventQueue.
+ */
+ protected abstract EventQueue getSystemEventQueueImpl();
+
+ /**
+ * Returns a map of text attributes for the abstract level description
+ * of the specified input method highlight, or null if no mapping is found.
+ *
+ * @param highlight the InputMethodHighlight.
+ *
+ * @return the Map<java.awt.font. text attribute,?>
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ public abstract Map<java.awt.font.TextAttribute, ?> mapInputMethodHighlight(
+ InputMethodHighlight highlight) throws HeadlessException;
+
+ /**
+ * Map input method highlight impl.
+ *
+ * @param highlight the highlight
+ *
+ * @return the map<java.awt.font. text attribute,?>
+ *
+ * @throws HeadlessException the headless exception
+ */
+ Map<java.awt.font.TextAttribute, ?> mapInputMethodHighlightImpl(
+ InputMethodHighlight highlight) throws HeadlessException {
+ HashMap<java.awt.font.TextAttribute, ?> map = new HashMap<java.awt.font.TextAttribute, Object>();
+ wtk.getSystemProperties().mapInputMethodHighlight(highlight, map);
+ return Collections.<java.awt.font.TextAttribute, Object> unmodifiableMap(map);
+ }
+
+ /**
+ * Adds the specified PropertyChangeListener listener for the specified
+ * property.
+ *
+ * @param propName the property name for which the specified PropertyChangeListener
+ * will be added.
+ * @param l the PropertyChangeListener object.
+ */
+ public void addPropertyChangeListener(String propName, PropertyChangeListener l) {
+ lockAWT();
+ try {
+ if (desktopProperties.isEmpty()) {
+ initializeDesktopProperties();
+ }
+ } finally {
+ unlockAWT();
+ }
+ if (l != null) { // there is no guarantee that null listener will not be added
+ desktopPropsSupport.addPropertyChangeListener(propName, l);
+ }
+ }
+
+ /**
+ * Returns an array of the property change listeners registered with
+ * this Toolkit.
+ *
+ * @return an array of the property change listeners registered with
+ * this Toolkit.
+ */
+ public PropertyChangeListener[] getPropertyChangeListeners() {
+ return desktopPropsSupport.getPropertyChangeListeners();
+ }
+
+ /**
+ * Returns an array of the property change listeners registered with
+ * this Toolkit for notification regarding the specified property.
+ *
+ * @param propName the property name for which the PropertyChangeListener
+ * was registered.
+ *
+ * @return the array of PropertyChangeListeners registered for the specified
+ * property name.
+ */
+ public PropertyChangeListener[] getPropertyChangeListeners(String propName) {
+ return desktopPropsSupport.getPropertyChangeListeners(propName);
+ }
+
+ /**
+ * Removes the specified property change listener registered for the
+ * specified property name.
+ *
+ * @param propName the property name.
+ * @param l the PropertyChangeListener registered for the specified property name.
+ */
+ public void removePropertyChangeListener(String propName, PropertyChangeListener l) {
+ desktopPropsSupport.removePropertyChangeListener(propName, l);
+ }
+
+ /**
+ * Creates a custom cursor with the specified Image, hot spot, and cursor
+ * description.
+ *
+ * @param img the image of activated cursor.
+ * @param hotSpot the Point giving the coordinates of the cursor's hot spot.
+ * @param name the cursor description.
+ *
+ * @return the cursor with the specified Image, hot spot, and cursor
+ * description.
+ *
+ * @throws IndexOutOfBoundsException if the hot spot values are outside
+ * the bounds of the cursor.
+ * @throws HeadlessException if isHeadless() method of GraphicsEnvironment
+ * class returns true.
+ */
+ public Cursor createCustomCursor(Image img, Point hotSpot, String name)
+ throws IndexOutOfBoundsException, HeadlessException {
+ lockAWT();
+ try {
+ int w = img.getWidth(null), x = hotSpot.x;
+ int h = img.getHeight(null), y = hotSpot.y;
+ if (x < 0 || x >= w || y < 0 || y >= h) {
+ // awt.7E=invalid hotSpot
+ throw new IndexOutOfBoundsException(Messages.getString("awt.7E")); //$NON-NLS-1$
+ }
+ return new Cursor(name, img, hotSpot);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Returns the supported cursor dimension which is closest to the
+ * specified width and height. If the Toolkit only supports a single
+ * cursor size, this method should return the supported cursor size.
+ * If custom cursor is not supported, a dimension of 0, 0 should be
+ * returned.
+ *
+ * @param prefWidth the preffered cursor width.
+ * @param prefHeight the preffered cursor height.
+ *
+ * @return the supported cursor dimension which is closest to the
+ * specified width and height.
+ *
+ * @throws HeadlessException if GraphicsEnvironment.isHeadless()
+ * returns true.
+ */
+ public Dimension getBestCursorSize(int prefWidth, int prefHeight) throws HeadlessException {
+ lockAWT();
+ try {
+ return wtk.getCursorFactory().getBestCursorSize(prefWidth, prefHeight);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the value for the specified desktop property.
+ *
+ * @param propName the property name.
+ *
+ * @return the Object that is the property's value.
+ */
+ public final Object getDesktopProperty(String propName) {
+ lockAWT();
+ try {
+ if (desktopProperties.isEmpty()) {
+ initializeDesktopProperties();
+ }
+ if (propName.equals("awt.dynamicLayoutSupported")) { //$NON-NLS-1$
+ // dynamicLayoutSupported is special case
+ return Boolean.valueOf(isDynamicLayoutActive());
+ }
+ Object val = desktopProperties.get(propName);
+ if (val == null) {
+ // try to lazily load prop value
+ // just for compatibility, our lazilyLoad is empty
+ val = lazilyLoadDesktopProperty(propName);
+ }
+ return val;
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Returns the locking key state for the specified key.
+ *
+ * @param a0 the key code: VK_CAPS_LOCK, VK_NUM_LOCK, VK_SCROLL_LOCK,
+ * or VK_KANA_LOCK.
+ *
+ * @return true if the specified key code is in the locked state,
+ * false otherwise.
+ *
+ * @throws UnsupportedOperationException if the state of this key
+ * can't be retrieved, or if the keyboard doesn't have this key.
+ * @throws NotImplementedException if this method is not implemented.
+ */
+ public boolean getLockingKeyState(int a0) throws UnsupportedOperationException, org.apache.harmony.luni.util.NotImplementedException {
+ lockAWT();
+ try {
+ } finally {
+ unlockAWT();
+ }
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //TODO: implement //$NON-NLS-1$
+ }
+ return true;
+ }
+
+ /**
+ * Returns the maximum number of colors which the Toolkit supports for
+ * custom cursor.
+ *
+ * @return the maximum cursor colors.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ public int getMaximumCursorColors() throws HeadlessException {
+ lockAWT();
+ try {
+ return wtk.getCursorFactory().getMaximumCursorColors();
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the menu shortcut key mask.
+ *
+ * @return the menu shortcut key mask.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ public int getMenuShortcutKeyMask() throws HeadlessException {
+ lockAWT();
+ try {
+ return InputEvent.CTRL_MASK;
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the screen insets.
+ *
+ * @param gc the GraphicsConfiguration.
+ *
+ * @return the insets of this toolkit.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ public Insets getScreenInsets(GraphicsConfiguration gc) throws HeadlessException {
+ if (gc == null) {
+ throw new NullPointerException();
+ }
+ lockAWT();
+ try {
+ return new Insets(0, 0, 0, 0); //TODO: get real screen insets
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the system EventQueue instance.
+ * If the default implementation of checkAwtEventQueueAccess is used,
+ * then this results of a call to the security manager's checkPermission
+ * method with an AWTPermission("accessEventQueue") permission.
+ *
+ * @return the system EventQueue instance.
+ */
+ public final EventQueue getSystemEventQueue() {
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ sm.checkAwtEventQueueAccess();
+ }
+ return getSystemEventQueueImpl();
+ }
+
+ /**
+ * Gets the system event queue core.
+ *
+ * @return the system event queue core
+ */
+ EventQueueCore getSystemEventQueueCore() {
+ return systemEventQueueCore;
+ }
+
+ /**
+ * Sets the system event queue core.
+ *
+ * @param core the new system event queue core
+ */
+ void setSystemEventQueueCore(EventQueueCore core) {
+ systemEventQueueCore = core;
+ }
+
+ /**
+ * Initialize the desktop properties.
+ */
+ protected void initializeDesktopProperties() {
+ lockAWT();
+ try {
+ wtk.getSystemProperties().init(desktopProperties);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Checks if dynamic layout of Containers is active or not.
+ *
+ * @return true, if is dynamic layout of Containers is active,
+ * false otherwise.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ public boolean isDynamicLayoutActive() throws HeadlessException {
+ lockAWT();
+ try {
+ // always return true
+ return true;
+ } finally {
+ unlockAWT();
+ }
+ }
+
+
+ /**
+ * Returns if the layout of Containers is checked dynamically during resizing,
+ * or statically after resizing is completed.
+ *
+ * @return true, if if the layout of Containers is checked dynamically during
+ * resizing; false, if the layout of Containers is checked statically after
+ * resizing is completed.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ protected boolean isDynamicLayoutSet() throws HeadlessException {
+ lockAWT();
+ try {
+ return bDynamicLayoutSet;
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Checks if the specified frame state is supported by Toolkit or not.
+ *
+ * @param state the frame state.
+ *
+ * @return true, if frame state is supported; false othrwise.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ public boolean isFrameStateSupported(int state) throws HeadlessException {
+ lockAWT();
+ try {
+ return wtk.getWindowFactory().isWindowStateSupported(state);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Loads the value of the desktop property with the specified property name.
+ *
+ * @param propName the property name.
+ *
+ * @return the desktop property values.
+ */
+ protected Object lazilyLoadDesktopProperty(String propName) {
+ return null;
+ }
+
+ /**
+ * Loads the current system color values to the specified array.
+ *
+ * @param colors the array where the current system color values
+ * are written by this method.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ protected void loadSystemColors(int[] colors) throws HeadlessException {
+ lockAWT();
+ try {
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the value of the desktop property with the specified name.
+ *
+ * @param propName the property's name.
+ * @param value the property's value.
+ */
+ protected final void setDesktopProperty(String propName, Object value) {
+ Object oldVal;
+ lockAWT();
+ try {
+ oldVal = getDesktopProperty(propName);
+ userPropSet.add(propName);
+ desktopProperties.put(propName, value);
+ } finally {
+ unlockAWT();
+ }
+ desktopPropsSupport.firePropertyChange(propName, oldVal, value);
+ }
+
+ /**
+ * Sets the layout state, whether the Container layout is checked
+ * dynamically during resizing, or statically after resizing is completed.
+ *
+ * @param dynamic the new dynamic layout state - if true the layout of
+ * Containers is checked dynamically during resizing, if false -
+ * statically after resizing is completed.
+ *
+ * @throws HeadlessException if the GraphicsEnvironment.isHeadless()
+ * method returns true.
+ */
+ public void setDynamicLayout(boolean dynamic) throws HeadlessException {
+ lockAWT();
+ try {
+ bDynamicLayoutSet = dynamic;
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Sets the locking key state for the specified key code.
+ *
+ * @param a0 the key code: VK_CAPS_LOCK, VK_NUM_LOCK, VK_SCROLL_LOCK,
+ * or VK_KANA_LOCK.
+ * @param a1 the state - true to set the specified key code to the locked state,
+ * false - to unlock it.
+ *
+ * @throws UnsupportedOperationException if the state of this key
+ * can't be set, or if the keyboard doesn't have this key.
+ * @throws NotImplementedException if this method is not implemented.
+ */
+ public void setLockingKeyState(int a0, boolean a1) throws UnsupportedOperationException, org.apache.harmony.luni.util.NotImplementedException {
+ lockAWT();
+ try {
+ } finally {
+ unlockAWT();
+ }
+ if (true) {
+ throw new RuntimeException("Method is not implemented"); //TODO: implement //$NON-NLS-1$
+ }
+ return;
+ }
+
+
+ /**
+ * On queue empty.
+ */
+ void onQueueEmpty() {
+ throw new RuntimeException("Not implemented!");
+ }
+
+ /**
+ * Creates the wtk.
+ *
+ * @param clsName the cls name
+ *
+ * @return the wTK
+ */
+ private WTK createWTK(String clsName) {
+ WTK newWTK = null;
+ try {
+ newWTK = (WTK) Class.forName(clsName).newInstance();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ return newWTK;
+ }
+
+ /**
+ * Connect the component to its native window
+ * @param winId - id of native window just created
+ */
+ boolean onWindowCreated(long winId) {
+ return false;
+ }
+
+ /**
+ * Gets the native event queue.
+ *
+ * @return the native event queue
+ */
+ NativeEventQueue getNativeEventQueue() {
+ return wtk.getNativeEventQueue();
+ }
+
+ /**
+ * Returns a shared instance of implementation of org.apache.harmony.awt.wtk.NativeCursor
+ * for current platform for
+ *
+ * @param type - Java Cursor type
+ *
+ * @return new instance of implementation of NativeCursor
+ */
+ NativeCursor createNativeCursor(int type) {
+ return wtk.getCursorFactory().getCursor(type);
+ }
+
+ /**
+ * Returns a shared instance of implementation of org.apache.harmony.awt.wtk.NativeCursor
+ * for current platform for custom cursor
+ *
+ * @param img the img
+ * @param hotSpot the hot spot
+ * @param name the name
+ *
+ * @return new instance of implementation of NativeCursor
+ */
+ NativeCursor createCustomNativeCursor(Image img, Point hotSpot, String name) {
+ return wtk.getCursorFactory().createCustomCursor(img, hotSpot.x, hotSpot.y);
+ }
+
+ /**
+ * Adds an AWTEventListener to the Toolkit to listen for events
+ * of types corresponding to bits in the specified event mask.
+ * Event masks are defined in AWTEvent class.
+ *
+ * @param listener the AWTEventListener.
+ * @param eventMask he bitmask of event types.
+ */
+ public void addAWTEventListener(AWTEventListener listener, long eventMask) {
+ lockAWT();
+ try {
+ SecurityManager security = System.getSecurityManager();
+ if (security != null) {
+ security.checkPermission(awtEventsManager.permission);
+ }
+ awtEventsManager.addAWTEventListener(listener, eventMask);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Removes the specified awt event listener.
+ *
+ * @param listener the AWTEventListener to be removed.
+ */
+ public void removeAWTEventListener(AWTEventListener listener) {
+ lockAWT();
+ try {
+ SecurityManager security = System.getSecurityManager();
+ if (security != null) {
+ security.checkPermission(awtEventsManager.permission);
+ }
+ awtEventsManager.removeAWTEventListener(listener);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Gets the array of all AWT event listeners registered with this Toolkit.
+ *
+ * @return the array of all AWT event listeners registered with this Toolkit.
+ */
+ public AWTEventListener[] getAWTEventListeners() {
+ lockAWT();
+ try {
+ SecurityManager security = System.getSecurityManager();
+ if (security != null) {
+ security.checkPermission(awtEventsManager.permission);
+ }
+ return awtEventsManager.getAWTEventListeners();
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Returns the array of the AWT event listeners registered with this Toolkit
+ * for the event types corresponding to the specified event mask.
+ *
+ * @param eventMask the bit mask of event type.
+ *
+ * @return the array of the AWT event listeners registered in this Toolkit
+ * for the event types corresponding to the specified event mask.
+ */
+ public AWTEventListener[] getAWTEventListeners(long eventMask) {
+ lockAWT();
+ try {
+ SecurityManager security = System.getSecurityManager();
+ if (security != null) {
+ security.checkPermission(awtEventsManager.permission);
+ }
+ return awtEventsManager.getAWTEventListeners(eventMask);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ /**
+ * Dispatch awt event.
+ *
+ * @param event the event
+ */
+ void dispatchAWTEvent(AWTEvent event) {
+ awtEventsManager.dispatchAWTEvent(event);
+ }
+
+ /**
+ * The Class AWTEventsManager.
+ */
+ final class AWTEventsManager {
+
+ /** The permission. */
+ AWTPermission permission = new AWTPermission("listenToAllAWTEvents"); //$NON-NLS-1$
+
+ /** The listeners. */
+ private final AWTListenerList<AWTEventListenerProxy> listeners = new AWTListenerList<AWTEventListenerProxy>();
+
+ /**
+ * Adds the awt event listener.
+ *
+ * @param listener the listener
+ * @param eventMask the event mask
+ */
+ void addAWTEventListener(AWTEventListener listener, long eventMask) {
+ if (listener != null) {
+ listeners.addUserListener(new AWTEventListenerProxy(eventMask, listener));
+ }
+ }
+
+ /**
+ * Removes the awt event listener.
+ *
+ * @param listener the listener
+ */
+ void removeAWTEventListener(AWTEventListener listener) {
+ if (listener != null) {
+ for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
+ if (listener == proxy.getListener()) {
+ listeners.removeUserListener(proxy);
+ return;
+ }
+ }
+ }
+ }
+
+ /**
+ * Gets the aWT event listeners.
+ *
+ * @return the aWT event listeners
+ */
+ AWTEventListener[] getAWTEventListeners() {
+ HashSet<EventListener> listenersSet = new HashSet<EventListener>();
+ for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
+ listenersSet.add(proxy.getListener());
+ }
+ return listenersSet.toArray(new AWTEventListener[listenersSet.size()]);
+ }
+
+ /**
+ * Gets the aWT event listeners.
+ *
+ * @param eventMask the event mask
+ *
+ * @return the aWT event listeners
+ */
+ AWTEventListener[] getAWTEventListeners(long eventMask) {
+ HashSet<EventListener> listenersSet = new HashSet<EventListener>();
+ for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
+ if ((proxy.getEventMask() & eventMask) == eventMask) {
+ listenersSet.add(proxy.getListener());
+ }
+ }
+ return listenersSet.toArray(new AWTEventListener[listenersSet.size()]);
+ }
+
+ /**
+ * Dispatch awt event.
+ *
+ * @param event the event
+ */
+ void dispatchAWTEvent(AWTEvent event) {
+ AWTEvent.EventDescriptor descriptor = eventTypeLookup.getEventDescriptor(event);
+ if (descriptor == null) {
+ return;
+ }
+ for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
+ if ((proxy.getEventMask() & descriptor.eventMask) != 0) {
+ proxy.eventDispatched(event);
+ }
+ }
+ }
+ }
+
+ /**
+ * The Class AutoNumber.
+ */
+ static final class AutoNumber {
+
+ /** The next component. */
+ int nextComponent = 0;
+
+ /** The next canvas. */
+ int nextCanvas = 0;
+
+ /** The next panel. */
+ int nextPanel = 0;
+
+ /** The next window. */
+ int nextWindow = 0;
+
+ /** The next frame. */
+ int nextFrame = 0;
+
+ /** The next dialog. */
+ int nextDialog = 0;
+
+ /** The next button. */
+ int nextButton = 0;
+
+ /** The next menu component. */
+ int nextMenuComponent = 0;
+
+ /** The next label. */
+ int nextLabel = 0;
+
+ /** The next check box. */
+ int nextCheckBox = 0;
+
+ /** The next scrollbar. */
+ int nextScrollbar = 0;
+
+ /** The next scroll pane. */
+ int nextScrollPane = 0;
+
+ /** The next list. */
+ int nextList = 0;
+
+ /** The next choice. */
+ int nextChoice = 0;
+
+ /** The next file dialog. */
+ int nextFileDialog = 0;
+
+ /** The next text area. */
+ int nextTextArea = 0;
+
+ /** The next text field. */
+ int nextTextField = 0;
+ }
+
+ private class Lock {
+ }
+
+ /** The lock. */
+ private final Object lock = new Lock();
+
+}
diff --git a/awt/java/awt/ToolkitImpl.java b/awt/java/awt/ToolkitImpl.java
new file mode 100644
index 0000000..5015aef
--- /dev/null
+++ b/awt/java/awt/ToolkitImpl.java
@@ -0,0 +1,255 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.awt;
+
+import java.awt.im.InputMethodHighlight;
+import java.awt.image.ColorModel;
+import java.awt.image.ImageObserver;
+import java.awt.image.ImageProducer;
+import java.awt.peer.*;
+import java.io.Serializable;
+import java.net.URL;
+import java.util.Hashtable;
+import java.util.Map;
+import org.apache.harmony.awt.gl.image.*;
+import org.apache.harmony.awt.wtk.GraphicsFactory;
+
+class ToolkitImpl extends Toolkit {
+
+ static final Hashtable<Serializable, Image> imageCache = new Hashtable<Serializable, Image>();
+
+ @Override
+ public void sync() {
+ lockAWT();
+ try {
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public int checkImage(Image image, int width, int height, ImageObserver observer) {
+ lockAWT();
+ try {
+ if (width == 0 || height == 0) {
+ return ImageObserver.ALLBITS;
+ }
+ if (!(image instanceof OffscreenImage)) {
+ return ImageObserver.ALLBITS;
+ }
+ OffscreenImage oi = (OffscreenImage) image;
+ return oi.checkImage(observer);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public Image createImage(ImageProducer producer) {
+ lockAWT();
+ try {
+ return new OffscreenImage(producer);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public Image createImage(byte[] imagedata, int imageoffset, int imagelength) {
+ lockAWT();
+ try {
+ return new OffscreenImage(new ByteArrayDecodingImageSource(imagedata, imageoffset,
+ imagelength));
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public Image createImage(URL url) {
+ lockAWT();
+ try {
+ return new OffscreenImage(new URLDecodingImageSource(url));
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public Image createImage(String filename) {
+ lockAWT();
+ try {
+ return new OffscreenImage(new FileDecodingImageSource(filename));
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public ColorModel getColorModel() {
+ lockAWT();
+ try {
+ return GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice()
+ .getDefaultConfiguration().getColorModel();
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ @Deprecated
+ public FontMetrics getFontMetrics(Font font) {
+ lockAWT();
+ try {
+ GraphicsFactory gf = getGraphicsFactory();
+ return gf.getFontMetrics(font);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public boolean prepareImage(Image image, int width, int height, ImageObserver observer) {
+ lockAWT();
+ try {
+ if (width == 0 || height == 0) {
+ return true;
+ }
+ if (!(image instanceof OffscreenImage)) {
+ return true;
+ }
+ OffscreenImage oi = (OffscreenImage) image;
+ return oi.prepareImage(observer);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public void beep() {
+ lockAWT();
+ try {
+ // ???AWT: is there nothing to be implemented here?
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ @Deprecated
+ public String[] getFontList() {
+ lockAWT();
+ try {
+ } finally {
+ unlockAWT();
+ }
+ return null;
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ @Deprecated
+ protected FontPeer getFontPeer(String a0, int a1) {
+ lockAWT();
+ try {
+ return null;
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public Image getImage(String filename) {
+ return getImage(filename, this);
+ }
+
+ static Image getImage(String filename, Toolkit toolkit) {
+ synchronized (imageCache) {
+ Image im = (filename == null ? null : imageCache.get(filename));
+
+ if (im == null) {
+ try {
+ im = toolkit.createImage(filename);
+ imageCache.put(filename, im);
+ } catch (Exception e) {
+ }
+ }
+
+ return im;
+ }
+ }
+
+ @Override
+ public Image getImage(URL url) {
+ return getImage(url, this);
+ }
+
+ static Image getImage(URL url, Toolkit toolkit) {
+ synchronized (imageCache) {
+ Image im = imageCache.get(url);
+ if (im == null) {
+ try {
+ im = toolkit.createImage(url);
+ imageCache.put(url, im);
+ } catch (Exception e) {
+ }
+ }
+ return im;
+ }
+ }
+
+ @Override
+ public int getScreenResolution() throws HeadlessException {
+ lockAWT();
+ try {
+ return 62;
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public Dimension getScreenSize() {
+ lockAWT();
+ try {
+ DisplayMode dm = GraphicsEnvironment.getLocalGraphicsEnvironment()
+ .getDefaultScreenDevice().getDisplayMode();
+ return new Dimension(dm.getWidth(), dm.getHeight());
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ public Map<java.awt.font.TextAttribute, ?> mapInputMethodHighlight(
+ InputMethodHighlight highlight) throws HeadlessException {
+ lockAWT();
+ try {
+ return mapInputMethodHighlightImpl(highlight);
+ } finally {
+ unlockAWT();
+ }
+ }
+
+ @Override
+ protected EventQueue getSystemEventQueueImpl() {
+ return getSystemEventQueueCore().getActiveEventQueue();
+ }
+}
diff --git a/awt/java/awt/Transparency.java b/awt/java/awt/Transparency.java
new file mode 100644
index 0000000..9793114
--- /dev/null
+++ b/awt/java/awt/Transparency.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt;
+
+/**
+ * The Transparency interface defines transparency's general modes.
+ */
+public interface Transparency {
+
+ /** The Constant OPAQUE represents completely opaque data,
+ * all pixels have an alpha value of 1.0.
+ */
+ public static final int OPAQUE = 1;
+
+ /** The Constant BITMASK represents data which can be either
+ * completely opaque, with an alpha value of 1.0, or completely
+ * transparent, with an alpha value of 0.0.
+ */
+ public static final int BITMASK = 2;
+
+ /** The Constant TRANSLUCENT represents data which alpha value
+ * can vary between and including 0.0 and 1.0. */
+ public static final int TRANSLUCENT = 3;
+
+ /**
+ * Gets the transparency mode.
+ *
+ * @return the transparency mode: OPAQUE, BITMASK or TRANSLUCENT.
+ */
+ public int getTransparency();
+
+}
+
diff --git a/awt/java/awt/color/CMMException.java b/awt/java/awt/color/CMMException.java
new file mode 100644
index 0000000..16fe76e
--- /dev/null
+++ b/awt/java/awt/color/CMMException.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+package java.awt.color;
+
+/**
+ * The CMMException is thrown as soon as a native CMM error
+ * occures.
+ */
+public class CMMException extends java.lang.RuntimeException {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 5775558044142994965L;
+
+ /**
+ * Instantiates a new CMM exception with detail message.
+ *
+ * @param s the String - detail message.
+ */
+ public CMMException (String s) {
+ super (s);
+ }
+}
diff --git a/awt/java/awt/color/ColorSpace.java b/awt/java/awt/color/ColorSpace.java
new file mode 100644
index 0000000..f961514
--- /dev/null
+++ b/awt/java/awt/color/ColorSpace.java
@@ -0,0 +1,340 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+package java.awt.color;
+
+import java.io.Serializable;
+
+import org.apache.harmony.awt.gl.color.LUTColorConverter;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The ColorSpace class defines a color space type for a Color and provides methods
+ * for arrays of color component operations.
+ */
+public abstract class ColorSpace implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -409452704308689724L;
+
+ /** The Constant TYPE_XYZ indicates XYZ color space type. */
+ public static final int TYPE_XYZ = 0;
+
+ /** The Constant TYPE_Lab indicates Lab color space type. */
+ public static final int TYPE_Lab = 1;
+
+ /** The Constant TYPE_Luv indicates Luv color space type. */
+ public static final int TYPE_Luv = 2;
+
+ /** The Constant TYPE_YCbCr indicates YCbCr color space type. */
+ public static final int TYPE_YCbCr = 3;
+
+ /** The Constant TYPE_Yxy indicates Yxy color space type. */
+ public static final int TYPE_Yxy = 4;
+
+ /** The Constant TYPE_RGB indicates RGB color space type. */
+ public static final int TYPE_RGB = 5;
+
+ /** The Constant TYPE_GRAY indicates Gray color space type. */
+ public static final int TYPE_GRAY = 6;
+
+ /** The Constant TYPE_HSV indicates HSV color space type. */
+ public static final int TYPE_HSV = 7;
+
+ /** The Constant TYPE_HLS indicates HLS color space type. */
+ public static final int TYPE_HLS = 8;
+
+ /** The Constant TYPE_CMYK indicates CMYK color space type. */
+ public static final int TYPE_CMYK = 9;
+
+ /** The Constant TYPE_CMY indicates CMY color space type. */
+ public static final int TYPE_CMY = 11;
+
+ /** The Constant TYPE_2CLR indicates color spaces with 2 components. */
+ public static final int TYPE_2CLR = 12;
+
+ /** The Constant TYPE_3CLR indicates color spaces with 3 components. */
+ public static final int TYPE_3CLR = 13;
+
+ /** The Constant TYPE_4CLR indicates color spaces with 4 components. */
+ public static final int TYPE_4CLR = 14;
+
+ /** The Constant TYPE_5CLR indicates color spaces with 5 components. */
+ public static final int TYPE_5CLR = 15;
+
+ /** The Constant TYPE_6CLR indicates color spaces with 6 components. */
+ public static final int TYPE_6CLR = 16;
+
+ /** The Constant TYPE_7CLR indicates color spaces with 7 components. */
+ public static final int TYPE_7CLR = 17;
+
+ /** The Constant TYPE_8CLR indicates color spaces with 8 components. */
+ public static final int TYPE_8CLR = 18;
+
+ /** The Constant TYPE_9CLR indicates color spaces with 9 components. */
+ public static final int TYPE_9CLR = 19;
+
+ /** The Constant TYPE_ACLR indicates color spaces with 10 components. */
+ public static final int TYPE_ACLR = 20;
+
+ /** The Constant TYPE_BCLR indicates color spaces with 11 components. */
+ public static final int TYPE_BCLR = 21;
+
+ /** The Constant TYPE_CCLR indicates color spaces with 12 components. */
+ public static final int TYPE_CCLR = 22;
+
+ /** The Constant TYPE_DCLR indicates color spaces with 13 components. */
+ public static final int TYPE_DCLR = 23;
+
+ /** The Constant TYPE_ECLR indicates color spaces with 14 components. */
+ public static final int TYPE_ECLR = 24;
+
+ /** The Constant TYPE_FCLR indicates color spaces with 15 components. */
+ public static final int TYPE_FCLR = 25;
+
+ /** The Constant CS_sRGB indicates standard RGB color space.*/
+ public static final int CS_sRGB = 1000;
+
+ /** The Constant CS_LINEAR_RGB indicates linear RGB color space. */
+ public static final int CS_LINEAR_RGB = 1004;
+
+ /** The Constant CS_CIEXYZ indicates CIEXYZ conversion color space. */
+ public static final int CS_CIEXYZ = 1001;
+
+ /** The Constant CS_PYCC indicates Photo YCC conversion color space. */
+ public static final int CS_PYCC = 1002;
+
+ /** The Constant CS_GRAY indicates linear gray scale color space. */
+ public static final int CS_GRAY = 1003;
+
+ /** The cs_ gray. */
+ private static ColorSpace cs_Gray = null;
+
+ /** The cs_ pycc. */
+ private static ColorSpace cs_PYCC = null;
+
+ /** The cs_ ciexyz. */
+ private static ColorSpace cs_CIEXYZ = null;
+
+ /** The cs_ lrgb. */
+ private static ColorSpace cs_LRGB = null;
+
+ /** The cs_s rgb. */
+ private static ColorSpace cs_sRGB = null;
+
+ /** The type. */
+ private int type;
+
+ /** The num components. */
+ private int numComponents;
+
+ /**
+ * Instantiates a ColorSpace with the specified
+ * ColorSpace type and number of components.
+ *
+ * @param type the type of color space.
+ * @param numcomponents the number of components.
+ */
+ protected ColorSpace(int type, int numcomponents) {
+ this.numComponents = numcomponents;
+ this.type = type;
+ }
+
+ /**
+ * Gets the name of the component for the specified component index.
+ *
+ * @param idx the index of the component.
+ *
+ * @return the name of the component.
+ */
+ public String getName(int idx) {
+ if (idx < 0 || idx > numComponents - 1) {
+ // awt.16A=Invalid component index: {0}
+ throw new IllegalArgumentException(Messages.getString("awt.16A", idx)); //$NON-NLS-1$
+ }
+
+ return "Unnamed color component #" + idx; //$NON-NLS-1$
+ }
+
+ /**
+ * Perform transformation a color from this ColorSpace
+ * into the RGB color space.
+ *
+ * @param colorvalue the color value in this ColorSpace.
+ *
+ * @return the float array with color components in the
+ * RGB color space.
+ */
+ public abstract float[] toRGB(float[] colorvalue);
+
+ /**
+ * Perform transformation a color from this ColorSpace
+ * into the CS_CIEXYZ color space.
+ *
+ * @param colorvalue the color value in this ColorSpace.
+ *
+ * @return the float array with color components in the
+ * CS_CIEXYZ color space.
+ */
+ public abstract float[] toCIEXYZ(float[] colorvalue);
+
+ /**
+ * Performs color transformation from the RGB color space
+ * into this ColorSpace.
+ *
+ * @param rgbvalue a float array in the RGB color space.
+ *
+ * @return the float[] an array of transformed color
+ * components.
+ */
+ public abstract float[] fromRGB(float[] rgbvalue);
+
+ /**
+ * Performs color transformation from the CS_CIEXYZ color space
+ * into this ColorSpace.
+ *
+ * @param colorvalue a float array in the CS_CIEXYZ color space.
+ *
+ * @return the float[] an array of transformed color
+ * components.
+ */
+ public abstract float[] fromCIEXYZ(float[] colorvalue);
+
+ /**
+ * Gets the minimum normalized color component value for
+ * the specified component.
+ *
+ * @param component the component.
+ *
+ * @return the miniimum normalized value of the component.
+ */
+ public float getMinValue(int component) {
+ if (component < 0 || component > numComponents - 1) {
+ // awt.16A=Invalid component index: {0}
+ throw new IllegalArgumentException(Messages.getString("awt.16A", component)); //$NON-NLS-1$
+ }
+ return 0;
+ }
+
+ /**
+ * Gets the maximum normalized color component value for
+ * the specified component.
+ *
+ * @param component the component.
+ *
+ * @return the maximum normalized value of the component.
+ */
+ public float getMaxValue(int component) {
+ if (component < 0 || component > numComponents - 1) {
+ // awt.16A=Invalid component index: {0}
+ throw new IllegalArgumentException(Messages.getString("awt.16A", component)); //$NON-NLS-1$
+ }
+ return 1;
+ }
+
+ /**
+ * Checks if this ColorSpace has CS_sRGB type or not.
+ *
+ * @return true, if this ColorSpace has CS_sRGB type,
+ * false otherwise.
+ */
+ public boolean isCS_sRGB() {
+ // If our color space is sRGB, then cs_sRGB
+ // is already initialized
+ return (this == cs_sRGB);
+ }
+
+ /**
+ * Gets the type of the ColorSpace.
+ *
+ * @return the type of the ColorSpace.
+ */
+ public int getType() {
+ return type;
+ }
+
+ /**
+ * Gets the number of components for this ColorSpace.
+ *
+ * @return the number of components.
+ */
+ public int getNumComponents() {
+ return numComponents;
+ }
+
+
+ /**
+ * Gets the single instance of ColorSpace with the specified
+ * ColorSpace: CS_sRGB, CS_LINEAR_RGB, CS_CIEXYZ, CS_GRAY,
+ * or CS_PYCC.
+ *
+ * @param colorspace the identifier of the specified Colorspace.
+ *
+ * @return the single instance of the desired ColorSpace.
+ */
+ public static ColorSpace getInstance(int colorspace) {
+ switch (colorspace) {
+ case CS_sRGB:
+ if (cs_sRGB == null) {
+ cs_sRGB = new ICC_ColorSpace(
+ new ICC_ProfileStub(CS_sRGB));
+ LUTColorConverter.sRGB_CS = cs_sRGB;
+ //ICC_Profile.getInstance (CS_sRGB));
+ }
+ return cs_sRGB;
+ case CS_CIEXYZ:
+ if (cs_CIEXYZ == null) {
+ cs_CIEXYZ = new ICC_ColorSpace(
+ new ICC_ProfileStub(CS_CIEXYZ));
+ //ICC_Profile.getInstance (CS_CIEXYZ));
+ }
+ return cs_CIEXYZ;
+ case CS_GRAY:
+ if (cs_Gray == null) {
+ cs_Gray = new ICC_ColorSpace(
+ new ICC_ProfileStub(CS_GRAY));
+ LUTColorConverter.LINEAR_GRAY_CS = cs_Gray;
+ //ICC_Profile.getInstance (CS_GRAY));
+ }
+ return cs_Gray;
+ case CS_PYCC:
+ if (cs_PYCC == null) {
+ cs_PYCC = new ICC_ColorSpace(
+ new ICC_ProfileStub(CS_PYCC));
+ //ICC_Profile.getInstance (CS_PYCC));
+ }
+ return cs_PYCC;
+ case CS_LINEAR_RGB:
+ if (cs_LRGB == null) {
+ cs_LRGB = new ICC_ColorSpace(
+ new ICC_ProfileStub(CS_LINEAR_RGB));
+ LUTColorConverter.LINEAR_GRAY_CS = cs_Gray;
+ //ICC_Profile.getInstance (CS_LINEAR_RGB));
+ }
+ return cs_LRGB;
+ default:
+ }
+
+ // Unknown argument passed
+ // awt.16B=Not a predefined colorspace
+ throw new IllegalArgumentException(Messages.getString("Not a predefined colorspace")); //$NON-NLS-1$
+ }
+
+}
\ No newline at end of file
diff --git a/awt/java/awt/color/ICC_ColorSpace.java b/awt/java/awt/color/ICC_ColorSpace.java
new file mode 100644
index 0000000..5ece2ef
--- /dev/null
+++ b/awt/java/awt/color/ICC_ColorSpace.java
@@ -0,0 +1,379 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+package java.awt.color;
+
+import org.apache.harmony.awt.gl.color.ColorConverter;
+import org.apache.harmony.awt.gl.color.ColorScaler;
+import org.apache.harmony.awt.gl.color.ICC_Transform;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+import java.io.*;
+
+/**
+ * ICC_ColorSpace class implements ColorSpace abstract class and
+ * represents device independent and device dependent color spaces.
+ * This color space is based on the International Color Consortium
+ * Specification (ICC) File Format for Color Profiles:
+ * <a href="http://www.color.org">http://www.color.org</a>
+ */
+public class ICC_ColorSpace extends ColorSpace {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 3455889114070431483L;
+
+ // Need to keep compatibility with serialized form
+ /** The Constant serialPersistentFields. */
+ private static final ObjectStreamField[]
+ serialPersistentFields = {
+ new ObjectStreamField("thisProfile", ICC_Profile.class), //$NON-NLS-1$
+ new ObjectStreamField("minVal", float[].class), //$NON-NLS-1$
+ new ObjectStreamField("maxVal", float[].class), //$NON-NLS-1$
+ new ObjectStreamField("diffMinMax", float[].class), //$NON-NLS-1$
+ new ObjectStreamField("invDiffMinMax", float[].class), //$NON-NLS-1$
+ new ObjectStreamField("needScaleInit", Boolean.TYPE) //$NON-NLS-1$
+ };
+
+
+ /**
+ * According to ICC specification (from http://www.color.org)
+ * "For the CIEXYZ encoding, each component (X, Y, and Z)
+ * is encoded as a u1Fixed15Number".
+ * This means that max value for this encoding is 1 + (32767/32768)
+ */
+ private static final float MAX_XYZ = 1f + (32767f/32768f);
+
+ /** The Constant MAX_SHORT. */
+ private static final float MAX_SHORT = 65535f;
+
+ /** The Constant INV_MAX_SHORT. */
+ private static final float INV_MAX_SHORT = 1f/MAX_SHORT;
+
+ /** The Constant SHORT2XYZ_FACTOR. */
+ private static final float SHORT2XYZ_FACTOR = MAX_XYZ/MAX_SHORT;
+
+ /** The Constant XYZ2SHORT_FACTOR. */
+ private static final float XYZ2SHORT_FACTOR = MAX_SHORT/MAX_XYZ;
+
+ /** The profile. */
+ private ICC_Profile profile = null;
+
+ /** The min values. */
+ private float minValues[] = null;
+
+ /** The max values. */
+ private float maxValues[] = null;
+
+ // cache transforms here - performance gain
+ /** The to rgb transform. */
+ private ICC_Transform toRGBTransform = null;
+
+ /** The from rgb transform. */
+ private ICC_Transform fromRGBTransform = null;
+
+ /** The to xyz transform. */
+ private ICC_Transform toXYZTransform = null;
+
+ /** The from xyz transform. */
+ private ICC_Transform fromXYZTransform = null;
+
+ /** The converter. */
+ private final ColorConverter converter = new ColorConverter();
+
+ /** The scaler. */
+ private final ColorScaler scaler = new ColorScaler();
+
+ /** The scaling data loaded. */
+ private boolean scalingDataLoaded = false;
+
+ /** The resolved deserialized inst. */
+ private ICC_ColorSpace resolvedDeserializedInst;
+
+ /**
+ * Instantiates a new ICC color space from an ICC_Profile object.
+ *
+ * @param pf the ICC_Profile object.
+ */
+ public ICC_ColorSpace(ICC_Profile pf) {
+ super(pf.getColorSpaceType(), pf.getNumComponents());
+
+ int pfClass = pf.getProfileClass();
+
+ switch (pfClass) {
+ case ICC_Profile.CLASS_COLORSPACECONVERSION:
+ case ICC_Profile.CLASS_DISPLAY:
+ case ICC_Profile.CLASS_OUTPUT:
+ case ICC_Profile.CLASS_INPUT:
+ break; // OK, it is color conversion profile
+ default:
+ // awt.168=Invalid profile class.
+ throw new IllegalArgumentException(Messages.getString("awt.168")); //$NON-NLS-1$
+ }
+
+ profile = pf;
+ fillMinMaxValues();
+ }
+
+ /**
+ * Returns the ICC_Profile for this ICC_ColorSpace.
+ *
+ * @return the ICC_Profile for this ICC_ColorSpace.
+ */
+ public ICC_Profile getProfile() {
+ if (profile instanceof ICC_ProfileStub) {
+ profile = ((ICC_ProfileStub) profile).loadProfile();
+ }
+
+ return profile;
+ }
+
+ @Override
+ public float[] toRGB(float[] colorvalue) {
+ if (toRGBTransform == null) {
+ ICC_Profile sRGBProfile =
+ ((ICC_ColorSpace) ColorSpace.getInstance(CS_sRGB)).getProfile();
+ ICC_Profile[] profiles = {getProfile(), sRGBProfile};
+ toRGBTransform = new ICC_Transform(profiles);
+ if (!scalingDataLoaded) {
+ scaler.loadScalingData(this);
+ scalingDataLoaded = true;
+ }
+ }
+
+ short[] data = new short[getNumComponents()];
+
+ scaler.scale(colorvalue, data, 0);
+
+ short[] converted =
+ converter.translateColor(toRGBTransform, data, null);
+
+ // unscale to sRGB
+ float[] res = new float[3];
+
+ res[0] = ((converted[0] & 0xFFFF)) * INV_MAX_SHORT;
+ res[1] = ((converted[1] & 0xFFFF)) * INV_MAX_SHORT;
+ res[2] = ((converted[2] & 0xFFFF)) * INV_MAX_SHORT;
+
+ return res;
+ }
+
+ @Override
+ public float[] toCIEXYZ(float[] colorvalue) {
+ if (toXYZTransform == null) {
+ ICC_Profile xyzProfile =
+ ((ICC_ColorSpace) ColorSpace.getInstance(CS_CIEXYZ)).getProfile();
+ ICC_Profile[] profiles = {getProfile(), xyzProfile};
+ try {
+ int[] intents = {
+ ICC_Profile.icRelativeColorimetric,
+ ICC_Profile.icPerceptual};
+ toXYZTransform = new ICC_Transform(profiles, intents);
+ } catch (CMMException e) { // No such tag, use what we can
+ toXYZTransform = new ICC_Transform(profiles);
+ }
+
+ if (!scalingDataLoaded) {
+ scaler.loadScalingData(this);
+ scalingDataLoaded = true;
+ }
+ }
+
+ short[] data = new short[getNumComponents()];
+
+ scaler.scale(colorvalue, data, 0);
+
+ short[] converted =
+ converter.translateColor(toXYZTransform, data, null);
+
+ // unscale to XYZ
+ float[] res = new float[3];
+
+ res[0] = ((converted[0] & 0xFFFF)) * SHORT2XYZ_FACTOR;
+ res[1] = ((converted[1] & 0xFFFF)) * SHORT2XYZ_FACTOR;
+ res[2] = ((converted[2] & 0xFFFF)) * SHORT2XYZ_FACTOR;
+
+ return res;
+ }
+
+ @Override
+ public float[] fromRGB(float[] rgbvalue) {
+ if (fromRGBTransform == null) {
+ ICC_Profile sRGBProfile =
+ ((ICC_ColorSpace) ColorSpace.getInstance(CS_sRGB)).getProfile();
+ ICC_Profile[] profiles = {sRGBProfile, getProfile()};
+ fromRGBTransform = new ICC_Transform(profiles);
+ if (!scalingDataLoaded) {
+ scaler.loadScalingData(this);
+ scalingDataLoaded = true;
+ }
+ }
+
+ // scale rgb value to short
+ short[] scaledRGBValue = new short[3];
+ scaledRGBValue[0] = (short)(rgbvalue[0] * MAX_SHORT + 0.5f);
+ scaledRGBValue[1] = (short)(rgbvalue[1] * MAX_SHORT + 0.5f);
+ scaledRGBValue[2] = (short)(rgbvalue[2] * MAX_SHORT + 0.5f);
+
+ short[] converted =
+ converter.translateColor(fromRGBTransform, scaledRGBValue, null);
+
+ float[] res = new float[getNumComponents()];
+
+ scaler.unscale(res, converted, 0);
+
+ return res;
+ }
+
+ @Override
+ public float[] fromCIEXYZ(float[] xyzvalue) {
+ if (fromXYZTransform == null) {
+ ICC_Profile xyzProfile =
+ ((ICC_ColorSpace) ColorSpace.getInstance(CS_CIEXYZ)).getProfile();
+ ICC_Profile[] profiles = {xyzProfile, getProfile()};
+ try {
+ int[] intents = {
+ ICC_Profile.icPerceptual,
+ ICC_Profile.icRelativeColorimetric};
+ fromXYZTransform = new ICC_Transform(profiles, intents);
+ } catch (CMMException e) { // No such tag, use what we can
+ fromXYZTransform = new ICC_Transform(profiles);
+ }
+
+ if (!scalingDataLoaded) {
+ scaler.loadScalingData(this);
+ scalingDataLoaded = true;
+ }
+
+ }
+
+ // scale xyz value to short
+ short[] scaledXYZValue = new short[3];
+ scaledXYZValue[0] = (short)(xyzvalue[0] * XYZ2SHORT_FACTOR + 0.5f);
+ scaledXYZValue[1] = (short)(xyzvalue[1] * XYZ2SHORT_FACTOR + 0.5f);
+ scaledXYZValue[2] = (short)(xyzvalue[2] * XYZ2SHORT_FACTOR + 0.5f);
+
+ short[] converted =
+ converter.translateColor(fromXYZTransform, scaledXYZValue, null);
+
+ float[] res = new float[getNumComponents()];
+
+ scaler.unscale(res, converted, 0);
+
+ return res;
+ }
+
+ @Override
+ public float getMinValue(int component) {
+ if ((component < 0) || (component > this.getNumComponents() - 1)) {
+ // awt.169=Component index out of range
+ throw new IllegalArgumentException(Messages.getString("awt.169")); //$NON-NLS-1$
+ }
+
+ return minValues[component];
+ }
+
+ @Override
+ public float getMaxValue(int component) {
+ if ((component < 0) || (component > this.getNumComponents() - 1)) {
+ // awt.169=Component index out of range
+ throw new IllegalArgumentException(Messages.getString("awt.169")); //$NON-NLS-1$
+ }
+
+ return maxValues[component];
+ }
+
+ /**
+ * Fill min max values.
+ */
+ private void fillMinMaxValues() {
+ int n = getNumComponents();
+ maxValues = new float[n];
+ minValues = new float[n];
+ switch (getType()) {
+ case ColorSpace.TYPE_XYZ:
+ minValues[0] = 0;
+ minValues[1] = 0;
+ minValues[2] = 0;
+ maxValues[0] = MAX_XYZ;
+ maxValues[1] = MAX_XYZ;
+ maxValues[2] = MAX_XYZ;
+ break;
+ case ColorSpace.TYPE_Lab:
+ minValues[0] = 0;
+ minValues[1] = -128;
+ minValues[2] = -128;
+ maxValues[0] = 100;
+ maxValues[1] = 127;
+ maxValues[2] = 127;
+ break;
+ default:
+ for(int i=0; i<n; i++) {
+ minValues[i] = 0;
+ maxValues[i] = 1;
+ }
+ }
+ }
+
+ /**
+ * Write object.
+ *
+ * @param out the out
+ *
+ * @throws IOException Signals that an I/O exception has occurred.
+ */
+ private void writeObject(ObjectOutputStream out) throws IOException {
+ ObjectOutputStream.PutField fields = out.putFields();
+
+ fields.put("thisProfile", profile); //$NON-NLS-1$
+ fields.put("minVal", null); //$NON-NLS-1$
+ fields.put("maxVal", null); //$NON-NLS-1$
+ fields.put("diffMinMax", null); //$NON-NLS-1$
+ fields.put("invDiffMinMax", null); //$NON-NLS-1$
+ fields.put("needScaleInit", true); //$NON-NLS-1$
+
+ out.writeFields();
+ }
+
+ /**
+ * Read object.
+ *
+ * @param in the in
+ *
+ * @throws IOException Signals that an I/O exception has occurred.
+ * @throws ClassNotFoundException the class not found exception
+ */
+ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+ ObjectInputStream.GetField fields = in.readFields();
+ resolvedDeserializedInst =
+ new ICC_ColorSpace((ICC_Profile) fields.get("thisProfile", null)); //$NON-NLS-1$
+ }
+
+ /**
+ * Read resolve.
+ *
+ * @return the object
+ *
+ * @throws ObjectStreamException the object stream exception
+ */
+ Object readResolve() throws ObjectStreamException {
+ return resolvedDeserializedInst;
+ }
+}
+
diff --git a/awt/java/awt/color/ICC_Profile.java b/awt/java/awt/color/ICC_Profile.java
new file mode 100644
index 0000000..ad704e0
--- /dev/null
+++ b/awt/java/awt/color/ICC_Profile.java
@@ -0,0 +1,1231 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+package java.awt.color;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamException;
+import java.io.OutputStream;
+import java.io.Serializable;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.StringTokenizer;
+
+import org.apache.harmony.awt.gl.color.ICC_ProfileHelper;
+import org.apache.harmony.awt.gl.color.NativeCMM;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The ICC_Profile class represents a color profile data for color spaces
+ * based on the International Color Consortium Specification ICC.1:2001-12,
+ * File Format for Color Profiles.
+ */
+public class ICC_Profile implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -3938515861990936766L;
+
+ // NOTE: Constant field values are noted in 1.5 specification.
+
+ /**
+ * The Constant CLASS_INPUT indicates that profile class is input.
+ */
+ public static final int CLASS_INPUT = 0;
+
+ /**
+ * The Constant CLASS_DISPLAY indicates that profile class is display.
+ */
+ public static final int CLASS_DISPLAY = 1;
+
+ /**
+ * The Constant CLASS_OUTPUT indicates that profile class is output.
+ */
+ public static final int CLASS_OUTPUT = 2;
+
+ /**
+ * The Constant CLASS_DEVICELINK indicates that profile class
+ * is device link.
+ */
+ public static final int CLASS_DEVICELINK = 3;
+
+ /**
+ * The Constant CLASS_COLORSPACECONVERSION indicates that profile class
+ * is color space conversion.
+ */
+ public static final int CLASS_COLORSPACECONVERSION = 4;
+
+ /** The Constant CLASS_ABSTRACT indicates that profile class is abstract. */
+ public static final int CLASS_ABSTRACT = 5;
+
+ /**
+ * The Constant CLASS_NAMEDCOLOR indicates that profile class
+ * is named color.
+ */
+ public static final int CLASS_NAMEDCOLOR = 6;
+
+ /** The Constant icSigXYZData - ICC Profile Color Space Type Signature. */
+ public static final int icSigXYZData = 1482250784;
+
+ /** The Constant icSigLabData - ICC Profile Color Space Type Signature. */
+ public static final int icSigLabData = 1281450528;
+
+ /** The Constant icSigLuvData - ICC Profile Color Space Type Signature. */
+ public static final int icSigLuvData = 1282766368;
+
+ /** The Constant icSigYCbCrData - ICC Profile Color Space Type Signature. */
+ public static final int icSigYCbCrData = 1497588338;
+
+ /** The Constant icSigYxyData - ICC Profile Color Space Type Signature. */
+ public static final int icSigYxyData = 1501067552;
+
+ /** The Constant icSigRgbData - ICC Profile Color Space Type Signature. */
+ public static final int icSigRgbData = 1380401696;
+
+ /** The Constant icSigGrayData - ICC Profile Color Space Type Signature. */
+ public static final int icSigGrayData = 1196573017;
+
+ /** The Constant icSigHsvData - ICC Profile Color Space Type Signature. */
+ public static final int icSigHsvData = 1213421088;
+
+ /** The Constant icSigHlsData - ICC Profile Color Space Type Signature. */
+ public static final int icSigHlsData = 1212961568;
+
+ /** The Constant icSigCmykData - ICC Profile Color Space Type Signature. */
+ public static final int icSigCmykData = 1129142603;
+
+ /** The Constant icSigCmyData - ICC Profile Color Space Type Signature. */
+ public static final int icSigCmyData = 1129142560;
+
+ /** The Constant icSigSpace2CLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpace2CLR = 843271250;
+
+ /** The Constant icSigSpace3CLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpace3CLR = 860048466;
+
+ /** The Constant icSigSpace4CLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpace4CLR = 876825682;
+
+ /** The Constant icSigSpace5CLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpace5CLR = 893602898;
+
+ /** The Constant icSigSpace6CLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpace6CLR = 910380114;
+
+ /** The Constant icSigSpace7CLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpace7CLR = 927157330;
+
+ /** The Constant icSigSpace8CLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpace8CLR = 943934546;
+
+ /** The Constant icSigSpace9CLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpace9CLR = 960711762;
+
+ /** The Constant icSigSpaceACLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpaceACLR = 1094929490;
+
+ /** The Constant icSigSpaceBCLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpaceBCLR = 1111706706;
+
+ /** The Constant icSigSpaceCCLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpaceCCLR = 1128483922;
+
+ /** The Constant icSigSpaceDCLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpaceDCLR = 1145261138;
+
+ /** The Constant icSigSpaceECLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpaceECLR = 1162038354;
+
+ /** The Constant icSigSpaceFCLR - ICC Profile Color Space Type Signature. */
+ public static final int icSigSpaceFCLR = 1178815570;
+
+ /** The Constant icSigInputClass - ICC Profile Class Signature. */
+ public static final int icSigInputClass = 1935896178;
+
+ /** The Constant icSigDisplayClass - ICC Profile Class Signature. */
+ public static final int icSigDisplayClass = 1835955314;
+
+ /** The Constant icSigOutputClass - ICC Profile Class Signature. */
+ public static final int icSigOutputClass = 1886549106;
+
+ /** The Constant icSigLinkClass - ICC Profile Class Signature. */
+ public static final int icSigLinkClass = 1818848875;
+
+ /** The Constant icSigAbstractClass - ICC Profile Class Signature. */
+ public static final int icSigAbstractClass = 1633842036;
+
+ /** The Constant icSigColorantOrderTag - ICC Profile Tag Signature. */
+ public static final int icSigColorantOrderTag = 1668051567;
+
+ /** The Constant icSigColorantTableTag - ICC Profile Tag Signature. */
+ public static final int icSigColorantTableTag = 1668051572;
+
+ /** The Constant icSigColorSpaceClass - ICC Profile Tag Signature. */
+ public static final int icSigColorSpaceClass = 1936744803;
+
+ /** The Constant icSigNamedColorClass - ICC Profile Tag Signature. */
+ public static final int icSigNamedColorClass = 1852662636;
+
+ /** The Constant icPerceptual - ICC Profile Rendering Intent. */
+ public static final int icPerceptual = 0;
+
+ /** The Constant icRelativeColorimetric - ICC Profile Rendering Intent. */
+ public static final int icRelativeColorimetric = 1;
+
+ /** The Constant icSaturation - ICC Profile Rendering Intent. */
+ public static final int icSaturation = 2;
+
+ /** The Constant icAbsoluteColorimetric - ICC Profile Rendering Intent. */
+ public static final int icAbsoluteColorimetric = 3;
+
+ /** The Constant icSigHead - ICC Profile Tag Signature. */
+ public static final int icSigHead = 1751474532;
+
+ /** The Constant icSigAToB0Tag - ICC Profile Tag Signature. */
+ public static final int icSigAToB0Tag = 1093812784;
+
+ /** The Constant icSigAToB1Tag - ICC Profile Tag Signature. */
+ public static final int icSigAToB1Tag = 1093812785;
+
+ /** The Constant icSigAToB2Tag - ICC Profile Tag Signature. */
+ public static final int icSigAToB2Tag = 1093812786;
+
+ /** The Constant icSigBlueColorantTag - ICC Profile Tag Signature. */
+ public static final int icSigBlueColorantTag = 1649957210;
+
+ /** The Constant icSigBlueMatrixColumnTag - ICC Profile Tag Signature. */
+ public static final int icSigBlueMatrixColumnTag = 1649957210;
+
+ /** The Constant icSigBlueTRCTag - ICC Profile Tag Signature. */
+ public static final int icSigBlueTRCTag = 1649693251;
+
+ /** The Constant icSigBToA0Tag - ICC Profile Tag Signature. */
+ public static final int icSigBToA0Tag = 1110589744;
+
+ /** The Constant icSigBToA1Tag - ICC Profile Tag Signature. */
+ public static final int icSigBToA1Tag = 1110589745;
+
+ /** The Constant icSigBToA2Tag - ICC Profile Tag Signature. */
+ public static final int icSigBToA2Tag = 1110589746;
+
+ /** The Constant icSigCalibrationDateTimeTag - ICC Profile Tag Signature. */
+ public static final int icSigCalibrationDateTimeTag = 1667329140;
+
+ /** The Constant icSigCharTargetTag - ICC Profile Tag Signature. */
+ public static final int icSigCharTargetTag = 1952543335;
+
+ /** The Constant icSigCopyrightTag - ICC Profile Tag Signature. */
+ public static final int icSigCopyrightTag = 1668313716;
+
+ /** The Constant icSigCrdInfoTag - ICC Profile Tag Signature. */
+ public static final int icSigCrdInfoTag = 1668441193;
+
+ /** The Constant icSigDeviceMfgDescTag - ICC Profile Tag Signature. */
+ public static final int icSigDeviceMfgDescTag = 1684893284;
+
+ /** The Constant icSigDeviceModelDescTag - ICC Profile Tag Signature. */
+ public static final int icSigDeviceModelDescTag = 1684890724;
+
+ /** The Constant icSigDeviceSettingsTag - ICC Profile Tag Signature. */
+ public static final int icSigDeviceSettingsTag = 1684371059;
+
+ /** The Constant icSigGamutTag - ICC Profile Tag Signature. */
+ public static final int icSigGamutTag = 1734438260;
+
+ /** The Constant icSigGrayTRCTag - ICC Profile Tag Signature. */
+ public static final int icSigGrayTRCTag = 1800688195;
+
+ /** The Constant icSigGreenColorantTag - ICC Profile Tag Signature. */
+ public static final int icSigGreenColorantTag = 1733843290;
+
+ /** The Constant icSigGreenMatrixColumnTag - ICC Profile Tag Signature. */
+ public static final int icSigGreenMatrixColumnTag = 1733843290;
+
+ /** The Constant icSigGreenTRCTag - ICC Profile Tag Signature. */
+ public static final int icSigGreenTRCTag = 1733579331;
+
+ /** The Constant icSigLuminanceTag - ICC Profile Tag Signature. */
+ public static final int icSigLuminanceTag = 1819635049;
+
+ /** The Constant icSigMeasurementTag - ICC Profile Tag Signature. */
+ public static final int icSigMeasurementTag = 1835360627;
+
+ /** The Constant icSigMediaBlackPointTag - ICC Profile Tag Signature. */
+ public static final int icSigMediaBlackPointTag = 1651208308;
+
+ /** The Constant icSigMediaWhitePointTag - ICC Profile Tag Signature. */
+ public static final int icSigMediaWhitePointTag = 2004119668;
+
+ /** The Constant icSigNamedColor2Tag - ICC Profile Tag Signature. */
+ public static final int icSigNamedColor2Tag = 1852009522;
+
+ /** The Constant icSigOutputResponseTag - ICC Profile Tag Signature. */
+ public static final int icSigOutputResponseTag = 1919251312;
+
+ /** The Constant icSigPreview0Tag - ICC Profile Tag Signature. */
+ public static final int icSigPreview0Tag = 1886545200;
+
+ /** The Constant icSigPreview1Tag - ICC Profile Tag Signature. */
+ public static final int icSigPreview1Tag = 1886545201;
+
+ /** The Constant icSigPreview2Tag - ICC Profile Tag Signature. */
+ public static final int icSigPreview2Tag = 1886545202;
+
+ /** The Constant icSigProfileDescriptionTag - ICC Profile Tag Signature. */
+ public static final int icSigProfileDescriptionTag = 1684370275;
+
+ /** The Constant icSigProfileSequenceDescTag - ICC Profile Tag Signature. */
+ public static final int icSigProfileSequenceDescTag = 1886610801;
+
+ /** The Constant icSigPs2CRD0Tag - ICC Profile Tag Signature. */
+ public static final int icSigPs2CRD0Tag = 1886610480;
+
+ /** The Constant icSigPs2CRD1Tag - ICC Profile Tag Signature. */
+ public static final int icSigPs2CRD1Tag = 1886610481;
+
+ /** The Constant icSigPs2CRD2Tag - ICC Profile Tag Signature. */
+ public static final int icSigPs2CRD2Tag = 1886610482;
+
+ /** The Constant icSigPs2CRD3Tag - ICC Profile Tag Signature. */
+ public static final int icSigPs2CRD3Tag = 1886610483;
+
+ /** The Constant icSigPs2CSATag - ICC Profile Tag Signature. */
+ public static final int icSigPs2CSATag = 1886597747;
+
+ /** The Constant icSigPs2RenderingIntentTag - ICC Profile Tag Signature. */
+ public static final int icSigPs2RenderingIntentTag = 1886597737;
+
+ /** The Constant icSigRedColorantTag - ICC Profile Tag Signature. */
+ public static final int icSigRedColorantTag = 1918392666;
+
+ /** The Constant icSigRedMatrixColumnTag - ICC Profile Tag Signature. */
+ public static final int icSigRedMatrixColumnTag = 1918392666;
+
+ /** The Constant icSigRedTRCTag - ICC Profile Tag Signature. */
+ public static final int icSigRedTRCTag = 1918128707;
+
+ /** The Constant icSigScreeningDescTag - ICC Profile Tag Signature. */
+ public static final int icSigScreeningDescTag = 1935897188;
+
+ /** The Constant icSigScreeningTag - ICC Profile Tag Signature. */
+ public static final int icSigScreeningTag = 1935897198;
+
+ /** The Constant icSigTechnologyTag - ICC Profile Tag Signature. */
+ public static final int icSigTechnologyTag = 1952801640;
+
+ /** The Constant icSigUcrBgTag - ICC Profile Tag Signature. */
+ public static final int icSigUcrBgTag = 1650877472;
+
+ /** The Constant icSigViewingCondDescTag - ICC Profile Tag Signature. */
+ public static final int icSigViewingCondDescTag = 1987405156;
+
+ /** The Constant icSigViewingConditionsTag - ICC Profile Tag Signature. */
+ public static final int icSigViewingConditionsTag = 1986618743;
+
+ /** The Constant icSigChromaticAdaptationTag - ICC Profile Tag Signature. */
+ public static final int icSigChromaticAdaptationTag = 1667785060;
+
+ /** The Constant icSigChromaticityTag - ICC Profile Tag Signature. */
+ public static final int icSigChromaticityTag = 1667789421;
+
+ /** The Constant icHdrSize - ICC Profile Header Location. */
+ public static final int icHdrSize = 0;
+
+ /** The Constant icHdrCmmId - ICC Profile Header Location. */
+ public static final int icHdrCmmId = 4;
+
+ /** The Constant icHdrVersion - ICC Profile Header Location. */
+ public static final int icHdrVersion = 8;
+
+ /** The Constant icHdrDeviceClass - ICC Profile Header Location. */
+ public static final int icHdrDeviceClass = 12;
+
+ /** The Constant icHdrColorSpace - ICC Profile Header Location. */
+ public static final int icHdrColorSpace = 16;
+
+ /** The Constant icHdrPcs - ICC Profile Header Location. */
+ public static final int icHdrPcs = 20;
+
+ /** The Constant icHdrDate - ICC Profile Header Location. */
+ public static final int icHdrDate = 24;
+
+ /** The Constant icHdrMagic - ICC Profile Header Location. */
+ public static final int icHdrMagic = 36;
+
+ /** The Constant icHdrPlatform - ICC Profile Header Location. */
+ public static final int icHdrPlatform = 40;
+
+ /** The Constant icHdrProfileID - ICC Profile Header Location. */
+ public static final int icHdrProfileID = 84;
+
+ /** The Constant icHdrFlags - ICC Profile Header Location. */
+ public static final int icHdrFlags = 44;
+
+ /** The Constant icHdrManufacturer - ICC Profile Header Location. */
+ public static final int icHdrManufacturer = 48;
+
+ /** The Constant icHdrModel - ICC Profile Header Location. */
+ public static final int icHdrModel = 52;
+
+ /** The Constant icHdrAttributes - ICC Profile Header Location. */
+ public static final int icHdrAttributes = 56;
+
+ /** The Constant icHdrRenderingIntent - ICC Profile Header Location. */
+ public static final int icHdrRenderingIntent = 64;
+
+ /** The Constant icHdrIlluminant - ICC Profile Header Location. */
+ public static final int icHdrIlluminant = 68;
+
+ /** The Constant icHdrCreator - ICC Profile Header Location. */
+ public static final int icHdrCreator = 80;
+
+ /** The Constant icICCAbsoluteColorimetric - ICC Profile Rendering Intent. */
+ public static final int icICCAbsoluteColorimetric = 3;
+
+ /** The Constant icMediaRelativeColorimetric - ICC Profile Rendering Intent. */
+ public static final int icMediaRelativeColorimetric = 1;
+
+ /** The Constant icTagType - ICC Profile Constant. */
+ public static final int icTagType = 0;
+
+ /** The Constant icTagReserved - ICC Profile Constant. */
+ public static final int icTagReserved = 4;
+
+ /** The Constant icCurveCount - ICC Profile Constant. */
+ public static final int icCurveCount = 8;
+
+ /** The Constant icCurveData - ICC Profile Constant. */
+ public static final int icCurveData = 12;
+
+ /** The Constant icXYZNumberX - ICC Profile Constant. */
+ public static final int icXYZNumberX = 8;
+
+ /** Size of a profile header. */
+ private static final int headerSize = 128;
+
+ /** header magic number. */
+ private static final int headerMagicNumber = 0x61637370;
+
+ // Cache of predefined profiles
+ /** The s rgb profile. */
+ private static ICC_Profile sRGBProfile;
+
+ /** The xyz profile. */
+ private static ICC_Profile xyzProfile;
+
+ /** The gray profile. */
+ private static ICC_Profile grayProfile;
+
+ /** The pycc profile. */
+ private static ICC_Profile pyccProfile;
+
+ /** The linear rgb profile. */
+ private static ICC_Profile linearRGBProfile;
+
+ /** Handle to the current profile. */
+ private transient long profileHandle = 0;
+
+ /** If handle is used by another class this object is not responsible for closing profile. */
+ private transient boolean handleStolen = false;
+
+ /** Cached header data. */
+ private transient byte[] headerData = null;
+
+ /** Serialization support. */
+ private transient ICC_Profile openedProfileObject;
+
+ /**
+ * Instantiates a new iC c_ profile.
+ *
+ * @param data the data
+ */
+ private ICC_Profile(byte[] data) {
+ profileHandle = NativeCMM.cmmOpenProfile(data);
+ NativeCMM.addHandle(this, profileHandle);
+ }
+
+ /**
+ * Used to instantiate dummy ICC_ProfileStub objects.
+ */
+ ICC_Profile() {
+ }
+
+ /**
+ * Used to instantiate subclasses (ICC_ProfileGrey and ICC_ProfileRGB).
+ *
+ * @param profileHandle - should be valid handle to opened color profile
+ */
+ ICC_Profile(long profileHandle) {
+ this.profileHandle = profileHandle;
+ // A new object reference, need to add it.
+ NativeCMM.addHandle(this, profileHandle);
+ }
+
+ /**
+ * Writes the ICC_Profile to a file with the specified name.
+ *
+ * @param fileName the file name.
+ *
+ * @throws IOException signals that an I/O exception has occurred during
+ * writing or opening the file.
+ */
+ public void write(String fileName) throws IOException {
+ FileOutputStream oStream = new FileOutputStream(fileName);
+ oStream.write(getData());
+ oStream.close();
+ }
+
+ /**
+ * Serializable implementation.
+ *
+ * @param s the s
+ *
+ * @throws IOException Signals that an I/O exception has occurred.
+ */
+ private void writeObject(ObjectOutputStream s) throws IOException {
+ s.defaultWriteObject();
+ s.writeObject(null);
+ s.writeObject(getData());
+ }
+
+ /**
+ * Serializable implementation.
+ *
+ * @param s the s
+ *
+ * @throws IOException Signals that an I/O exception has occurred.
+ * @throws ClassNotFoundException the class not found exception
+ */
+ private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
+ s.defaultReadObject();
+ String colorSpaceStr = (String)s.readObject();
+ byte[] data = (byte[])s.readObject();
+
+ if (colorSpaceStr != null) {
+ if (colorSpaceStr.equals("CS_sRGB")) { //$NON-NLS-1$
+ openedProfileObject = getInstance(ColorSpace.CS_sRGB);
+ } else if (colorSpaceStr.equals("CS_GRAY")) { //$NON-NLS-1$
+ openedProfileObject = getInstance(ColorSpace.CS_GRAY);
+ } else if (colorSpaceStr.equals("CS_LINEAR_RGB")) { //$NON-NLS-1$
+ openedProfileObject = getInstance(ColorSpace.CS_LINEAR_RGB);
+ } else if (colorSpaceStr.equals("CS_CIEXYZ")) { //$NON-NLS-1$
+ openedProfileObject = getInstance(ColorSpace.CS_CIEXYZ);
+ } else if (colorSpaceStr.equals("CS_PYCC")) { //$NON-NLS-1$
+ openedProfileObject = getInstance(ColorSpace.CS_PYCC);
+ } else {
+ openedProfileObject = ICC_Profile.getInstance(data);
+ }
+ } else {
+ openedProfileObject = ICC_Profile.getInstance(data);
+ }
+ }
+
+ /**
+ * Resolves instances being deserialized into instances registered with CMM.
+ *
+ * @return ICC_Profile object for profile registered with CMM.
+ *
+ * @throws ObjectStreamException if there is an error in the serialized
+ * files or during the process of reading them.
+ */
+ protected Object readResolve() throws ObjectStreamException {
+ return openedProfileObject;
+ }
+
+ /**
+ * Writes the ICC_Profile to an OutputStream.
+ *
+ * @param s the OutputStream.
+ *
+ * @throws IOException signals that an I/O exception has occurred during
+ * writing or opening OutputStream.
+ */
+ public void write(OutputStream s) throws IOException {
+ s.write(getData());
+ }
+
+ /**
+ * Sets a tagged data element in the profile from a byte array.
+ *
+ * @param tagSignature the ICC tag signature for the data element to be set.
+ * @param tagData the data to be set for the specified tag signature.
+ */
+ public void setData(int tagSignature, byte[] tagData) {
+ NativeCMM.cmmSetProfileElement(profileHandle, tagSignature, tagData);
+ // Remove cached header data if header is modified
+ if (tagSignature == icSigHead) {
+ headerData = null;
+ }
+ }
+
+ /**
+ * Gets a tagged data element from the profile as a byte array.
+ * Elements are identified by tag signatures as defined in
+ * the ICC specification.
+ *
+ * @param tagSignature the ICC tag signature for the data element to get.
+ *
+ * @return a byte array that contains the tagged data element.
+ */
+ public byte[] getData(int tagSignature) {
+ int tagSize = 0;
+ try {
+ tagSize = NativeCMM.cmmGetProfileElementSize(
+ profileHandle,
+ tagSignature
+ );
+ } catch (CMMException e) {
+ // We'll get this exception if there's no element with
+ // the specified tag signature
+ return null;
+ }
+
+ byte[] data = new byte[tagSize];
+ NativeCMM.cmmGetProfileElement(profileHandle, tagSignature, data);
+ return data;
+ }
+
+ /**
+ * Gets a data byte array of this ICC_Profile.
+ *
+ * @return a byte array that contains the ICC Profile data.
+ */
+ public byte[] getData() {
+ int profileSize = NativeCMM.cmmGetProfileSize(profileHandle);
+ byte[] data = new byte[profileSize];
+ NativeCMM.cmmGetProfile(profileHandle, data);
+ return data;
+ }
+
+ /**
+ * Frees the resources associated with an ICC_Profile object.
+ */
+ @Override
+ protected void finalize() {
+ if (profileHandle!=0 && !handleStolen) {
+ NativeCMM.cmmCloseProfile(profileHandle);
+ }
+
+ // Always remove because key no more exist
+ // when object is destroyed
+ NativeCMM.removeHandle(this);
+ }
+
+ /**
+ * Gets the profile class.
+ *
+ * @return the profile class constant.
+ */
+ public int getProfileClass() {
+ int deviceClassSignature = getIntFromHeader(icHdrDeviceClass);
+
+ switch (deviceClassSignature) {
+ case icSigColorSpaceClass:
+ return CLASS_COLORSPACECONVERSION;
+ case icSigDisplayClass:
+ return CLASS_DISPLAY;
+ case icSigOutputClass:
+ return CLASS_OUTPUT;
+ case icSigInputClass:
+ return CLASS_INPUT;
+ case icSigLinkClass:
+ return CLASS_DEVICELINK;
+ case icSigAbstractClass:
+ return CLASS_ABSTRACT;
+ case icSigNamedColorClass:
+ return CLASS_NAMEDCOLOR;
+ default:
+ }
+
+ // Not an ICC profile class
+ // awt.15F=Profile class does not comply with ICC specification
+ throw new IllegalArgumentException(Messages.getString("awt.15F")); //$NON-NLS-1$
+
+ }
+
+ /**
+ * Returns the color space type of the Profile Connection Space (PCS).
+ *
+ * @return the PCS type.
+ */
+ public int getPCSType() {
+ return csFromSignature(getIntFromHeader(icHdrPcs));
+ }
+
+ /**
+ * Gets the number of components of this ICC Profile.
+ *
+ * @return the number of components of this ICC Profile.
+ */
+ public int getNumComponents() {
+ switch (getIntFromHeader(icHdrColorSpace)) {
+ // The most common cases go first to increase speed
+ case icSigRgbData:
+ case icSigXYZData:
+ case icSigLabData:
+ return 3;
+ case icSigCmykData:
+ return 4;
+ // Then all other
+ case icSigGrayData:
+ return 1;
+ case icSigSpace2CLR:
+ return 2;
+ case icSigYCbCrData:
+ case icSigLuvData:
+ case icSigYxyData:
+ case icSigHlsData:
+ case icSigHsvData:
+ case icSigCmyData:
+ case icSigSpace3CLR:
+ return 3;
+ case icSigSpace4CLR:
+ return 4;
+ case icSigSpace5CLR:
+ return 5;
+ case icSigSpace6CLR:
+ return 6;
+ case icSigSpace7CLR:
+ return 7;
+ case icSigSpace8CLR:
+ return 8;
+ case icSigSpace9CLR:
+ return 9;
+ case icSigSpaceACLR:
+ return 10;
+ case icSigSpaceBCLR:
+ return 11;
+ case icSigSpaceCCLR:
+ return 12;
+ case icSigSpaceDCLR:
+ return 13;
+ case icSigSpaceECLR:
+ return 14;
+ case icSigSpaceFCLR:
+ return 15;
+ default:
+ }
+
+ // awt.160=Color space doesn't comply with ICC specification
+ throw new ProfileDataException(Messages.getString("awt.160") //$NON-NLS-1$
+ );
+ }
+
+ /**
+ * Gets the minor version of this ICC profile.
+ *
+ * @return the minor version of this ICC profile.
+ */
+ public int getMinorVersion() {
+ return getByteFromHeader(icHdrVersion+1);
+ }
+
+ /**
+ * Gets the major version of this ICC profile.
+ *
+ * @return the major version of this ICC profile.
+ */
+ public int getMajorVersion() {
+ return getByteFromHeader(icHdrVersion);
+ }
+
+ /**
+ * Gets the color space type of this ICC_Profile.
+ *
+ * @return the color space type.
+ */
+ public int getColorSpaceType() {
+ return csFromSignature(getIntFromHeader(icHdrColorSpace));
+ }
+
+ /**
+ * Tries to open file at the specified path. Path entries can be
+ * divided by a separator character.
+ *
+ * @param path the path
+ * @param fileName the file name
+ *
+ * @return the file input stream
+ */
+ private static FileInputStream tryPath(String path, String fileName) {
+ FileInputStream fiStream = null;
+
+ if (path == null) {
+ return null;
+ }
+
+ StringTokenizer st = new StringTokenizer(path, File.pathSeparator);
+
+ while (st.hasMoreTokens()) {
+ String pathEntry = st.nextToken();
+ try {
+ fiStream = new FileInputStream(pathEntry + File.separatorChar + fileName);
+ if (fiStream != null) {
+ return fiStream;
+ }
+ } catch (FileNotFoundException e) {}
+ }
+
+ return fiStream;
+ }
+
+ /**
+ * Gets the single instance of ICC_Profile from data in the specified file.
+ *
+ * @param fileName the specified name of file with ICC profile data.
+ *
+ * @return single instance of ICC_Profile.
+ *
+ * @throws IOException signals that an I/O error occured while reading the file
+ * or the file doesn't exist.
+ */
+ public static ICC_Profile getInstance(String fileName) throws IOException {
+ final String fName = fileName; // to use in the privileged block
+
+ FileInputStream fiStream = (FileInputStream) AccessController.doPrivileged(
+ new PrivilegedAction<FileInputStream>() {
+ public FileInputStream run() {
+ FileInputStream fiStream = null;
+
+ // Open absolute path
+ try {
+ fiStream = new FileInputStream(fName);
+ if (fiStream != null) {
+ return fiStream;
+ }
+ } catch (FileNotFoundException e) {}
+
+ // Check java.iccprofile.path entries
+ fiStream = tryPath(System.getProperty("java.iccprofile.path"), fName); //$NON-NLS-1$
+ if (fiStream != null) {
+ return fiStream;
+ }
+
+ // Check java.class.path entries
+ fiStream = tryPath(System.getProperty("java.class.path"), fName); //$NON-NLS-1$
+ if (fiStream != null) {
+ return fiStream;
+ }
+
+ // Check directory with java sample profiles
+ String home = System.getProperty("java.home"); //$NON-NLS-1$
+ if (home != null) {
+ fiStream = tryPath(
+ home + File.separatorChar +
+ "lib" + File.separatorChar + "cmm", fName //$NON-NLS-1$ //$NON-NLS-2$
+ );
+ }
+
+ return fiStream;
+ }
+ });
+
+ if (fiStream == null) {
+ // awt.161=Unable to open file {0}
+ throw new IOException(Messages.getString("awt.161", fileName)); //$NON-NLS-1$
+ }
+
+ ICC_Profile pf = getInstance(fiStream);
+ fiStream.close();
+ return pf;
+ }
+
+ /**
+ * Gets the single instance of ICC_Profile with data in
+ * the specified InputStream.
+ *
+ * @param s the InputStream with ICC profile data.
+ *
+ * @return single instance of ICC_Profile.
+ *
+ * @throws IOException if an I/O exception has occurred during reading
+ * from InputStream.
+ * @throws IllegalArgumentException if the file does not contain valid
+ * ICC Profile data.
+ */
+ public static ICC_Profile getInstance(InputStream s) throws IOException {
+ byte[] header = new byte[headerSize];
+ // awt.162=Invalid ICC Profile Data
+ String invalidDataMessage = Messages.getString("awt.162"); //$NON-NLS-1$
+
+ // Get header from the input stream
+ if (s.read(header) != headerSize) {
+ throw new IllegalArgumentException(invalidDataMessage);
+ }
+
+ // Check the profile data for consistency
+ if (
+ ICC_ProfileHelper.getBigEndianFromByteArray(header, icHdrMagic) !=
+ headerMagicNumber
+ ) {
+ throw new IllegalArgumentException(invalidDataMessage);
+ }
+
+ // Get profile size from header, create an array for profile data
+ int profileSize = ICC_ProfileHelper.getBigEndianFromByteArray(header, icHdrSize);
+ byte[] profileData = new byte[profileSize];
+
+ // Copy header into it
+ System.arraycopy(header, 0, profileData, 0, headerSize);
+
+ // Read the profile itself
+ if (
+ s.read(profileData, headerSize, profileSize - headerSize) !=
+ profileSize - headerSize
+ ) {
+ throw new IllegalArgumentException(invalidDataMessage);
+ }
+
+ return getInstance(profileData);
+ }
+
+ /**
+ * Gets the single instance of ICC_Profile from the specified data in
+ * a byte array.
+ *
+ * @param data the byte array of ICC profile.
+ *
+ * @return single instance of ICC_Profile from the specified data in
+ * a byte array.
+ *
+ * @throws IllegalArgumentException if the file does not contain valid
+ * ICC Profile data.
+ */
+ public static ICC_Profile getInstance(byte[] data) {
+ ICC_Profile res = null;
+
+ try {
+ res = new ICC_Profile(data);
+ } catch (CMMException e) {
+ // awt.162=Invalid ICC Profile Data
+ throw new IllegalArgumentException(Messages.getString("awt.162")); //$NON-NLS-1$
+ }
+
+ if (System.getProperty("os.name").toLowerCase().indexOf("windows") >= 0) { //$NON-NLS-1$ //$NON-NLS-2$
+ try {
+ if ( res.getColorSpaceType () == ColorSpace.TYPE_RGB &&
+ res.getDataSize(icSigMediaWhitePointTag) > 0 &&
+ res.getDataSize(icSigRedColorantTag) > 0 &&
+ res.getDataSize(icSigGreenColorantTag) > 0 &&
+ res.getDataSize(icSigBlueColorantTag) > 0 &&
+ res.getDataSize(icSigRedTRCTag) > 0 &&
+ res.getDataSize(icSigGreenTRCTag) > 0 &&
+ res.getDataSize(icSigBlueTRCTag) > 0
+ ) {
+ res = new ICC_ProfileRGB(res.getProfileHandle());
+ } else if ( res.getColorSpaceType () == ColorSpace.TYPE_GRAY &&
+ res.getDataSize(icSigMediaWhitePointTag) > 0 &&
+ res.getDataSize(icSigGrayTRCTag) > 0
+ ) {
+ res = new ICC_ProfileGray (res.getProfileHandle());
+ }
+
+ } catch (CMMException e) { /* return res in this case */ }
+ }
+
+ return res;
+ }
+
+ /**
+ * Gets the single instance of ICC_Profile with the specific color space
+ * defined by the ColorSpace class: CS_sRGB, CS_LINEAR_RGB, CS_CIEXYZ,
+ * CS_PYCC, CS_GRAY.
+ *
+ * @param cspace the type of color space defined in the ColorSpace class.
+ *
+ * @return single instance of ICC_Profile.
+ *
+ * @throws IllegalArgumentException is not one of the defined color
+ * space types.
+ */
+ public static ICC_Profile getInstance(int cspace) {
+ try {
+ switch (cspace) {
+
+ case ColorSpace.CS_sRGB:
+ if (sRGBProfile == null) {
+ sRGBProfile = getInstance("sRGB.pf"); //$NON-NLS-1$
+ }
+ return sRGBProfile;
+
+ case ColorSpace.CS_CIEXYZ:
+ if (xyzProfile == null) {
+ xyzProfile = getInstance("CIEXYZ.pf"); //$NON-NLS-1$
+ }
+ return xyzProfile;
+
+ case ColorSpace.CS_GRAY:
+ if (grayProfile == null) {
+ grayProfile = getInstance("GRAY.pf"); //$NON-NLS-1$
+ }
+ return grayProfile;
+
+ case ColorSpace.CS_PYCC:
+ if (pyccProfile == null) {
+ pyccProfile = getInstance("PYCC.pf"); //$NON-NLS-1$
+ }
+ return pyccProfile;
+
+ case ColorSpace.CS_LINEAR_RGB:
+ if (linearRGBProfile == null) {
+ linearRGBProfile = getInstance("LINEAR_RGB.pf"); //$NON-NLS-1$
+ }
+ return linearRGBProfile;
+ }
+
+ } catch (IOException e) {
+ // awt.163=Can't open color profile
+ throw new IllegalArgumentException(Messages.getString("Can't open color profile")); //$NON-NLS-1$
+ }
+
+ // awt.164=Not a predefined color space
+ throw new IllegalArgumentException(Messages.getString("Not a predefined color space")); //$NON-NLS-1$
+ }
+
+ /**
+ * Reads an integer from the profile header at the specified position.
+ *
+ * @param idx - offset in bytes from the beginning of the header
+ *
+ * @return the int from header
+ */
+ private int getIntFromHeader(int idx) {
+ if (headerData == null) {
+ headerData = getData(icSigHead);
+ }
+
+ return ((headerData[idx] & 0xFF) << 24)|
+ ((headerData[idx+1] & 0xFF) << 16)|
+ ((headerData[idx+2] & 0xFF) << 8) |
+ ((headerData[idx+3] & 0xFF));
+ }
+
+ /**
+ * Reads byte from the profile header at the specified position.
+ *
+ * @param idx - offset in bytes from the beginning of the header
+ *
+ * @return the byte from header
+ */
+ private byte getByteFromHeader(int idx) {
+ if (headerData == null) {
+ headerData = getData(icSigHead);
+ }
+
+ return headerData[idx];
+ }
+
+ /**
+ * Converts ICC color space signature to the java predefined
+ * color space type.
+ *
+ * @param signature the signature
+ *
+ * @return the int
+ */
+ private int csFromSignature(int signature) {
+ switch (signature) {
+ case icSigRgbData:
+ return ColorSpace.TYPE_RGB;
+ case icSigXYZData:
+ return ColorSpace.TYPE_XYZ;
+ case icSigCmykData:
+ return ColorSpace.TYPE_CMYK;
+ case icSigLabData:
+ return ColorSpace.TYPE_Lab;
+ case icSigGrayData:
+ return ColorSpace.TYPE_GRAY;
+ case icSigHlsData:
+ return ColorSpace.TYPE_HLS;
+ case icSigLuvData:
+ return ColorSpace.TYPE_Luv;
+ case icSigYCbCrData:
+ return ColorSpace.TYPE_YCbCr;
+ case icSigYxyData:
+ return ColorSpace.TYPE_Yxy;
+ case icSigHsvData:
+ return ColorSpace.TYPE_HSV;
+ case icSigCmyData:
+ return ColorSpace.TYPE_CMY;
+ case icSigSpace2CLR:
+ return ColorSpace.TYPE_2CLR;
+ case icSigSpace3CLR:
+ return ColorSpace.TYPE_3CLR;
+ case icSigSpace4CLR:
+ return ColorSpace.TYPE_4CLR;
+ case icSigSpace5CLR:
+ return ColorSpace.TYPE_5CLR;
+ case icSigSpace6CLR:
+ return ColorSpace.TYPE_6CLR;
+ case icSigSpace7CLR:
+ return ColorSpace.TYPE_7CLR;
+ case icSigSpace8CLR:
+ return ColorSpace.TYPE_8CLR;
+ case icSigSpace9CLR:
+ return ColorSpace.TYPE_9CLR;
+ case icSigSpaceACLR:
+ return ColorSpace.TYPE_ACLR;
+ case icSigSpaceBCLR:
+ return ColorSpace.TYPE_BCLR;
+ case icSigSpaceCCLR:
+ return ColorSpace.TYPE_CCLR;
+ case icSigSpaceDCLR:
+ return ColorSpace.TYPE_DCLR;
+ case icSigSpaceECLR:
+ return ColorSpace.TYPE_ECLR;
+ case icSigSpaceFCLR:
+ return ColorSpace.TYPE_FCLR;
+ default:
+ }
+
+ // awt.165=Color space doesn't comply with ICC specification
+ throw new IllegalArgumentException (Messages.getString("awt.165")); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the profile handle.
+ *
+ * @return the profile handle
+ */
+ private long getProfileHandle() {
+ handleStolen = true;
+ return profileHandle;
+ }
+
+ /**
+ * Gets the data size.
+ *
+ * @param tagSignature the tag signature
+ *
+ * @return the data size
+ */
+ private int getDataSize(int tagSignature) {
+ return NativeCMM.cmmGetProfileElementSize(
+ profileHandle,
+ tagSignature
+ );
+ }
+
+ /**
+ * Reads XYZ value from the tag data.
+ *
+ * @param tagSignature the tag signature
+ *
+ * @return the XYZ value
+ */
+ float[] getXYZValue(int tagSignature) {
+ float[] res = new float[3];
+ byte[] data = getData(tagSignature);
+
+ // Convert from ICC s15Fixed16Number type
+ // 1 (float) = 0x10000 (s15Fixed16Number),
+ // hence dividing by 0x10000
+ res[0] = ICC_ProfileHelper.getIntFromByteArray(data, 0) / 65536.f;
+ res[1] = ICC_ProfileHelper.getIntFromByteArray(data, 4) / 65536.f;
+ res[2] = ICC_ProfileHelper.getIntFromByteArray(data, 8) / 65536.f;
+
+ return res;
+ }
+
+ /**
+ * Gets the media white point.
+ *
+ * @return the media white point
+ */
+ float[] getMediaWhitePoint() {
+ return getXYZValue(icSigMediaWhitePointTag);
+ }
+
+ /**
+ * If TRC is not a table returns gamma via return value
+ * and sets dataTRC to null. If TRC is a table returns 0
+ * and fills dataTRC with values.
+ *
+ * @param tagSignature the tag signature
+ * @param dataTRC the data trc
+ *
+ * @return - gamma or zero if TRC is a table
+ */
+ private float getGammaOrTRC(int tagSignature, short[] dataTRC) {
+ byte[] data = getData(tagSignature);
+ int trcSize = ICC_ProfileHelper.getIntFromByteArray(data, icCurveCount);
+
+ dataTRC = null;
+
+ if (trcSize == 0) {
+ return 1.0f;
+ }
+
+ if (trcSize == 1) {
+ // Cast from ICC u8Fixed8Number to float
+ return ICC_ProfileHelper.getShortFromByteArray(data, icCurveData) / 256.f;
+ }
+
+ // TRC is a table
+ dataTRC = new short[trcSize];
+ for (int i = 0, pos = icCurveData; i < trcSize; i++, pos += 2) {
+ dataTRC[i] = ICC_ProfileHelper.getShortFromByteArray(data, pos);
+ }
+ return 0;
+ }
+
+ /**
+ * Gets the gamma.
+ *
+ * @param tagSignature the tag signature
+ *
+ * @return the gamma
+ */
+ float getGamma(int tagSignature) {
+ short[] dataTRC = null;
+ float gamma = getGammaOrTRC(tagSignature, dataTRC);
+
+ if (dataTRC == null) {
+ return gamma;
+ }
+ // awt.166=TRC is not a simple gamma value.
+ throw new ProfileDataException(Messages.getString("awt.166")); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the tRC.
+ *
+ * @param tagSignature the tag signature
+ *
+ * @return the tRC
+ */
+ short[] getTRC(int tagSignature) {
+ short[] dataTRC = null;
+ getGammaOrTRC(tagSignature, dataTRC);
+
+ if (dataTRC == null) {
+ // awt.167=TRC is a gamma value, not a table.
+ throw new ProfileDataException(Messages.getString("awt.167")); //$NON-NLS-1$
+ }
+ return dataTRC;
+ }
+}
+
diff --git a/awt/java/awt/color/ICC_ProfileGray.java b/awt/java/awt/color/ICC_ProfileGray.java
new file mode 100644
index 0000000..f009b18
--- /dev/null
+++ b/awt/java/awt/color/ICC_ProfileGray.java
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+package java.awt.color;
+
+/**
+ * The ICC_ProfileGray class represent profiles with TYPE_GRAY color space type,
+ * and includes the grayTRCTag and mediaWhitePointTag tags.
+ *
+ * The gray component can be transformed from a GRAY device profile color space
+ * to the CIEXYZ Profile through the tone reproduction curve (TRC):
+ * <p>PCSY = grayTRC[deviceGray]
+ */
+public class ICC_ProfileGray extends ICC_Profile {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -1124721290732002649L;
+
+ /**
+ * Instantiates a new iC c_ profile gray.
+ *
+ * @param profileHandle the profile handle
+ */
+ ICC_ProfileGray(long profileHandle) {
+ super(profileHandle);
+ }
+
+ /**
+ * Gets the TRC as an array of shorts.
+ *
+ * @return a short array of the TRC.
+ */
+ public short[] getTRC() {
+ return super.getTRC(icSigGrayTRCTag);
+ }
+
+ @Override
+ public float[] getMediaWhitePoint() {
+ return super.getMediaWhitePoint();
+ }
+
+ /**
+ * Gets a gamma value representing the tone reproduction curve (TRC).
+ *
+ * @return the gamma value representing the tone reproduction curve (TRC).
+ */
+ public float getGamma() {
+ return super.getGamma(icSigGrayTRCTag);
+ }
+}
+
diff --git a/awt/java/awt/color/ICC_ProfileRGB.java b/awt/java/awt/color/ICC_ProfileRGB.java
new file mode 100644
index 0000000..beb1a0c
--- /dev/null
+++ b/awt/java/awt/color/ICC_ProfileRGB.java
@@ -0,0 +1,122 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+package java.awt.color;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The ICC_ProfileRGB class represents profiles with RGB color space type and
+ * contains the redColorantTag, greenColorantTag, blueColorantTag, redTRCTag,
+ * greenTRCTag, blueTRCTag, and mediaWhitePointTag tags.
+ */
+public class ICC_ProfileRGB extends ICC_Profile {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 8505067385152579334L;
+
+ /**
+ * Instantiates a new iC c_ profile rgb.
+ *
+ * @param profileHandle the profile handle
+ */
+ ICC_ProfileRGB(long profileHandle) {
+ super(profileHandle);
+ }
+
+ /** The Constant REDCOMPONENT indicates the red component. */
+ public static final int REDCOMPONENT = 0;
+
+ /** The Constant GREENCOMPONENT indicates the green component. */
+ public static final int GREENCOMPONENT = 1;
+
+ /** The Constant BLUECOMPONENT indicates the blue component. */
+ public static final int BLUECOMPONENT = 2;
+
+ // awt.15E=Unknown component. Must be REDCOMPONENT, GREENCOMPONENT or BLUECOMPONENT.
+ /** The Constant UNKNOWN_COMPONENT_MSG. */
+ private static final String UNKNOWN_COMPONENT_MSG = Messages
+ .getString("awt.15E"); //$NON-NLS-1$
+
+ @Override
+ public short[] getTRC(int component) {
+ switch (component) {
+ case REDCOMPONENT:
+ return super.getTRC(icSigRedTRCTag);
+ case GREENCOMPONENT:
+ return super.getTRC(icSigGreenTRCTag);
+ case BLUECOMPONENT:
+ return super.getTRC(icSigBlueTRCTag);
+ default:
+ }
+
+ throw new IllegalArgumentException(UNKNOWN_COMPONENT_MSG);
+ }
+
+ @Override
+ public float getGamma(int component) {
+ switch (component) {
+ case REDCOMPONENT:
+ return super.getGamma(icSigRedTRCTag);
+ case GREENCOMPONENT:
+ return super.getGamma(icSigGreenTRCTag);
+ case BLUECOMPONENT:
+ return super.getGamma(icSigBlueTRCTag);
+ default:
+ }
+
+ throw new IllegalArgumentException(UNKNOWN_COMPONENT_MSG);
+ }
+
+ /**
+ * Gets a float matrix which contains the X, Y, and Z components of
+ * the profile's redColorantTag, greenColorantTag, and blueColorantTag.
+ *
+ * @return a float matrix which contains the X, Y, and Z components of
+ * the profile's redColorantTag, greenColorantTag, and blueColorantTag.
+ */
+ public float[][] getMatrix() {
+ float [][] m = new float[3][3]; // The matrix
+
+ float[] redXYZ = getXYZValue(icSigRedColorantTag);
+ float[] greenXYZ = getXYZValue(icSigGreenColorantTag);
+ float[] blueXYZ = getXYZValue(icSigBlueColorantTag);
+
+ m[0][0] = redXYZ[0];
+ m[1][0] = redXYZ[1];
+ m[2][0] = redXYZ[2];
+
+ m[0][1] = greenXYZ[0];
+ m[1][1] = greenXYZ[1];
+ m[2][1] = greenXYZ[2];
+
+ m[0][2] = blueXYZ[0];
+ m[1][2] = blueXYZ[1];
+ m[2][2] = blueXYZ[2];
+
+ return m;
+ }
+
+ @Override
+ public float[] getMediaWhitePoint() {
+ return super.getMediaWhitePoint();
+ }
+}
+
diff --git a/awt/java/awt/color/ICC_ProfileStub.java b/awt/java/awt/color/ICC_ProfileStub.java
new file mode 100644
index 0000000..bc04c8a
--- /dev/null
+++ b/awt/java/awt/color/ICC_ProfileStub.java
@@ -0,0 +1,173 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+
+package java.awt.color;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectStreamException;
+import java.io.OutputStream;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+final class ICC_ProfileStub extends ICC_Profile {
+ private static final long serialVersionUID = 501389760875253507L;
+
+ transient int colorspace;
+
+ public ICC_ProfileStub(int csSpecifier) {
+ switch (csSpecifier) {
+ case ColorSpace.CS_sRGB:
+ case ColorSpace.CS_CIEXYZ:
+ case ColorSpace.CS_LINEAR_RGB:
+ case ColorSpace.CS_PYCC:
+ case ColorSpace.CS_GRAY:
+ break;
+ default:
+ // awt.15D=Invalid colorspace
+ throw new IllegalArgumentException(Messages.getString("awt.15D")); //$NON-NLS-1$
+ }
+ colorspace = csSpecifier;
+ }
+
+ @Override
+ public void write(String fileName) throws IOException {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ /**
+ * Serializable implementation
+ *
+ * @throws ObjectStreamException
+ */
+ private Object writeReplace() throws ObjectStreamException {
+ return loadProfile();
+ }
+
+ @Override
+ public void write(OutputStream s) throws IOException {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ @Override
+ public void setData(int tagSignature, byte[] tagData) {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ @Override
+ public byte[] getData(int tagSignature) {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ @Override
+ public byte[] getData() {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ @Override
+ protected void finalize() {
+ }
+
+ @Override
+ public int getProfileClass() {
+ return CLASS_COLORSPACECONVERSION;
+ }
+
+ @Override
+ public int getPCSType() {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ @Override
+ public int getNumComponents() {
+ switch (colorspace) {
+ case ColorSpace.CS_sRGB:
+ case ColorSpace.CS_CIEXYZ:
+ case ColorSpace.CS_LINEAR_RGB:
+ case ColorSpace.CS_PYCC:
+ return 3;
+ case ColorSpace.CS_GRAY:
+ return 1;
+ default:
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+ }
+
+ @Override
+ public int getMinorVersion() {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ @Override
+ public int getMajorVersion() {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ @Override
+ public int getColorSpaceType() {
+ switch (colorspace) {
+ case ColorSpace.CS_sRGB:
+ case ColorSpace.CS_LINEAR_RGB:
+ return ColorSpace.TYPE_RGB;
+ case ColorSpace.CS_CIEXYZ:
+ return ColorSpace.TYPE_XYZ;
+ case ColorSpace.CS_PYCC:
+ return ColorSpace.TYPE_3CLR;
+ case ColorSpace.CS_GRAY:
+ return ColorSpace.TYPE_GRAY;
+ default:
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+ }
+
+ public static ICC_Profile getInstance(String fileName) throws IOException {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ public static ICC_Profile getInstance(InputStream s) throws IOException {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ public static ICC_Profile getInstance(byte[] data) {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ public static ICC_Profile getInstance(int cspace) {
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+
+ public ICC_Profile loadProfile() {
+ switch (colorspace) {
+ case ColorSpace.CS_sRGB:
+ return ICC_Profile.getInstance(ColorSpace.CS_sRGB);
+ case ColorSpace.CS_GRAY:
+ return ICC_Profile.getInstance(ColorSpace.CS_GRAY);
+ case ColorSpace.CS_CIEXYZ:
+ return ICC_Profile.getInstance(ColorSpace.CS_CIEXYZ);
+ case ColorSpace.CS_LINEAR_RGB:
+ return ICC_Profile.getInstance(ColorSpace.CS_LINEAR_RGB);
+ case ColorSpace.CS_PYCC:
+ return ICC_Profile.getInstance(ColorSpace.CS_PYCC);
+ default:
+ throw new UnsupportedOperationException("Stub cannot perform this operation"); //$NON-NLS-1$
+ }
+ }
+}
\ No newline at end of file
diff --git a/awt/java/awt/color/ProfileDataException.java b/awt/java/awt/color/ProfileDataException.java
new file mode 100644
index 0000000..ca169fe
--- /dev/null
+++ b/awt/java/awt/color/ProfileDataException.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+package java.awt.color;
+
+/**
+ * The ProfileDataException class represents an error which occurs
+ * while accessing or processing an ICC_Profile object.
+ */
+public class ProfileDataException extends RuntimeException {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 7286140888240322498L;
+
+ /**
+ * Instantiates a new profile data exception with detailed message.
+ *
+ * @param s the detailed message.
+ */
+ public ProfileDataException(String s) {
+ super(s);
+ }
+
+}
+
diff --git a/awt/java/awt/event/AWTEventListener.java b/awt/java/awt/event/AWTEventListener.java
new file mode 100644
index 0000000..f621c9b
--- /dev/null
+++ b/awt/java/awt/event/AWTEventListener.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+import java.util.EventListener;
+
+public interface AWTEventListener extends EventListener {
+
+ public void eventDispatched(AWTEvent event);
+
+}
diff --git a/awt/java/awt/event/AWTEventListenerProxy.java b/awt/java/awt/event/AWTEventListenerProxy.java
new file mode 100644
index 0000000..5ee5e59
--- /dev/null
+++ b/awt/java/awt/event/AWTEventListenerProxy.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+
+import java.util.EventListenerProxy;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+public class AWTEventListenerProxy extends EventListenerProxy implements AWTEventListener {
+
+ private AWTEventListener listener;
+ private long eventMask;
+
+ public AWTEventListenerProxy(long eventMask, AWTEventListener listener) {
+ super(listener);
+
+ // awt.193=Listener can't be zero
+ assert listener != null : Messages.getString("awt.193"); //$NON-NLS-1$
+
+ this.listener = listener;
+ this.eventMask = eventMask;
+ }
+
+ public void eventDispatched(AWTEvent evt) {
+ listener.eventDispatched(evt);
+ }
+
+ public long getEventMask() {
+ return eventMask;
+ }
+
+}
diff --git a/awt/java/awt/event/ActionEvent.java b/awt/java/awt/event/ActionEvent.java
new file mode 100644
index 0000000..c32fc4b
--- /dev/null
+++ b/awt/java/awt/event/ActionEvent.java
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+
+public class ActionEvent extends AWTEvent {
+
+ private static final long serialVersionUID = -7671078796273832149L;
+
+ public static final int SHIFT_MASK = 1;
+
+ public static final int CTRL_MASK = 2;
+
+ public static final int META_MASK = 4;
+
+ public static final int ALT_MASK = 8;
+
+ public static final int ACTION_FIRST = 1001;
+
+ public static final int ACTION_LAST = 1001;
+
+ public static final int ACTION_PERFORMED = 1001;
+
+ private long when;
+ private int modifiers;
+ private String command;
+
+ public ActionEvent(Object source, int id, String command) {
+ this(source, id, command, 0);
+ }
+
+ public ActionEvent(Object source, int id, String command, int modifiers) {
+ this(source, id, command, 0l, modifiers);
+ }
+
+ public ActionEvent(Object source, int id, String command, long when, int modifiers) {
+ super(source, id);
+
+ this.command = command;
+ this.when = when;
+ this.modifiers = modifiers;
+ }
+
+ public int getModifiers() {
+ return modifiers;
+ }
+
+ public String getActionCommand() {
+ return command;
+ }
+
+ public long getWhen() {
+ return when;
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * ActionEvent e = new ActionEvent(new Component(){},
+ * ActionEvent.ACTION_PERFORMED, "Command",
+ * ActionEvent.SHIFT_MASK|ActionEvent.CTRL_MASK|
+ * ActionEvent.META_MASK|ActionEvent.ALT_MASK);
+ * System.out.println(e);
+ */
+
+ String idString = (id == ACTION_PERFORMED) ?
+ "ACTION_PERFORMED" : "unknown type"; //$NON-NLS-1$ //$NON-NLS-2$
+ String modifiersString = ""; //$NON-NLS-1$
+
+ if ((modifiers & SHIFT_MASK) > 0) {
+ modifiersString += "Shift"; //$NON-NLS-1$
+ }
+ if ((modifiers & CTRL_MASK) > 0) {
+ modifiersString += modifiersString.length() == 0 ? "Ctrl" : "+Ctrl"; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if ((modifiers & META_MASK) > 0) {
+ modifiersString += modifiersString.length() == 0 ? "Meta" : "+Meta"; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if ((modifiers & ALT_MASK) > 0) {
+ modifiersString += modifiersString.length() == 0 ? "Alt" : "+Alt"; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ return (idString + ",cmd=" + command + ",when=" + when + //$NON-NLS-1$ //$NON-NLS-2$
+ ",modifiers=" + modifiersString); //$NON-NLS-1$
+ }
+
+}
diff --git a/awt/java/awt/event/ActionListener.java b/awt/java/awt/event/ActionListener.java
new file mode 100644
index 0000000..473d2b6
--- /dev/null
+++ b/awt/java/awt/event/ActionListener.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface ActionListener extends EventListener {
+
+ public void actionPerformed(ActionEvent e);
+
+}
diff --git a/awt/java/awt/event/AdjustmentEvent.java b/awt/java/awt/event/AdjustmentEvent.java
new file mode 100644
index 0000000..a2b11a8
--- /dev/null
+++ b/awt/java/awt/event/AdjustmentEvent.java
@@ -0,0 +1,117 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+import java.awt.Adjustable;
+
+public class AdjustmentEvent extends AWTEvent {
+
+ private static final long serialVersionUID = 5700290645205279921L;
+
+ public static final int ADJUSTMENT_FIRST = 601;
+
+ public static final int ADJUSTMENT_LAST = 601;
+
+ public static final int ADJUSTMENT_VALUE_CHANGED = 601;
+
+ public static final int UNIT_INCREMENT = 1;
+
+ public static final int UNIT_DECREMENT = 2;
+
+ public static final int BLOCK_DECREMENT = 3;
+
+ public static final int BLOCK_INCREMENT = 4;
+
+ public static final int TRACK = 5;
+
+ private int type;
+ private int value;
+ private boolean isAdjusting;
+
+ public AdjustmentEvent(Adjustable source, int id, int type, int value) {
+ this(source, id, type, value, false);
+ }
+
+ public AdjustmentEvent(Adjustable source, int id, int type, int value,
+ boolean isAdjusting) {
+ super(source, id);
+ this.type = type;
+ this.value = value;
+ this.isAdjusting = isAdjusting;
+ }
+
+ public int getValue() {
+ return value;
+ }
+
+ public int getAdjustmentType() {
+ return type;
+ }
+
+ public boolean getValueIsAdjusting() {
+ return isAdjusting;
+ }
+
+ public Adjustable getAdjustable() {
+ return (Adjustable) source;
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * AdjustmentEvent e = new AdjustmentEvent(new Scrollbar(),
+ * AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
+ * AdjustmentEvent.UNIT_INCREMENT, 1);
+ * System.out.println(e);
+ */
+
+ String idString = (id == ADJUSTMENT_VALUE_CHANGED ?
+ "ADJUSTMENT_VALUE_CHANGED" : "unknown type"); //$NON-NLS-1$ //$NON-NLS-2$
+ String adjType = null;
+
+ switch (type) {
+ case UNIT_INCREMENT:
+ adjType = "UNIT_INCREMENT"; //$NON-NLS-1$
+ break;
+ case UNIT_DECREMENT:
+ adjType = "UNIT_DECREMENT"; //$NON-NLS-1$
+ break;
+ case BLOCK_INCREMENT:
+ adjType = "BLOCK_INCREMENT"; //$NON-NLS-1$
+ break;
+ case BLOCK_DECREMENT:
+ adjType = "BLOCK_DECREMENT"; //$NON-NLS-1$
+ break;
+ case TRACK:
+ adjType = "TRACK"; //$NON-NLS-1$
+ break;
+ default:
+ adjType = "unknown type"; //$NON-NLS-1$
+ }
+
+ return (idString + ",adjType=" + adjType + ",value=" + value + //$NON-NLS-1$ //$NON-NLS-2$
+ ",isAdjusting=" + isAdjusting); //$NON-NLS-1$
+ }
+
+}
diff --git a/awt/java/awt/event/AdjustmentListener.java b/awt/java/awt/event/AdjustmentListener.java
new file mode 100644
index 0000000..ef7c378
--- /dev/null
+++ b/awt/java/awt/event/AdjustmentListener.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface AdjustmentListener extends EventListener {
+
+ public void adjustmentValueChanged(AdjustmentEvent e);
+
+}
diff --git a/awt/java/awt/event/ComponentAdapter.java b/awt/java/awt/event/ComponentAdapter.java
new file mode 100644
index 0000000..4f0bd90
--- /dev/null
+++ b/awt/java/awt/event/ComponentAdapter.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+public abstract class ComponentAdapter implements ComponentListener {
+
+ public ComponentAdapter() {
+ }
+
+ public void componentHidden(ComponentEvent e) {
+ }
+
+ public void componentMoved(ComponentEvent e) {
+ }
+
+ public void componentResized(ComponentEvent e) {
+ }
+
+ public void componentShown(ComponentEvent e) {
+ }
+
+}
diff --git a/awt/java/awt/event/ComponentEvent.java b/awt/java/awt/event/ComponentEvent.java
new file mode 100644
index 0000000..d0bca54
--- /dev/null
+++ b/awt/java/awt/event/ComponentEvent.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+import java.awt.Component;
+
+public class ComponentEvent extends AWTEvent {
+
+ private static final long serialVersionUID = 8101406823902992965L;
+
+ public static final int COMPONENT_FIRST = 100;
+
+ public static final int COMPONENT_LAST = 103;
+
+ public static final int COMPONENT_MOVED = 100;
+
+ public static final int COMPONENT_RESIZED = 101;
+
+ public static final int COMPONENT_SHOWN = 102;
+
+ public static final int COMPONENT_HIDDEN = 103;
+
+ public ComponentEvent(Component source, int id) {
+ super(source, id);
+ }
+
+ public Component getComponent() {
+ return (Component) source;
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * ComponentEvent e = new ComponentEvent(new Button("Button"),
+ * ComponentEvent.COMPONENT_SHOWN);
+ * System.out.println(e);
+ */
+
+ String idString = null;
+ Component c = getComponent();
+
+ switch (id) {
+ case COMPONENT_MOVED:
+ idString = "COMPONENT_MOVED"; //$NON-NLS-1$
+ break;
+ case COMPONENT_RESIZED:
+ idString = "COMPONENT_RESIZED"; //$NON-NLS-1$
+ break;
+ case COMPONENT_SHOWN:
+ return "COMPONENT_SHOWN"; //$NON-NLS-1$
+ case COMPONENT_HIDDEN:
+ return "COMPONENT_HIDDEN"; //$NON-NLS-1$
+ default:
+ return "unknown type"; //$NON-NLS-1$
+ }
+
+ return (idString + " (" + c.getX() + "," + c.getY() + //$NON-NLS-1$ //$NON-NLS-2$
+ " " + c.getWidth()+ "x" + c.getHeight() + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+}
diff --git a/awt/java/awt/event/ComponentListener.java b/awt/java/awt/event/ComponentListener.java
new file mode 100644
index 0000000..147e9e0
--- /dev/null
+++ b/awt/java/awt/event/ComponentListener.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface ComponentListener extends EventListener {
+
+ public void componentHidden(ComponentEvent e);
+
+ public void componentMoved(ComponentEvent e);
+
+ public void componentResized(ComponentEvent e);
+
+ public void componentShown(ComponentEvent e);
+
+}
diff --git a/awt/java/awt/event/ContainerAdapter.java b/awt/java/awt/event/ContainerAdapter.java
new file mode 100644
index 0000000..12dc3de
--- /dev/null
+++ b/awt/java/awt/event/ContainerAdapter.java
@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+public abstract class ContainerAdapter implements ContainerListener {
+
+ public ContainerAdapter() {
+ }
+
+ public void componentAdded(ContainerEvent e) {
+ }
+
+ public void componentRemoved(ContainerEvent e) {
+ }
+
+}
diff --git a/awt/java/awt/event/ContainerEvent.java b/awt/java/awt/event/ContainerEvent.java
new file mode 100644
index 0000000..1a1055c
--- /dev/null
+++ b/awt/java/awt/event/ContainerEvent.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.Component;
+//???AWT: import java.awt.Container;
+
+public class ContainerEvent extends ComponentEvent {
+
+ private static final long serialVersionUID = -4114942250539772041L;
+
+ public static final int CONTAINER_FIRST = 300;
+
+ public static final int CONTAINER_LAST = 301;
+
+ public static final int COMPONENT_ADDED = 300;
+
+ public static final int COMPONENT_REMOVED = 301;
+
+ private Component child;
+
+ public ContainerEvent(Component src, int id, Component child) {
+ super(src, id);
+ this.child = child;
+ }
+
+ public Component getChild() {
+ return child;
+ }
+
+ //???AWT
+ /*
+ public Container getContainer() {
+ return (Container) source;
+ }
+ */
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * ContainerEvent e = new ContainerEvent(new Panel(),
+ * ContainerEvent.COMPONENT_ADDED,
+ * new Button("Button"));
+ * System.out.println(e);
+ */
+
+ String idString = null;
+
+ switch (id) {
+ case COMPONENT_ADDED:
+ idString = "COMPONENT_ADDED"; //$NON-NLS-1$
+ break;
+ case COMPONENT_REMOVED:
+ idString = "COMPONENT_REMOVED"; //$NON-NLS-1$
+ break;
+ default:
+ idString = "unknown type"; //$NON-NLS-1$
+ }
+
+ return (idString + ",child=" + child.getName()); //$NON-NLS-1$
+ }
+
+}
diff --git a/awt/java/awt/event/ContainerListener.java b/awt/java/awt/event/ContainerListener.java
new file mode 100644
index 0000000..bf47664
--- /dev/null
+++ b/awt/java/awt/event/ContainerListener.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface ContainerListener extends EventListener {
+
+ public void componentAdded(ContainerEvent e);
+
+ public void componentRemoved(ContainerEvent e);
+
+}
diff --git a/awt/java/awt/event/FocusAdapter.java b/awt/java/awt/event/FocusAdapter.java
new file mode 100644
index 0000000..3489e11
--- /dev/null
+++ b/awt/java/awt/event/FocusAdapter.java
@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+public abstract class FocusAdapter implements FocusListener {
+
+ public FocusAdapter() {
+ }
+
+ public void focusGained(FocusEvent e) {
+ }
+
+ public void focusLost(FocusEvent e) {
+ }
+
+}
diff --git a/awt/java/awt/event/FocusEvent.java b/awt/java/awt/event/FocusEvent.java
new file mode 100644
index 0000000..1db5263
--- /dev/null
+++ b/awt/java/awt/event/FocusEvent.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.Component;
+
+public class FocusEvent extends ComponentEvent {
+
+ private static final long serialVersionUID = 523753786457416396L;
+
+ public static final int FOCUS_FIRST = 1004;
+
+ public static final int FOCUS_LAST = 1005;
+
+ public static final int FOCUS_GAINED = 1004;
+
+ public static final int FOCUS_LOST = 1005;
+
+ private boolean temporary;
+ private Component opposite;
+
+ public FocusEvent(Component source, int id) {
+ this(source, id, false);
+ }
+
+ public FocusEvent(Component source, int id, boolean temporary) {
+ this(source, id, temporary, null);
+ }
+
+ public FocusEvent(Component source, int id, boolean temporary, Component opposite) {
+ super(source, id);
+ this.temporary = temporary;
+ this.opposite = opposite;
+ }
+
+ public Component getOppositeComponent() {
+ return opposite;
+ }
+
+ public boolean isTemporary() {
+ return temporary;
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * FocusEvent e = new FocusEvent(new Button("Button0"),
+ * FocusEvent.FOCUS_GAINED, false, new Button("Button1"));
+ * System.out.println(e);
+ */
+
+ String idString = null;
+
+ switch (id) {
+ case FOCUS_GAINED:
+ idString = "FOCUS_GAINED"; //$NON-NLS-1$
+ break;
+ case FOCUS_LOST:
+ idString = "FOCUS_LOST"; //$NON-NLS-1$
+ break;
+ default:
+ idString = "unknown type"; //$NON-NLS-1$
+ }
+
+ return (idString +
+ (temporary ? ",temporary" : ",permanent") + //$NON-NLS-1$ //$NON-NLS-2$
+ ",opposite=" + opposite); //$NON-NLS-1$
+ }
+
+}
diff --git a/awt/java/awt/event/FocusListener.java b/awt/java/awt/event/FocusListener.java
new file mode 100644
index 0000000..ee98d90
--- /dev/null
+++ b/awt/java/awt/event/FocusListener.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface FocusListener extends EventListener {
+
+ public void focusGained(FocusEvent e);
+
+ public void focusLost(FocusEvent e);
+
+}
diff --git a/awt/java/awt/event/HierarchyBoundsAdapter.java b/awt/java/awt/event/HierarchyBoundsAdapter.java
new file mode 100644
index 0000000..24e3d9d
--- /dev/null
+++ b/awt/java/awt/event/HierarchyBoundsAdapter.java
@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+public abstract class HierarchyBoundsAdapter implements HierarchyBoundsListener {
+
+ public HierarchyBoundsAdapter() {
+ }
+
+ public void ancestorMoved(HierarchyEvent e) {
+ }
+
+ public void ancestorResized(HierarchyEvent e) {
+ }
+
+}
diff --git a/awt/java/awt/event/HierarchyBoundsListener.java b/awt/java/awt/event/HierarchyBoundsListener.java
new file mode 100644
index 0000000..4288f52
--- /dev/null
+++ b/awt/java/awt/event/HierarchyBoundsListener.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface HierarchyBoundsListener extends EventListener {
+
+ public void ancestorMoved(HierarchyEvent e);
+
+ public void ancestorResized(HierarchyEvent e);
+
+}
diff --git a/awt/java/awt/event/HierarchyEvent.java b/awt/java/awt/event/HierarchyEvent.java
new file mode 100644
index 0000000..1881667
--- /dev/null
+++ b/awt/java/awt/event/HierarchyEvent.java
@@ -0,0 +1,148 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+import java.awt.Component;
+//???AWT: import java.awt.Container;
+
+public class HierarchyEvent extends AWTEvent {
+
+ private static final long serialVersionUID = -5337576970038043990L;
+
+ public static final int HIERARCHY_FIRST = 1400;
+
+ public static final int HIERARCHY_CHANGED = 1400;
+
+ public static final int ANCESTOR_MOVED = 1401;
+
+ public static final int ANCESTOR_RESIZED = 1402;
+
+ public static final int HIERARCHY_LAST = 1402;
+
+ public static final int PARENT_CHANGED = 1;
+
+ public static final int DISPLAYABILITY_CHANGED = 2;
+
+ public static final int SHOWING_CHANGED = 4;
+
+ //???AWT: private Container changedParent;
+ private Component changed;
+ private long changeFlag;
+
+ //???AWT
+ /*
+ public HierarchyEvent(Component source, int id, Component changed,
+ Container changedParent) {
+ this(source, id, changed, changedParent, 0l);
+ }
+ */
+
+ //???AWT
+ /*
+ public HierarchyEvent(Component source, int id, Component changed,
+ Container changedParent, long changeFlags) {
+ super(source, id);
+
+ this.changed = changed;
+ this.changedParent = changedParent;
+ this.changeFlag = changeFlags;
+ }
+ */
+ //???AWT: Fake constructor, should be as above.
+ public HierarchyEvent(Component source, int id, Component changed,
+ Object changedParent, long changeFlags) {
+ super(source, id);
+
+// this.changed = changed;
+// this.changedParent = changedParent;
+// this.changeFlag = changeFlags;
+ }
+
+ public Component getComponent() {
+ return (Component) source;
+ }
+
+ public long getChangeFlags() {
+ return changeFlag;
+ }
+
+ public Component getChanged() {
+ return changed;
+ }
+
+ //???AWT
+ /*
+ public Container getChangedParent() {
+ return changedParent;
+
+ }
+ */
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * HierarchyEvent e = new HierarchyEvent(new Button("Button"),
+ * HierarchyEvent.HIERARCHY_CHANGED,
+ * new Panel(), new Container());
+ * System.out.println(e);
+ */
+ String paramString = null;
+
+ switch (id) {
+ case HIERARCHY_CHANGED:
+ paramString = "HIERARCHY_CHANGED"; //$NON-NLS-1$
+ break;
+ case ANCESTOR_MOVED:
+ paramString = "ANCESTOR_MOVED"; //$NON-NLS-1$
+ break;
+ case ANCESTOR_RESIZED:
+ paramString = "ANCESTOR_RESIZED"; //$NON-NLS-1$
+ break;
+ default:
+ paramString = "unknown type"; //$NON-NLS-1$
+ }
+
+ paramString += " ("; //$NON-NLS-1$
+
+ if (id == HIERARCHY_CHANGED) {
+ if ((changeFlag & PARENT_CHANGED) > 0) {
+ paramString += "PARENT_CHANGED,"; //$NON-NLS-1$
+ }
+ if ((changeFlag & DISPLAYABILITY_CHANGED) > 0) {
+ paramString += "DISPLAYABILITY_CHANGED,"; //$NON-NLS-1$
+ }
+ if ((changeFlag & SHOWING_CHANGED) > 0) {
+ paramString += "SHOWING_CHANGED,"; //$NON-NLS-1$
+ }
+ }
+
+ //???AWT
+ /*
+ return paramString + "changed=" + changed + //$NON-NLS-1$
+ ",changedParent=" + changedParent + ")"; //$NON-NLS-1$ //$NON-NLS-2$
+ */
+ return paramString;
+ }
+
+}
diff --git a/awt/java/awt/event/HierarchyListener.java b/awt/java/awt/event/HierarchyListener.java
new file mode 100644
index 0000000..e01ba11
--- /dev/null
+++ b/awt/java/awt/event/HierarchyListener.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface HierarchyListener extends EventListener {
+
+ public void hierarchyChanged(HierarchyEvent e);
+
+}
diff --git a/awt/java/awt/event/InputEvent.java b/awt/java/awt/event/InputEvent.java
new file mode 100644
index 0000000..c98382d
--- /dev/null
+++ b/awt/java/awt/event/InputEvent.java
@@ -0,0 +1,184 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.Component;
+
+public abstract class InputEvent extends ComponentEvent {
+
+ private static final long serialVersionUID = -2482525981698309786L;
+
+ public static final int SHIFT_MASK = 1;
+
+ public static final int CTRL_MASK = 2;
+
+ public static final int META_MASK = 4;
+
+ public static final int ALT_MASK = 8;
+
+ public static final int ALT_GRAPH_MASK = 32;
+
+ public static final int BUTTON1_MASK = 16;
+
+ public static final int BUTTON2_MASK = 8;
+
+ public static final int BUTTON3_MASK = 4;
+
+ public static final int SHIFT_DOWN_MASK = 64;
+
+ public static final int CTRL_DOWN_MASK = 128;
+
+ public static final int META_DOWN_MASK = 256;
+
+ public static final int ALT_DOWN_MASK = 512;
+
+ public static final int BUTTON1_DOWN_MASK = 1024;
+
+ public static final int BUTTON2_DOWN_MASK = 2048;
+
+ public static final int BUTTON3_DOWN_MASK = 4096;
+
+ public static final int ALT_GRAPH_DOWN_MASK = 8192;
+
+ private static final int DOWN_MASKS = SHIFT_DOWN_MASK | CTRL_DOWN_MASK |
+ META_DOWN_MASK | ALT_DOWN_MASK | BUTTON1_DOWN_MASK |
+ BUTTON2_DOWN_MASK | BUTTON3_DOWN_MASK | ALT_GRAPH_DOWN_MASK;
+
+ private long when;
+ private int modifiersEx;
+
+ public static String getModifiersExText(int modifiers/*Ex*/) {
+ return MouseEvent.addMouseModifiersExText(
+ KeyEvent.getKeyModifiersExText(modifiers), modifiers);
+ }
+
+ static int extractExFlags(int modifiers) {
+ int exFlags = modifiers & DOWN_MASKS;
+
+ if ((modifiers & SHIFT_MASK) != 0) {
+ exFlags |= SHIFT_DOWN_MASK;
+ }
+ if ((modifiers & CTRL_MASK) != 0) {
+ exFlags |= CTRL_DOWN_MASK;
+ }
+ if ((modifiers & META_MASK) != 0) {
+ exFlags |= META_DOWN_MASK;
+ }
+ if ((modifiers & ALT_MASK) != 0) {
+ exFlags |= ALT_DOWN_MASK;
+ }
+ if ((modifiers & ALT_GRAPH_MASK) != 0) {
+ exFlags |= ALT_GRAPH_DOWN_MASK;
+ }
+ if ((modifiers & BUTTON1_MASK) != 0) {
+ exFlags |= BUTTON1_DOWN_MASK;
+ }
+ if ((modifiers & BUTTON2_MASK) != 0) {
+ exFlags |= BUTTON2_DOWN_MASK;
+ }
+ if ((modifiers & BUTTON3_MASK) != 0) {
+ exFlags |= BUTTON3_DOWN_MASK;
+ }
+
+ return exFlags;
+ }
+
+ InputEvent(Component source, int id, long when, int modifiers) {
+ super(source, id);
+
+ this.when = when;
+ modifiersEx = extractExFlags(modifiers);
+ }
+
+ public int getModifiers() {
+ int modifiers = 0;
+
+ if ((modifiersEx & SHIFT_DOWN_MASK) != 0) {
+ modifiers |= SHIFT_MASK;
+ }
+ if ((modifiersEx & CTRL_DOWN_MASK) != 0) {
+ modifiers |= CTRL_MASK;
+ }
+ if ((modifiersEx & META_DOWN_MASK) != 0) {
+ modifiers |= META_MASK;
+ }
+ if ((modifiersEx & ALT_DOWN_MASK) != 0) {
+ modifiers |= ALT_MASK;
+ }
+ if ((modifiersEx & ALT_GRAPH_DOWN_MASK) != 0) {
+ modifiers |= ALT_GRAPH_MASK;
+ }
+ if ((modifiersEx & BUTTON1_DOWN_MASK) != 0) {
+ modifiers |= BUTTON1_MASK;
+ }
+ if ((modifiersEx & BUTTON2_DOWN_MASK) != 0) {
+ modifiers |= BUTTON2_MASK;
+ }
+ if ((modifiersEx & BUTTON3_DOWN_MASK) != 0) {
+ modifiers |= BUTTON3_MASK;
+ }
+
+ return modifiers;
+ }
+
+ public int getModifiersEx() {
+ return modifiersEx;
+ }
+
+ void setModifiers(int modifiers) {
+ modifiersEx = extractExFlags(modifiers);
+ }
+
+ public boolean isAltDown() {
+ return ((modifiersEx & ALT_DOWN_MASK) != 0);
+ }
+
+ public boolean isAltGraphDown() {
+ return ((modifiersEx & ALT_GRAPH_DOWN_MASK) != 0);
+ }
+
+ public boolean isControlDown() {
+ return ((modifiersEx & CTRL_DOWN_MASK) != 0);
+ }
+
+ public boolean isMetaDown() {
+ return ((modifiersEx & META_DOWN_MASK) != 0);
+ }
+
+ public boolean isShiftDown() {
+ return ((modifiersEx & SHIFT_DOWN_MASK) != 0);
+ }
+
+ public long getWhen() {
+ return when;
+ }
+
+ @Override
+ public void consume() {
+ super.consume();
+ }
+
+ @Override
+ public boolean isConsumed() {
+ return super.isConsumed();
+ }
+
+}
diff --git a/awt/java/awt/event/InputMethodEvent.java b/awt/java/awt/event/InputMethodEvent.java
new file mode 100644
index 0000000..a5cac4e
--- /dev/null
+++ b/awt/java/awt/event/InputMethodEvent.java
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+import java.awt.Component;
+import java.awt.font.TextHitInfo;
+import java.text.AttributedCharacterIterator;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+public class InputMethodEvent extends AWTEvent {
+
+ private static final long serialVersionUID = 4727190874778922661L;
+
+ public static final int INPUT_METHOD_FIRST = 1100;
+
+ public static final int INPUT_METHOD_TEXT_CHANGED = 1100;
+
+ public static final int CARET_POSITION_CHANGED = 1101;
+
+ public static final int INPUT_METHOD_LAST = 1101;
+
+ private AttributedCharacterIterator text;
+ private TextHitInfo visiblePosition;
+ private TextHitInfo caret;
+ private int committedCharacterCount;
+ private long when;
+
+ public InputMethodEvent(Component src, int id,
+ TextHitInfo caret,
+ TextHitInfo visiblePos) {
+ this(src, id, null, 0, caret, visiblePos);
+ }
+
+ public InputMethodEvent(Component src, int id,
+ AttributedCharacterIterator text,
+ int commitedCharCount,
+ TextHitInfo caret,
+ TextHitInfo visiblePos) {
+ this(src, id, 0l, text, commitedCharCount, caret, visiblePos);
+ }
+
+ public InputMethodEvent(Component src, int id, long when,
+ AttributedCharacterIterator text,
+ int committedCharacterCount,
+ TextHitInfo caret,
+ TextHitInfo visiblePos) {
+ super(src, id);
+
+ if ((id < INPUT_METHOD_FIRST) || (id > INPUT_METHOD_LAST)) {
+ // awt.18E=Wrong event id
+ throw new IllegalArgumentException(Messages.getString("awt.18E")); //$NON-NLS-1$
+ }
+ if ((id == CARET_POSITION_CHANGED) && (text != null)) {
+ // awt.18F=Text must be null for CARET_POSITION_CHANGED
+ throw new IllegalArgumentException(Messages.getString("awt.18F")); //$NON-NLS-1$
+ }
+ if ((text != null) &&
+ ((committedCharacterCount < 0) ||
+ (committedCharacterCount >
+ (text.getEndIndex() - text.getBeginIndex())))) {
+ // awt.190=Wrong committedCharacterCount
+ throw new IllegalArgumentException(Messages.getString("awt.190")); //$NON-NLS-1$
+ }
+
+ this.when = when;
+ this.text = text;
+ this.caret = caret;
+ this.visiblePosition = visiblePos;
+ this.committedCharacterCount = committedCharacterCount;
+ }
+
+ public TextHitInfo getCaret() {
+ return caret;
+ }
+
+ public int getCommittedCharacterCount() {
+ return committedCharacterCount;
+ }
+
+ public AttributedCharacterIterator getText() {
+ return text;
+ }
+
+ public TextHitInfo getVisiblePosition() {
+ return visiblePosition;
+ }
+
+ public long getWhen() {
+ return when;
+ }
+
+ @Override
+ public void consume() {
+ super.consume();
+ }
+
+ @Override
+ public boolean isConsumed() {
+ return super.isConsumed();
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * InputMethodEvent e = new InputMethodEvent(new Component(){},
+ * InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
+ * TextHitInfo.leading(1), TextHitInfo.trailing(2));
+ * System.out.println(e);
+ */
+ String typeString = null;
+
+ switch (id) {
+ case INPUT_METHOD_TEXT_CHANGED:
+ typeString = "INPUT_METHOD_TEXT_CHANGED"; //$NON-NLS-1$
+ break;
+ case CARET_POSITION_CHANGED:
+ typeString = "CARET_POSITION_CHANGED"; //$NON-NLS-1$
+ break;
+ default:
+ typeString = "unknown type"; //$NON-NLS-1$
+ }
+
+ return typeString + ",text=" + text + //$NON-NLS-1$
+ ",commitedCharCount=" + committedCharacterCount + //$NON-NLS-1$
+ ",caret=" + caret + ",visiblePosition=" + visiblePosition; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+}
diff --git a/awt/java/awt/event/InputMethodListener.java b/awt/java/awt/event/InputMethodListener.java
new file mode 100644
index 0000000..0ab6918
--- /dev/null
+++ b/awt/java/awt/event/InputMethodListener.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface InputMethodListener extends EventListener {
+
+ public void caretPositionChanged(InputMethodEvent e);
+
+ public void inputMethodTextChanged(InputMethodEvent e);
+
+}
diff --git a/awt/java/awt/event/InvocationEvent.java b/awt/java/awt/event/InvocationEvent.java
new file mode 100644
index 0000000..59346ed
--- /dev/null
+++ b/awt/java/awt/event/InvocationEvent.java
@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+import java.awt.ActiveEvent;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+public class InvocationEvent extends AWTEvent implements ActiveEvent {
+
+ private static final long serialVersionUID = 436056344909459450L;
+
+ public static final int INVOCATION_FIRST = 1200;
+
+ public static final int INVOCATION_DEFAULT = 1200;
+
+ public static final int INVOCATION_LAST = 1200;
+
+ protected Runnable runnable;
+
+ protected Object notifier;
+
+ protected boolean catchExceptions;
+
+ private long when;
+ private Throwable throwable;
+
+ public InvocationEvent(Object source, Runnable runnable) {
+ this(source, runnable, null, false);
+ }
+
+ public InvocationEvent(Object source, Runnable runnable,
+ Object notifier, boolean catchExceptions) {
+ this(source, INVOCATION_DEFAULT, runnable, notifier, catchExceptions);
+ }
+
+ protected InvocationEvent(Object source, int id, Runnable runnable,
+ Object notifier, boolean catchExceptions)
+ {
+ super(source, id);
+
+ // awt.18C=Cannot invoke null runnable
+ assert runnable != null : Messages.getString("awt.18C"); //$NON-NLS-1$
+
+ if (source == null) {
+ // awt.18D=Source is null
+ throw new IllegalArgumentException(Messages.getString("awt.18D")); //$NON-NLS-1$
+ }
+ this.runnable = runnable;
+ this.notifier = notifier;
+ this.catchExceptions = catchExceptions;
+
+ throwable = null;
+ when = System.currentTimeMillis();
+ }
+
+ public void dispatch() {
+ if (!catchExceptions) {
+ runAndNotify();
+ } else {
+ try {
+ runAndNotify();
+ } catch (Throwable t) {
+ throwable = t;
+ }
+ }
+ }
+
+ private void runAndNotify() {
+ if (notifier != null) {
+ synchronized(notifier) {
+ try {
+ runnable.run();
+ } finally {
+ notifier.notifyAll();
+ }
+ }
+ } else {
+ runnable.run();
+ }
+ }
+
+ public Exception getException() {
+ return (throwable != null && throwable instanceof Exception) ?
+ (Exception)throwable : null;
+ }
+
+ public Throwable getThrowable() {
+ return throwable;
+ }
+
+ public long getWhen() {
+ return when;
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * InvocationEvent e = new InvocationEvent(new Component(){},
+ * new Runnable() { public void run(){} });
+ * System.out.println(e);
+ */
+
+ return ((id == INVOCATION_DEFAULT ? "INVOCATION_DEFAULT" : "unknown type") + //$NON-NLS-1$ //$NON-NLS-2$
+ ",runnable=" + runnable + //$NON-NLS-1$
+ ",notifier=" + notifier + //$NON-NLS-1$
+ ",catchExceptions=" + catchExceptions + //$NON-NLS-1$
+ ",when=" + when); //$NON-NLS-1$
+ }
+
+}
diff --git a/awt/java/awt/event/ItemEvent.java b/awt/java/awt/event/ItemEvent.java
new file mode 100644
index 0000000..842da14
--- /dev/null
+++ b/awt/java/awt/event/ItemEvent.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+import java.awt.ItemSelectable;
+
+public class ItemEvent extends AWTEvent {
+
+ private static final long serialVersionUID = -608708132447206933L;
+
+ public static final int ITEM_FIRST = 701;
+
+ public static final int ITEM_LAST = 701;
+
+ public static final int ITEM_STATE_CHANGED = 701;
+
+ public static final int SELECTED = 1;
+
+ public static final int DESELECTED = 2;
+
+ private Object item;
+ private int stateChange;
+
+ public ItemEvent(ItemSelectable source, int id, Object item, int stateChange) {
+ super(source, id);
+
+ this.item = item;
+ this.stateChange = stateChange;
+ }
+
+ public Object getItem() {
+ return item;
+ }
+
+ public int getStateChange() {
+ return stateChange;
+ }
+
+ public ItemSelectable getItemSelectable() {
+ return (ItemSelectable) source;
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * Checkbox c = new Checkbox("Checkbox", true);
+ * ItemEvent e = new ItemEvent(c, ItemEvent.ITEM_STATE_CHANGED,
+ * c, ItemEvent.SELECTED);
+ * System.out.println(e);
+ */
+
+ String stateString = null;
+
+ switch (stateChange) {
+ case SELECTED:
+ stateString = "SELECTED"; //$NON-NLS-1$
+ break;
+ case DESELECTED:
+ stateString = "DESELECTED"; //$NON-NLS-1$
+ break;
+ default:
+ stateString = "unknown type"; //$NON-NLS-1$
+ }
+
+ return ((id == ITEM_STATE_CHANGED ? "ITEM_STATE_CHANGED" : "unknown type") + //$NON-NLS-1$ //$NON-NLS-2$
+ ",item=" + item + ",stateChange=" + stateString); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+}
diff --git a/awt/java/awt/event/ItemListener.java b/awt/java/awt/event/ItemListener.java
new file mode 100644
index 0000000..33633be
--- /dev/null
+++ b/awt/java/awt/event/ItemListener.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface ItemListener extends EventListener {
+
+ public void itemStateChanged(ItemEvent e);
+
+}
diff --git a/awt/java/awt/event/KeyAdapter.java b/awt/java/awt/event/KeyAdapter.java
new file mode 100644
index 0000000..423b5c9
--- /dev/null
+++ b/awt/java/awt/event/KeyAdapter.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+public abstract class KeyAdapter implements KeyListener {
+
+ public KeyAdapter() {
+ }
+
+ public void keyPressed(KeyEvent e) {
+ }
+
+ public void keyReleased(KeyEvent e) {
+ }
+
+ public void keyTyped(KeyEvent e) {
+ }
+
+}
diff --git a/awt/java/awt/event/KeyEvent.java b/awt/java/awt/event/KeyEvent.java
new file mode 100644
index 0000000..056c64c
--- /dev/null
+++ b/awt/java/awt/event/KeyEvent.java
@@ -0,0 +1,681 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.Component;
+import java.awt.Toolkit;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+public class KeyEvent extends InputEvent {
+
+ private static final long serialVersionUID = -2352130953028126954L;
+
+ public static final int KEY_FIRST = 400;
+
+ public static final int KEY_LAST = 402;
+
+ public static final int KEY_TYPED = 400;
+
+ public static final int KEY_PRESSED = 401;
+
+ public static final int KEY_RELEASED = 402;
+
+ public static final int VK_ENTER = 10;
+
+ public static final int VK_BACK_SPACE = 8;
+
+ public static final int VK_TAB = 9;
+
+ public static final int VK_CANCEL = 3;
+
+ public static final int VK_CLEAR = 12;
+
+ public static final int VK_SHIFT = 16;
+
+ public static final int VK_CONTROL = 17;
+
+ public static final int VK_ALT = 18;
+
+ public static final int VK_PAUSE = 19;
+
+ public static final int VK_CAPS_LOCK = 20;
+
+ public static final int VK_ESCAPE = 27;
+
+ public static final int VK_SPACE = 32;
+
+ public static final int VK_PAGE_UP = 33;
+
+ public static final int VK_PAGE_DOWN = 34;
+
+ public static final int VK_END = 35;
+
+ public static final int VK_HOME = 36;
+
+ public static final int VK_LEFT = 37;
+
+ public static final int VK_UP = 38;
+
+ public static final int VK_RIGHT = 39;
+
+ public static final int VK_DOWN = 40;
+
+ public static final int VK_COMMA = 44;
+
+ public static final int VK_MINUS = 45;
+
+ public static final int VK_PERIOD = 46;
+
+ public static final int VK_SLASH = 47;
+
+ public static final int VK_0 = 48;
+
+ public static final int VK_1 = 49;
+
+ public static final int VK_2 = 50;
+
+ public static final int VK_3 = 51;
+
+ public static final int VK_4 = 52;
+
+ public static final int VK_5 = 53;
+
+ public static final int VK_6 = 54;
+
+ public static final int VK_7 = 55;
+
+ public static final int VK_8 = 56;
+
+ public static final int VK_9 = 57;
+
+ public static final int VK_SEMICOLON = 59;
+
+ public static final int VK_EQUALS = 61;
+
+ public static final int VK_A = 65;
+
+ public static final int VK_B = 66;
+
+ public static final int VK_C = 67;
+
+ public static final int VK_D = 68;
+
+ public static final int VK_E = 69;
+
+ public static final int VK_F = 70;
+
+ public static final int VK_G = 71;
+
+ public static final int VK_H = 72;
+
+ public static final int VK_I = 73;
+
+ public static final int VK_J = 74;
+
+ public static final int VK_K = 75;
+
+ public static final int VK_L = 76;
+
+ public static final int VK_M = 77;
+
+ public static final int VK_N = 78;
+
+ public static final int VK_O = 79;
+
+ public static final int VK_P = 80;
+
+ public static final int VK_Q = 81;
+
+ public static final int VK_R = 82;
+
+ public static final int VK_S = 83;
+
+ public static final int VK_T = 84;
+
+ public static final int VK_U = 85;
+
+ public static final int VK_V = 86;
+
+ public static final int VK_W = 87;
+
+ public static final int VK_X = 88;
+
+ public static final int VK_Y = 89;
+
+ public static final int VK_Z = 90;
+
+ public static final int VK_OPEN_BRACKET = 91;
+
+ public static final int VK_BACK_SLASH = 92;
+
+ public static final int VK_CLOSE_BRACKET = 93;
+
+ public static final int VK_NUMPAD0 = 96;
+
+ public static final int VK_NUMPAD1 = 97;
+
+ public static final int VK_NUMPAD2 = 98;
+
+ public static final int VK_NUMPAD3 = 99;
+
+ public static final int VK_NUMPAD4 = 100;
+
+ public static final int VK_NUMPAD5 = 101;
+
+ public static final int VK_NUMPAD6 = 102;
+
+ public static final int VK_NUMPAD7 = 103;
+
+ public static final int VK_NUMPAD8 = 104;
+
+ public static final int VK_NUMPAD9 = 105;
+
+ public static final int VK_MULTIPLY = 106;
+
+ public static final int VK_ADD = 107;
+
+ public static final int VK_SEPARATER = 108;
+
+ public static final int VK_SEPARATOR = 108;
+
+ public static final int VK_SUBTRACT = 109;
+
+ public static final int VK_DECIMAL = 110;
+
+ public static final int VK_DIVIDE = 111;
+
+ public static final int VK_DELETE = 127;
+
+ public static final int VK_NUM_LOCK = 144;
+
+ public static final int VK_SCROLL_LOCK = 145;
+
+ public static final int VK_F1 = 112;
+
+ public static final int VK_F2 = 113;
+
+ public static final int VK_F3 = 114;
+
+ public static final int VK_F4 = 115;
+
+ public static final int VK_F5 = 116;
+
+ public static final int VK_F6 = 117;
+
+ public static final int VK_F7 = 118;
+
+ public static final int VK_F8 = 119;
+
+ public static final int VK_F9 = 120;
+
+ public static final int VK_F10 = 121;
+
+ public static final int VK_F11 = 122;
+
+ public static final int VK_F12 = 123;
+
+ public static final int VK_F13 = 61440;
+
+ public static final int VK_F14 = 61441;
+
+ public static final int VK_F15 = 61442;
+
+ public static final int VK_F16 = 61443;
+
+ public static final int VK_F17 = 61444;
+
+ public static final int VK_F18 = 61445;
+
+ public static final int VK_F19 = 61446;
+
+ public static final int VK_F20 = 61447;
+
+ public static final int VK_F21 = 61448;
+
+ public static final int VK_F22 = 61449;
+
+ public static final int VK_F23 = 61450;
+
+ public static final int VK_F24 = 61451;
+
+ public static final int VK_PRINTSCREEN = 154;
+
+ public static final int VK_INSERT = 155;
+
+ public static final int VK_HELP = 156;
+
+ public static final int VK_META = 157;
+
+ public static final int VK_BACK_QUOTE = 192;
+
+ public static final int VK_QUOTE = 222;
+
+ public static final int VK_KP_UP = 224;
+
+ public static final int VK_KP_DOWN = 225;
+
+ public static final int VK_KP_LEFT = 226;
+
+ public static final int VK_KP_RIGHT = 227;
+
+ public static final int VK_DEAD_GRAVE = 128;
+
+ public static final int VK_DEAD_ACUTE = 129;
+
+ public static final int VK_DEAD_CIRCUMFLEX = 130;
+
+ public static final int VK_DEAD_TILDE = 131;
+
+ public static final int VK_DEAD_MACRON = 132;
+
+ public static final int VK_DEAD_BREVE = 133;
+
+ public static final int VK_DEAD_ABOVEDOT = 134;
+
+ public static final int VK_DEAD_DIAERESIS = 135;
+
+ public static final int VK_DEAD_ABOVERING = 136;
+
+ public static final int VK_DEAD_DOUBLEACUTE = 137;
+
+ public static final int VK_DEAD_CARON = 138;
+
+ public static final int VK_DEAD_CEDILLA = 139;
+
+ public static final int VK_DEAD_OGONEK = 140;
+
+ public static final int VK_DEAD_IOTA = 141;
+
+ public static final int VK_DEAD_VOICED_SOUND = 142;
+
+ public static final int VK_DEAD_SEMIVOICED_SOUND = 143;
+
+ public static final int VK_AMPERSAND = 150;
+
+ public static final int VK_ASTERISK = 151;
+
+ public static final int VK_QUOTEDBL = 152;
+
+ public static final int VK_LESS = 153;
+
+ public static final int VK_GREATER = 160;
+
+ public static final int VK_BRACELEFT = 161;
+
+ public static final int VK_BRACERIGHT = 162;
+
+ public static final int VK_AT = 512;
+
+ public static final int VK_COLON = 513;
+
+ public static final int VK_CIRCUMFLEX = 514;
+
+ public static final int VK_DOLLAR = 515;
+
+ public static final int VK_EURO_SIGN = 516;
+
+ public static final int VK_EXCLAMATION_MARK = 517;
+
+ public static final int VK_INVERTED_EXCLAMATION_MARK = 518;
+
+ public static final int VK_LEFT_PARENTHESIS = 519;
+
+ public static final int VK_NUMBER_SIGN = 520;
+
+ public static final int VK_PLUS = 521;
+
+ public static final int VK_RIGHT_PARENTHESIS = 522;
+
+ public static final int VK_UNDERSCORE = 523;
+
+ public static final int VK_FINAL = 24;
+
+ public static final int VK_WINDOWS = 524;
+
+ public static final int VK_CONTEXT_MENU = 525;
+
+ public static final int VK_CONVERT = 28;
+
+ public static final int VK_NONCONVERT = 29;
+
+ public static final int VK_ACCEPT = 30;
+
+ public static final int VK_MODECHANGE = 31;
+
+ public static final int VK_KANA = 21;
+
+ public static final int VK_KANJI = 25;
+
+ public static final int VK_ALPHANUMERIC = 240;
+
+ public static final int VK_KATAKANA = 241;
+
+ public static final int VK_HIRAGANA = 242;
+
+ public static final int VK_FULL_WIDTH = 243;
+
+ public static final int VK_HALF_WIDTH = 244;
+
+ public static final int VK_ROMAN_CHARACTERS = 245;
+
+ public static final int VK_ALL_CANDIDATES = 256;
+
+ public static final int VK_PREVIOUS_CANDIDATE = 257;
+
+ public static final int VK_CODE_INPUT = 258;
+
+ public static final int VK_JAPANESE_KATAKANA = 259;
+
+ public static final int VK_JAPANESE_HIRAGANA = 260;
+
+ public static final int VK_JAPANESE_ROMAN = 261;
+
+ public static final int VK_KANA_LOCK = 262;
+
+ public static final int VK_INPUT_METHOD_ON_OFF = 263;
+
+ public static final int VK_CUT = 65489;
+
+ public static final int VK_COPY = 65485;
+
+ public static final int VK_PASTE = 65487;
+
+ public static final int VK_UNDO = 65483;
+
+ public static final int VK_AGAIN = 65481;
+
+ public static final int VK_FIND = 65488;
+
+ public static final int VK_PROPS = 65482;
+
+ public static final int VK_STOP = 65480;
+
+ public static final int VK_COMPOSE = 65312;
+
+ public static final int VK_ALT_GRAPH = 65406;
+
+ public static final int VK_BEGIN = 65368;
+
+ public static final int VK_UNDEFINED = 0;
+
+ public static final char CHAR_UNDEFINED = (char)(-1);
+
+ public static final int KEY_LOCATION_UNKNOWN = 0;
+
+ public static final int KEY_LOCATION_STANDARD = 1;
+
+ public static final int KEY_LOCATION_LEFT = 2;
+
+ public static final int KEY_LOCATION_RIGHT = 3;
+
+ public static final int KEY_LOCATION_NUMPAD = 4;
+
+ private int keyCode;
+ private char keyChar;
+ private int keyLocation;
+
+ public static String getKeyModifiersText(int modifiers) {
+ return getKeyModifiersExText(extractExFlags(modifiers));
+ }
+
+ static String getKeyModifiersExText(int modifiersEx) {
+ String text = ""; //$NON-NLS-1$
+
+ if ((modifiersEx & InputEvent.META_DOWN_MASK) != 0) {
+ text += Toolkit.getProperty("AWT.meta", "Meta"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if ((modifiersEx & InputEvent.CTRL_DOWN_MASK) != 0) {
+ text += ((text.length() > 0) ? "+" : "") + //$NON-NLS-1$ //$NON-NLS-2$
+ Toolkit.getProperty("AWT.control", "Ctrl"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if ((modifiersEx & InputEvent.ALT_DOWN_MASK) != 0) {
+ text += ((text.length() > 0) ? "+" : "") + //$NON-NLS-1$ //$NON-NLS-2$
+ Toolkit.getProperty("AWT.alt", "Alt"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if ((modifiersEx & InputEvent.SHIFT_DOWN_MASK) != 0) {
+ text += ((text.length() > 0) ? "+" : "") + //$NON-NLS-1$ //$NON-NLS-2$
+ Toolkit.getProperty("AWT.shift", "Shift"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if ((modifiersEx & InputEvent.ALT_GRAPH_DOWN_MASK) != 0) {
+ text += ((text.length() > 0) ? "+" : "") + //$NON-NLS-1$ //$NON-NLS-2$
+ Toolkit.getProperty("AWT.altGraph", "Alt Graph"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ return text;
+ }
+
+ public static String getKeyText(int keyCode) {
+ String[] rawName = getPublicStaticFinalIntFieldName(keyCode); //$NON-NLS-1$
+
+ if ((rawName == null) || (rawName.length == 0)) {
+ return ("Unknown keyCode: " + (keyCode >= 0 ? "0x" : "-0x") + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ Integer.toHexString(Math.abs(keyCode)));
+ }
+
+ String propertyName = getPropertyName(rawName);
+ String defaultName = getDefaultName(rawName);
+
+ return Toolkit.getProperty(propertyName, defaultName);
+ }
+
+ private static String getDefaultName(String[] rawName) {
+ String name = ""; //$NON-NLS-1$
+
+ for (int i = 0; true; i++) {
+ String part = rawName[i];
+
+ name += new String(new char[] {part.charAt(0)}).toUpperCase() +
+ part.substring(1).toLowerCase();
+
+ if (i == (rawName.length - 1)) {
+ break;
+ }
+ name += " "; //$NON-NLS-1$
+ }
+
+ return name;
+ }
+
+ private static String getPropertyName(String[] rawName) {
+ String name = rawName[0].toLowerCase();
+
+ for (int i = 1; i < rawName.length; i++) {
+ String part = rawName[i];
+
+ name += new String(new char[] {part.charAt(0)}).toUpperCase() +
+ part.substring(1).toLowerCase();
+ }
+
+ return ("AWT." + name); //$NON-NLS-1$
+ }
+
+ private static String[] getPublicStaticFinalIntFieldName(int value) {
+ Field[] allFields = KeyEvent.class.getDeclaredFields();
+
+ try {
+ for (Field field : allFields) {
+ Class<?> ssalc = field.getType();
+ int modifiers = field.getModifiers();
+
+ if (ssalc.isPrimitive() && ssalc.getName().equals("int") && //$NON-NLS-1$
+ Modifier.isFinal(modifiers) && Modifier.isPublic(modifiers) &&
+ Modifier.isStatic(modifiers))
+ {
+ if (field.getInt(null) == value){
+ final String name = field.getName();
+ final int prefixLength = name.indexOf("_") + 1;
+ return name.substring(prefixLength).split("_"); //$NON-NLS-1$
+ }
+ }
+ }
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ return null;
+ }
+
+ @Deprecated
+ public KeyEvent(Component src, int id,
+ long when, int modifiers,
+ int keyCode) {
+ this(src, id, when, modifiers, keyCode,
+ (keyCode > (2 << 7) - 1) ? CHAR_UNDEFINED : (char) keyCode);
+ }
+
+ public KeyEvent(Component src, int id,
+ long when, int modifiers,
+ int keyCode, char keyChar) {
+ this(src, id, when, modifiers, keyCode, keyChar, KEY_LOCATION_UNKNOWN);
+ }
+
+ public KeyEvent(Component src, int id,
+ long when, int modifiers,
+ int keyCode, char keyChar,
+ int keyLocation) {
+ super(src, id, when, modifiers);
+
+ if (id == KEY_TYPED) {
+ if (keyCode != VK_UNDEFINED) {
+ // awt.191=Invalid keyCode for KEY_TYPED event, must be VK_UNDEFINED
+ throw new IllegalArgumentException(Messages.getString("awt.191")); //$NON-NLS-1$
+ }
+ if (keyChar == CHAR_UNDEFINED) {
+ // awt.192=Invalid keyChar for KEY_TYPED event, can't be CHAR_UNDEFINED
+ throw new IllegalArgumentException(Messages.getString("awt.192")); //$NON-NLS-1$
+ }
+ }
+
+ if ((keyLocation < KEY_LOCATION_UNKNOWN)
+ || (keyLocation > KEY_LOCATION_NUMPAD)) {
+ // awt.297=Invalid keyLocation
+ throw new IllegalArgumentException(Messages.getString("awt.297")); //$NON-NLS-1$
+ }
+
+ this.keyChar = keyChar;
+ this.keyLocation = keyLocation;
+ this.keyCode = keyCode;
+ }
+
+ public int getKeyCode() {
+ return keyCode;
+ }
+
+ public void setKeyCode(int keyCode) {
+ this.keyCode = keyCode;
+ }
+
+ public char getKeyChar() {
+ return keyChar;
+ }
+
+ public void setKeyChar(char keyChar) {
+ this.keyChar = keyChar;
+ }
+
+ public int getKeyLocation() {
+ return keyLocation;
+ }
+
+ @Override
+ @Deprecated
+ public void setModifiers(int modifiers) {
+ super.setModifiers(modifiers);
+ }
+
+ public boolean isActionKey() {
+ return ((keyChar == CHAR_UNDEFINED) && (keyCode != VK_UNDEFINED) &&
+ !((keyCode == VK_ALT) || (keyCode == VK_ALT_GRAPH) ||
+ (keyCode == VK_CONTROL) || (keyCode == VK_META) || (keyCode == VK_SHIFT)));
+ }
+
+ @Override
+ public String paramString() {
+ /*
+ * The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * KeyEvent e = new KeyEvent(new Component() {},
+ * KeyEvent.KEY_PRESSED, 0,
+ * KeyEvent.CTRL_DOWN_MASK|KeyEvent.SHIFT_DOWN_MASK,
+ * KeyEvent.VK_A, 'A', KeyEvent.KEY_LOCATION_STANDARD);
+ * System.out.println(e);
+ */
+
+ String idString = null;
+ String locString = null;
+ String paramString = null;
+ String keyCharString = (keyChar == '\n') ?
+ keyCharString = getKeyText(VK_ENTER) : "'" + keyChar + "'"; //$NON-NLS-1$ //$NON-NLS-2$
+
+ switch (id) {
+ case KEY_PRESSED:
+ idString = "KEY_PRESSED"; //$NON-NLS-1$
+ break;
+ case KEY_RELEASED:
+ idString = "KEY_RELEASED"; //$NON-NLS-1$
+ break;
+ case KEY_TYPED:
+ idString = "KEY_TYPED"; //$NON-NLS-1$
+ break;
+ default:
+ idString = "unknown type"; //$NON-NLS-1$
+ }
+
+ switch(keyLocation){
+ case KEY_LOCATION_STANDARD:
+ locString = "KEY_LOCATION_STANDARD"; //$NON-NLS-1$
+ break;
+ case KEY_LOCATION_LEFT:
+ locString = "KEY_LOCATION_LEFT"; //$NON-NLS-1$
+ break;
+ case KEY_LOCATION_RIGHT:
+ locString = "KEY_LOCATION_RIGHT"; //$NON-NLS-1$
+ break;
+ case KEY_LOCATION_NUMPAD:
+ locString = "KEY_LOCATION_NUMPAD"; //$NON-NLS-1$
+ break;
+ case KEY_LOCATION_UNKNOWN:
+ locString = "KEY_LOCATION_UNKNOWN"; //$NON-NLS-1$
+ break;
+ default:
+ locString = "unknown type"; //$NON-NLS-1$
+ }
+
+ paramString = idString + ",keyCode=" + keyCode; //$NON-NLS-1$
+ if (isActionKey()) {
+ paramString += "," + getKeyText(keyCode); //$NON-NLS-1$
+ } else {
+ paramString += ",keyChar=" + keyCharString; //$NON-NLS-1$
+ }
+ if (getModifiersEx() > 0) {
+ paramString += ",modifiers=" + getModifiersExText(getModifiersEx()) + //$NON-NLS-1$
+ ",extModifiers=" + getModifiersExText(getModifiersEx()); //$NON-NLS-1$
+ }
+ paramString += ",keyLocation=" + locString; //$NON-NLS-1$
+
+ return paramString;
+ }
+
+}
diff --git a/awt/java/awt/event/KeyListener.java b/awt/java/awt/event/KeyListener.java
new file mode 100644
index 0000000..f20fc90
--- /dev/null
+++ b/awt/java/awt/event/KeyListener.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface KeyListener extends EventListener {
+
+ public void keyPressed(KeyEvent e);
+
+ public void keyReleased(KeyEvent e);
+
+ public void keyTyped(KeyEvent e);
+
+}
diff --git a/awt/java/awt/event/MouseAdapter.java b/awt/java/awt/event/MouseAdapter.java
new file mode 100644
index 0000000..4973956
--- /dev/null
+++ b/awt/java/awt/event/MouseAdapter.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+public abstract class MouseAdapter implements MouseListener {
+
+ public MouseAdapter() {
+ }
+
+ public void mouseClicked(MouseEvent e) {
+ }
+
+ public void mouseEntered(MouseEvent e) {
+ }
+
+ public void mouseExited(MouseEvent e) {
+ }
+
+ public void mousePressed(MouseEvent e) {
+ }
+
+ public void mouseReleased(MouseEvent e) {
+ }
+
+}
diff --git a/awt/java/awt/event/MouseEvent.java b/awt/java/awt/event/MouseEvent.java
new file mode 100644
index 0000000..0b776f9
--- /dev/null
+++ b/awt/java/awt/event/MouseEvent.java
@@ -0,0 +1,226 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.Component;
+import java.awt.Point;
+import java.awt.Toolkit;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+public class MouseEvent extends InputEvent {
+
+ private static final long serialVersionUID = -991214153494842848L;
+
+ public static final int MOUSE_FIRST = 500;
+
+ public static final int MOUSE_LAST = 507;
+
+ public static final int MOUSE_CLICKED = 500;
+
+ public static final int MOUSE_PRESSED = 501;
+
+ public static final int MOUSE_RELEASED = 502;
+
+ public static final int MOUSE_MOVED = 503;
+
+ public static final int MOUSE_ENTERED = 504;
+
+ public static final int MOUSE_EXITED = 505;
+
+ public static final int MOUSE_DRAGGED = 506;
+
+ public static final int MOUSE_WHEEL = 507;
+
+ public static final int NOBUTTON = 0;
+
+ public static final int BUTTON1 = 1;
+
+ public static final int BUTTON2 = 2;
+
+ public static final int BUTTON3 = 3;
+
+ private boolean popupTrigger;
+ private int clickCount;
+ private int button;
+ private int x;
+ private int y;
+
+ public static String getMouseModifiersText(int modifiers) {
+ final StringBuffer text = new StringBuffer();
+
+ if ((modifiers & META_MASK) != 0) {
+ text.append(Toolkit.getProperty("AWT.meta", "Meta")).append("+"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+ if ((modifiers & SHIFT_MASK) != 0) {
+ text.append(Toolkit.getProperty("AWT.shift", "Shift")).append("+"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+ if ((modifiers & CTRL_MASK) != 0) {
+ text.append(Toolkit.getProperty("AWT.control", "Ctrl")).append("+"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+ if ((modifiers & ALT_MASK) != 0) {
+ text.append(Toolkit.getProperty("AWT.alt", "Alt")).append("+"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+ if ((modifiers & ALT_GRAPH_MASK) != 0) {
+ text.append(Toolkit.getProperty("AWT.altGraph", "Alt Graph")).append("+"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+ if ((modifiers & BUTTON1_MASK) != 0) {
+ text.append(Toolkit.getProperty("AWT.button1", "Button1")).append("+"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+ if ((modifiers & BUTTON2_MASK) != 0) {
+ text.append(Toolkit.getProperty("AWT.button2", "Button2")).append("+"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+ if ((modifiers & BUTTON3_MASK) != 0) {
+ text.append(Toolkit.getProperty("AWT.button3", "Button3")).append("+"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+ return text.length() == 0 ? text.toString() : text.substring(0, text
+ .length() - 1);
+ }
+
+ static String addMouseModifiersExText(String text, int modifiersEx) {
+ if ((modifiersEx & InputEvent.BUTTON1_DOWN_MASK) != 0) {
+ text += ((text.length() > 0) ? "+" : "") + //$NON-NLS-1$ //$NON-NLS-2$
+ Toolkit.getProperty("AWT.button1", "Button1"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if ((modifiersEx & InputEvent.BUTTON2_DOWN_MASK) != 0) {
+ text += ((text.length() > 0) ? "+" : "") + //$NON-NLS-1$ //$NON-NLS-2$
+ Toolkit.getProperty("AWT.button2", "Button2"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ if ((modifiersEx & InputEvent.BUTTON3_DOWN_MASK) != 0) {
+ text += ((text.length() > 0) ? "+" : "") + //$NON-NLS-1$ //$NON-NLS-2$
+ Toolkit.getProperty("AWT.button3", "Button3"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ return text;
+ }
+
+ public MouseEvent(Component source, int id, long when,
+ int modifiers, int x, int y,
+ int clickCount, boolean popupTrigger) {
+ this(source, id, when, modifiers, x, y,
+ clickCount, popupTrigger, NOBUTTON);
+ }
+
+ public MouseEvent(Component source, int id, long when,
+ int modifiers, int x, int y,
+ int clickCount, boolean popupTrigger, int button) {
+ super(source, id, when, modifiers);
+
+ if ((button != NOBUTTON) && (button != BUTTON1) &&
+ (button != BUTTON2) && (button != BUTTON3)) {
+ // awt.18B=Invalid button value
+ throw new IllegalArgumentException(Messages.getString("awt.18B")); //$NON-NLS-1$
+ }
+
+ this.popupTrigger = popupTrigger;
+ this.clickCount = clickCount;
+ this.button = button;
+ this.x = x;
+ this.y = y;
+ }
+
+ public int getButton() {
+ return button;
+ }
+
+ public int getClickCount() {
+ return clickCount;
+ }
+
+ public Point getPoint() {
+ return new Point(x, y);
+ }
+
+ public int getX() {
+ return x;
+ }
+
+ public int getY() {
+ return y;
+ }
+
+ public boolean isPopupTrigger() {
+ return popupTrigger;
+ }
+
+ public void translatePoint(int x, int y) {
+ this.x += x;
+ this.y += y;
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * MouseEvent e = new MouseEvent(new Component(){},
+ * MouseEvent.MOUSE_PRESSED, 0,
+ * MouseEvent.BUTTON1_DOWN_MASK|MouseEvent.CTRL_DOWN_MASK,
+ * 10, 20, 1, false, MouseEvent.BUTTON1);
+ * System.out.println(e);
+ */
+
+ String idString = null;
+ String paramString = null;
+
+ switch (id) {
+ case MOUSE_MOVED:
+ idString = "MOUSE_MOVED"; //$NON-NLS-1$
+ break;
+ case MOUSE_CLICKED:
+ idString = "MOUSE_CLICKED"; //$NON-NLS-1$
+ break;
+ case MOUSE_PRESSED:
+ idString = "MOUSE_PRESSED"; //$NON-NLS-1$
+ break;
+ case MOUSE_RELEASED:
+ idString = "MOUSE_RELEASED"; //$NON-NLS-1$
+ break;
+ case MOUSE_DRAGGED:
+ idString = "MOUSE_DRAGGED"; //$NON-NLS-1$
+ break;
+ case MOUSE_ENTERED:
+ idString = "MOUSE_ENTERED"; //$NON-NLS-1$
+ break;
+ case MOUSE_EXITED:
+ idString = "MOUSE_EXITED"; //$NON-NLS-1$
+ break;
+ case MOUSE_WHEEL:
+ idString = "MOUSE_WHEEL"; //$NON-NLS-1$
+ break;
+ default:
+ idString = "unknown type"; //$NON-NLS-1$
+ }
+
+ paramString = idString + ",(" + getX() + "," + getY() + ")" + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ ",button=" + button; //$NON-NLS-1$
+ if (getModifiersEx() > 0) {
+ paramString +=
+ ",modifiers=" + getModifiersExText(getModifiersEx()) + //$NON-NLS-1$
+ ",extModifiers=" + getModifiersExText(getModifiersEx()); //$NON-NLS-1$
+ }
+ paramString += ",clickCount=" + getClickCount(); //$NON-NLS-1$
+
+ return paramString;
+ }
+
+}
diff --git a/awt/java/awt/event/MouseListener.java b/awt/java/awt/event/MouseListener.java
new file mode 100644
index 0000000..5d32b0f
--- /dev/null
+++ b/awt/java/awt/event/MouseListener.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface MouseListener extends EventListener {
+
+ public void mouseClicked(MouseEvent e);
+
+ public void mouseEntered(MouseEvent e);
+
+ public void mouseExited(MouseEvent e);
+
+ public void mousePressed(MouseEvent e);
+
+ public void mouseReleased(MouseEvent e);
+
+}
diff --git a/awt/java/awt/event/MouseMotionAdapter.java b/awt/java/awt/event/MouseMotionAdapter.java
new file mode 100644
index 0000000..a4bebcc
--- /dev/null
+++ b/awt/java/awt/event/MouseMotionAdapter.java
@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+public abstract class MouseMotionAdapter implements MouseMotionListener {
+
+ public MouseMotionAdapter() {
+ }
+
+ public void mouseDragged(MouseEvent e) {
+ }
+
+ public void mouseMoved(MouseEvent e) {
+ }
+
+}
diff --git a/awt/java/awt/event/MouseMotionListener.java b/awt/java/awt/event/MouseMotionListener.java
new file mode 100644
index 0000000..a5c11da
--- /dev/null
+++ b/awt/java/awt/event/MouseMotionListener.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface MouseMotionListener extends EventListener {
+
+ public void mouseDragged(MouseEvent e);
+
+ public void mouseMoved(MouseEvent e);
+
+}
diff --git a/awt/java/awt/event/MouseWheelEvent.java b/awt/java/awt/event/MouseWheelEvent.java
new file mode 100644
index 0000000..d3ac9d8
--- /dev/null
+++ b/awt/java/awt/event/MouseWheelEvent.java
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.Component;
+
+public class MouseWheelEvent extends MouseEvent {
+
+ private static final long serialVersionUID = -9187413581993563929L;
+
+ public static final int WHEEL_UNIT_SCROLL = 0;
+
+ public static final int WHEEL_BLOCK_SCROLL = 1;
+
+ private int wheelRotation;
+ private int scrollAmount;
+ private int scrollType;
+
+ public MouseWheelEvent(Component source, int id, long when, int modifiers,
+ int x, int y, int clickCount, boolean popupTrigger, int scrollType,
+ int scrollAmount, int wheelRotation) {
+ super(source, id, when, modifiers, x, y, clickCount, popupTrigger);
+
+ this.scrollType = scrollType;
+ this.scrollAmount = scrollAmount;
+ this.wheelRotation = wheelRotation;
+ }
+
+ public int getScrollAmount() {
+ return scrollAmount;
+ }
+
+ public int getScrollType() {
+ return scrollType;
+ }
+
+ public int getWheelRotation() {
+ return wheelRotation;
+ }
+
+ public int getUnitsToScroll() {
+ return (scrollAmount * wheelRotation);
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * MouseWheelEvent e = new MouseWheelEvent(new Component(){},
+ * MouseWheelEvent.MOUSE_WHEEL, 0,
+ * MouseEvent.BUTTON1_DOWN_MASK|MouseEvent.CTRL_DOWN_MASK,
+ * 10, 20, 1, false, MouseWheelEvent.WHEEL_UNIT_SCROLL,
+ * 1, 3);
+ * System.out.println(e);
+ */
+
+ String paramString = super.paramString();
+ String typeString = null;
+
+ switch (scrollType) {
+ case WHEEL_UNIT_SCROLL:
+ typeString = "WHEEL_UNIT_SCROLL"; //$NON-NLS-1$
+ break;
+ case WHEEL_BLOCK_SCROLL:
+ typeString = "WHEEL_BLOCK_SCROLL"; //$NON-NLS-1$
+ break;
+ default:
+ typeString = "unknown type"; //$NON-NLS-1$
+ }
+
+ paramString += ",scrollType=" + typeString + //$NON-NLS-1$
+ ",scrollAmount=" + scrollAmount + //$NON-NLS-1$
+ ",wheelRotation=" + wheelRotation; //$NON-NLS-1$
+
+ return paramString;
+ }
+
+}
diff --git a/awt/java/awt/event/MouseWheelListener.java b/awt/java/awt/event/MouseWheelListener.java
new file mode 100644
index 0000000..8ca1c8b
--- /dev/null
+++ b/awt/java/awt/event/MouseWheelListener.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface MouseWheelListener extends EventListener {
+
+ public void mouseWheelMoved(MouseWheelEvent e);
+
+}
diff --git a/awt/java/awt/event/PaintEvent.java b/awt/java/awt/event/PaintEvent.java
new file mode 100644
index 0000000..d0573e1
--- /dev/null
+++ b/awt/java/awt/event/PaintEvent.java
@@ -0,0 +1,80 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.Component;
+import java.awt.Rectangle;
+
+public class PaintEvent extends ComponentEvent {
+
+ private static final long serialVersionUID = 1267492026433337593L;
+
+ public static final int PAINT_FIRST = 800;
+
+ public static final int PAINT_LAST = 801;
+
+ public static final int PAINT = 800;
+
+ public static final int UPDATE = 801;
+
+ private Rectangle updateRect;
+
+ public PaintEvent(Component source, int id, Rectangle updateRect) {
+ super(source, id);
+
+ this.updateRect = updateRect;
+ }
+
+ public Rectangle getUpdateRect() {
+ return updateRect;
+ }
+
+ public void setUpdateRect(Rectangle updateRect) {
+ this.updateRect = updateRect;
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * PaintEvent e = new PaintEvent(new Component(){},
+ * PaintEvent.PAINT, new Rectangle(0, 0, 10, 20));
+ * System.out.println(e);
+ */
+
+ String typeString = null;
+
+ switch (id) {
+ case PAINT:
+ typeString = "PAINT"; //$NON-NLS-1$
+ break;
+ case UPDATE:
+ typeString = "UPDATE"; //$NON-NLS-1$
+ break;
+ default:
+ typeString = "unknown type"; //$NON-NLS-1$
+ }
+
+ return typeString + ",updateRect=" + updateRect; //$NON-NLS-1$
+ }
+
+}
diff --git a/awt/java/awt/event/TextEvent.java b/awt/java/awt/event/TextEvent.java
new file mode 100644
index 0000000..e2bfd96
--- /dev/null
+++ b/awt/java/awt/event/TextEvent.java
@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.awt.AWTEvent;
+
+public class TextEvent extends AWTEvent {
+
+ private static final long serialVersionUID = 6269902291250941179L;
+
+ public static final int TEXT_FIRST = 900;
+
+ public static final int TEXT_LAST = 900;
+
+ public static final int TEXT_VALUE_CHANGED = 900;
+
+ public TextEvent(Object src, int id) {
+ super(src, id);
+ }
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * TextEvent e = new TextEvent(new Component(){},
+ * TextEvent.TEXT_VALUE_CHANGED);
+ * System.out.println(e);
+ */
+
+ return (id == TEXT_VALUE_CHANGED) ?
+ "TEXT_VALUE_CHANGED" : "unknown type"; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+}
diff --git a/awt/java/awt/event/TextListener.java b/awt/java/awt/event/TextListener.java
new file mode 100644
index 0000000..6c5a671
--- /dev/null
+++ b/awt/java/awt/event/TextListener.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface TextListener extends EventListener {
+
+ public void textValueChanged(TextEvent e);
+
+}
+
diff --git a/awt/java/awt/event/WindowAdapter.java b/awt/java/awt/event/WindowAdapter.java
new file mode 100644
index 0000000..9d4b377
--- /dev/null
+++ b/awt/java/awt/event/WindowAdapter.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+public abstract class WindowAdapter implements WindowListener, WindowStateListener, WindowFocusListener {
+
+ public WindowAdapter() {
+ }
+
+ public void windowActivated(WindowEvent e) {
+ }
+
+ public void windowClosed(WindowEvent e) {
+ }
+
+ public void windowClosing(WindowEvent e) {
+ }
+
+ public void windowDeactivated(WindowEvent e) {
+ }
+
+ public void windowDeiconified(WindowEvent e) {
+ }
+
+ public void windowGainedFocus(WindowEvent e) {
+ }
+
+ public void windowIconified(WindowEvent e) {
+ }
+
+ public void windowLostFocus(WindowEvent e) {
+ }
+
+ public void windowOpened(WindowEvent e) {
+ }
+
+ public void windowStateChanged(WindowEvent e) {
+ }
+
+}
diff --git a/awt/java/awt/event/WindowEvent.java b/awt/java/awt/event/WindowEvent.java
new file mode 100644
index 0000000..65a30e4
--- /dev/null
+++ b/awt/java/awt/event/WindowEvent.java
@@ -0,0 +1,162 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+
+//???AWT
+//import java.awt.Window;
+//import java.awt.Frame;
+
+public class WindowEvent extends ComponentEvent {
+
+ private static final long serialVersionUID = -1567959133147912127L;
+
+ public static final int WINDOW_FIRST = 200;
+
+ public static final int WINDOW_OPENED = 200;
+
+ public static final int WINDOW_CLOSING = 201;
+
+ public static final int WINDOW_CLOSED = 202;
+
+ public static final int WINDOW_ICONIFIED = 203;
+
+ public static final int WINDOW_DEICONIFIED = 204;
+
+ public static final int WINDOW_ACTIVATED = 205;
+
+ public static final int WINDOW_DEACTIVATED = 206;
+
+ public static final int WINDOW_GAINED_FOCUS = 207;
+
+ public static final int WINDOW_LOST_FOCUS = 208;
+
+ public static final int WINDOW_STATE_CHANGED = 209;
+
+ public static final int WINDOW_LAST = 209;
+
+ //???AWT: private Window oppositeWindow;
+ private int oldState;
+ private int newState;
+
+ //???AWT
+ /*
+ public WindowEvent(Window source, int id) {
+ this(source, id, null);
+ }
+
+ public WindowEvent(Window source, int id, Window opposite) {
+ this(source, id, opposite, Frame.NORMAL, Frame.NORMAL);
+ }
+
+ public WindowEvent(Window source, int id, int oldState, int newState) {
+ this(source, id, null, oldState, newState);
+ }
+
+ public WindowEvent(Window source, int id, Window opposite,
+ int oldState, int newState) {
+ super(source, id);
+
+ oppositeWindow = opposite;
+ this.oldState = oldState;
+ this.newState = newState;
+ }
+ */
+ //???AWT: Fake constructor
+ public WindowEvent() {
+ super(null, 0);
+ }
+
+ public int getNewState() {
+ return newState;
+ }
+
+ public int getOldState() {
+ return oldState;
+ }
+
+ //???AWT
+ /*
+ public Window getOppositeWindow() {
+ return oppositeWindow;
+ }
+
+ public Window getWindow() {
+ return (Window) source;
+ }
+ */
+
+ @Override
+ public String paramString() {
+ /* The format is based on 1.5 release behavior
+ * which can be revealed by the following code:
+ *
+ * WindowEvent e = new WindowEvent(new Frame(),
+ * WindowEvent.WINDOW_OPENED);
+ * System.out.println(e);
+ */
+
+ String typeString = null;
+
+ switch (id) {
+ case WINDOW_OPENED:
+ typeString = "WINDOW_OPENED"; //$NON-NLS-1$
+ break;
+ case WINDOW_CLOSING:
+ typeString = "WINDOW_CLOSING"; //$NON-NLS-1$
+ break;
+ case WINDOW_CLOSED:
+ typeString = "WINDOW_CLOSED"; //$NON-NLS-1$
+ break;
+ case WINDOW_ICONIFIED:
+ typeString = "WINDOW_ICONIFIED"; //$NON-NLS-1$
+ break;
+ case WINDOW_DEICONIFIED:
+ typeString = "WINDOW_DEICONIFIED"; //$NON-NLS-1$
+ break;
+ case WINDOW_ACTIVATED:
+ typeString = "WINDOW_ACTIVATED"; //$NON-NLS-1$
+ break;
+ case WINDOW_DEACTIVATED:
+ typeString = "WINDOW_DEACTIVATED"; //$NON-NLS-1$
+ break;
+ case WINDOW_GAINED_FOCUS:
+ typeString = "WINDOW_GAINED_FOCUS"; //$NON-NLS-1$
+ break;
+ case WINDOW_LOST_FOCUS:
+ typeString = "WINDOW_LOST_FOCUS"; //$NON-NLS-1$
+ break;
+ case WINDOW_STATE_CHANGED:
+ typeString = "WINDOW_STATE_CHANGED"; //$NON-NLS-1$
+ break;
+ default:
+ typeString = "unknown type"; //$NON-NLS-1$
+ }
+
+ //???AWT
+ /*
+ return typeString + ",opposite=" + oppositeWindow + //$NON-NLS-1$
+ ",oldState=" + oldState + ",newState=" + newState; //$NON-NLS-1$ //$NON-NLS-2$
+ */
+ return typeString;
+ }
+
+}
diff --git a/awt/java/awt/event/WindowFocusListener.java b/awt/java/awt/event/WindowFocusListener.java
new file mode 100644
index 0000000..e0200f2
--- /dev/null
+++ b/awt/java/awt/event/WindowFocusListener.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface WindowFocusListener extends EventListener {
+
+ public void windowGainedFocus(WindowEvent e);
+
+ public void windowLostFocus(WindowEvent e);
+
+}
diff --git a/awt/java/awt/event/WindowListener.java b/awt/java/awt/event/WindowListener.java
new file mode 100644
index 0000000..20a2b08
--- /dev/null
+++ b/awt/java/awt/event/WindowListener.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface WindowListener extends EventListener {
+
+ public void windowActivated(WindowEvent e);
+
+ public void windowClosed(WindowEvent e);
+
+ public void windowClosing(WindowEvent e);
+
+ public void windowDeactivated(WindowEvent e);
+
+ public void windowDeiconified(WindowEvent e);
+
+ public void windowIconified(WindowEvent e);
+
+ public void windowOpened(WindowEvent e);
+
+}
diff --git a/awt/java/awt/event/WindowStateListener.java b/awt/java/awt/event/WindowStateListener.java
new file mode 100644
index 0000000..12dbc20
--- /dev/null
+++ b/awt/java/awt/event/WindowStateListener.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Michael Danilov
+ * @version $Revision$
+ */
+package java.awt.event;
+
+import java.util.EventListener;
+
+public interface WindowStateListener extends EventListener {
+
+ public void windowStateChanged(WindowEvent e);
+
+}
+
diff --git a/awt/java/awt/font/FontRenderContext.java b/awt/java/awt/font/FontRenderContext.java
new file mode 100644
index 0000000..766300d
--- /dev/null
+++ b/awt/java/awt/font/FontRenderContext.java
@@ -0,0 +1,168 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+import java.awt.geom.AffineTransform;
+
+/**
+ * The FontRenderContext class contains the information
+ * about text measurement. Anti-aliasing and fractional-metrics
+ * modes are defined by an application and affect the size of
+ * a character.
+ */
+public class FontRenderContext {
+
+ // Affine transform of this mode
+ /** The transform. */
+ private AffineTransform transform;
+
+ // Is the anti-aliased mode used
+ /** The anti aliased. */
+ private boolean fAntiAliased;
+
+ // Is the fractional metrics used
+ /** The fractional metrics. */
+ private boolean fFractionalMetrics;
+
+
+ /**
+ * Instantiates a new FontRenderContext object with the specified
+ * AffineTransform, anti-aliasing and fractional metrics flags.
+ *
+ * @param trans the AffineTransform.
+ * @param antiAliased the anti-aliasing flag.
+ * @param usesFractionalMetrics the fractional metrics flag.
+ */
+ public FontRenderContext(AffineTransform trans, boolean antiAliased,
+ boolean usesFractionalMetrics) {
+ if (trans != null){
+ transform = new AffineTransform(trans);
+ }
+ fAntiAliased = antiAliased;
+ fFractionalMetrics = usesFractionalMetrics;
+ }
+
+ /**
+ * Instantiates a new FontRenderContext object.
+ */
+ protected FontRenderContext() {
+ }
+
+ /**
+ * Compares the specified Object with current FontRenderContext object.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if the specified Object is equal to current
+ * FontRenderContext object.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+
+ if (obj != null) {
+ try {
+ return equals((FontRenderContext) obj);
+ } catch (ClassCastException e) {
+ return false;
+ }
+ }
+ return false;
+
+ }
+
+ /**
+ * Gets the transform which is used for scaling typographical points
+ * to pixels in this FontRenderContext.
+ *
+ * @return the AffineTransform which is used for scaling typographical
+ * points to pixels in this FontRenderContext.
+ */
+ public AffineTransform getTransform() {
+ if (transform != null){
+ return new AffineTransform(transform);
+ }
+ return new AffineTransform();
+ }
+
+ /**
+ * Compares the specified FontRenderContext object with current
+ * FontRenderContext.
+ *
+ * @param frc the FontRenderContext object to be compared.
+ *
+ * @return true, if the specified FontRenderContext object is
+ * equal to current FontRenderContext.
+ */
+ public boolean equals(FontRenderContext frc) {
+ if (this == frc){
+ return true;
+ }
+
+ if (frc == null){
+ return false;
+ }
+
+ if (!frc.getTransform().equals(this.getTransform()) &&
+ !frc.isAntiAliased() == this.fAntiAliased &&
+ !frc.usesFractionalMetrics() == this.fFractionalMetrics){
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Returns true if the text fractional metrics are used in
+ * this FontRenderContext.
+ *
+ * @return true, if the text fractional metrics are used in
+ * this FontRenderContext, false otherwise.
+ */
+ public boolean usesFractionalMetrics() {
+ return this.fFractionalMetrics;
+ }
+
+ /**
+ * Returns true if anti-aliasing is used in this FontRenderContext.
+ *
+ * @return true, if is anti-aliasing is used in this FontRenderContext,
+ * false otherwise.
+ */
+ public boolean isAntiAliased() {
+ return this.fAntiAliased;
+ }
+
+ /**
+ * Returns hash code of the FontRenderContext object.
+ *
+ * @return the hash code of the FontRenderContext object.
+ */
+ @Override
+ public int hashCode() {
+ return this.getTransform().hashCode() ^
+ new Boolean(this.fFractionalMetrics).hashCode() ^
+ new Boolean(this.fAntiAliased).hashCode();
+ }
+
+}
+
diff --git a/awt/java/awt/font/GlyphJustificationInfo.java b/awt/java/awt/font/GlyphJustificationInfo.java
new file mode 100644
index 0000000..4c3e02e
--- /dev/null
+++ b/awt/java/awt/font/GlyphJustificationInfo.java
@@ -0,0 +1,185 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The GlyphJustificationInfo class provides information about
+ * the glyph's justification properties. There are four justification
+ * properties: weight, priority, absorb, and limit.
+ * <p>
+ * There are two sets of metrics: growing and shrinking.
+ * Growing metrics are used when the glyphs are to be spread apart
+ * to fit a larger width. Shrinking metrics are used when the glyphs
+ * are to be moved together to fit a smaller width.
+ */
+public final class GlyphJustificationInfo {
+
+ /**
+ * The Constant PRIORITY_KASHIDA indicates the highest
+ * justification priority.
+ */
+ public static final int PRIORITY_KASHIDA = 0;
+
+ /**
+ * The Constant PRIORITY_WHITESPACE indicates the second highest
+ * justification priority.
+ */
+ public static final int PRIORITY_WHITESPACE = 1;
+
+ /**
+ * The Constant PRIORITY_INTERCHAR indicates the second lowest
+ * justification priority.
+ */
+ public static final int PRIORITY_INTERCHAR = 2;
+
+ /**
+ * The Constant PRIORITY_NONE indicates the lowest justification
+ * priority.
+ */
+ public static final int PRIORITY_NONE = 3;
+
+ /**
+ * The grow absorb flag indicates if this glyph absorbs all extra
+ * space at this and lower priority levels when it grows.
+ */
+ public final boolean growAbsorb;
+
+ /**
+ * The grow left limit value represents the maximum value by which
+ * the left side of this glyph grows.
+ */
+ public final float growLeftLimit;
+
+ /**
+ * The grow right limit value repesents the maximum value by which
+ * the right side of this glyph grows.
+ */
+ public final float growRightLimit;
+
+ /**
+ * The grow priority value represents the priority level of this
+ * glyph as it is growing.
+ */
+ public final int growPriority;
+
+ /**
+ * The shrink absorb fleg indicates this glyph absorbs all remaining
+ * shrinkage at this and lower priority levels as it shrinks.
+ */
+ public final boolean shrinkAbsorb;
+
+ /**
+ * The shrink left limit value represents the maximum value by which
+ * the left side of this glyph shrinks.
+ */
+ public final float shrinkLeftLimit;
+
+ /**
+ * The shrink right limit value represents the maximum value by which
+ * the right side of this glyph shrinks.
+ */
+ public final float shrinkRightLimit;
+
+ /**
+ * The shrink priority represents the glyth's priority level
+ * as it is shrinking.
+ */
+ public final int shrinkPriority;
+
+ /**
+ * The weight of the glyph.
+ */
+ public final float weight;
+
+ /**
+ * Instantiates a new GlyphJustificationInfo object which contains
+ * glyph's justification properties.
+ *
+ * @param weight the weight of glyph.
+ * @param growAbsorb indicates if this glyph contais all space
+ * at this priority and lower priority levels when it grows.
+ * @param growPriority indicates the priority level of this glyph
+ * when it grows.
+ * @param growLeftLimit indicates the maximum value of which the
+ * left side of this glyph can grow.
+ * @param growRightLimit the maximum value of which the right side of
+ * this glyph can grow.
+ * @param shrinkAbsorb indicates if this glyph contains all remaining
+ * shrinkage at this and lower priority levels when it shrinks.
+ * @param shrinkPriority indicates the glyph's priority level when
+ * it shrinks.
+ * @param shrinkLeftLimit indicates the maximum value of which
+ * the left side of this glyph can shrink.
+ * @param shrinkRightLimit indicates the maximum amount by which
+ * the right side of this glyph can shrink.
+ */
+ public GlyphJustificationInfo(float weight, boolean growAbsorb, int growPriority,
+ float growLeftLimit, float growRightLimit, boolean shrinkAbsorb,
+ int shrinkPriority, float shrinkLeftLimit, float shrinkRightLimit) {
+
+ if (weight < 0) {
+ // awt.19C=weight must be a positive number
+ throw new IllegalArgumentException(Messages.getString("awt.19C")); //$NON-NLS-1$
+ }
+ this.weight = weight;
+
+ if (growLeftLimit < 0) {
+ // awt.19D=growLeftLimit must be a positive number
+ throw new IllegalArgumentException(Messages.getString("awt.19D")); //$NON-NLS-1$
+ }
+ this.growLeftLimit = growLeftLimit;
+
+ if (growRightLimit < 0) {
+ // awt.19E=growRightLimit must be a positive number
+ throw new IllegalArgumentException(Messages.getString("awt.19E")); //$NON-NLS-1$
+ }
+ this.growRightLimit = growRightLimit;
+
+ if ((shrinkPriority < 0) || (shrinkPriority > PRIORITY_NONE)) {
+ // awt.19F=incorrect value for shrinkPriority, more than PRIORITY_NONE or less than PRIORITY_KASHIDA value
+ throw new IllegalArgumentException(Messages.getString("awt.19F")); //$NON-NLS-1$
+ }
+ this.shrinkPriority = shrinkPriority;
+
+ if ((growPriority < 0) || (growPriority > PRIORITY_NONE)) {
+ // awt.200=incorrect value for growPriority, more than PRIORITY_NONE or less than PRIORITY_KASHIDA value
+ throw new IllegalArgumentException(Messages.getString("awt.200")); //$NON-NLS-1$
+ }
+ this.growPriority = growPriority;
+
+ if (shrinkLeftLimit < 0) {
+ // awt.201=shrinkLeftLimit must be a positive number
+ throw new IllegalArgumentException(Messages.getString("awt.201")); //$NON-NLS-1$
+ }
+ this.shrinkLeftLimit = shrinkLeftLimit;
+
+ if (shrinkRightLimit < 0) {
+ // awt.202=shrinkRightLimit must be a positive number
+ throw new IllegalArgumentException(Messages.getString("awt.202")); //$NON-NLS-1$
+ }
+ this.shrinkRightLimit = shrinkRightLimit;
+
+ this.shrinkAbsorb = shrinkAbsorb;
+ this.growAbsorb = growAbsorb;
+ }
+}
diff --git a/awt/java/awt/font/GlyphMetrics.java b/awt/java/awt/font/GlyphMetrics.java
new file mode 100644
index 0000000..d96ef18
--- /dev/null
+++ b/awt/java/awt/font/GlyphMetrics.java
@@ -0,0 +1,248 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+import java.awt.geom.Rectangle2D;
+
+/**
+ * The GlyphMetrics class provides information about the size and shape
+ * of a single glyph.
+ * Each glyph has information to specify whether its baseline is horizontal
+ * or vertical as well as information on how it interacts with
+ * other characters in a text, given as one of the
+ * following types: STANDARD, LIGATURE, COMBINING, or COMPONENT.
+ */
+public final class GlyphMetrics {
+
+ // advance width of the glyph character cell
+ /** The advance x. */
+ private float advanceX;
+
+ // advance height of the glyph character cell
+ /** The advance y. */
+ private float advanceY;
+
+ // flag if the glyph horizontal
+ /** The horizontal. */
+ private boolean horizontal;
+
+ // glyph type code
+ /** The glyph type. */
+ private byte glyphType;
+
+ // bounding box for outline of the glyph
+ /** The bounds. */
+ private Rectangle2D.Float bounds;
+
+ /**
+ * The Constant STANDARD indicates a glyph that represents a single
+ * character.
+ */
+ public static final byte STANDARD = 0;
+
+ /**
+ * The Constant LIGATURE indicates a glyph that represents multiple
+ * characters as a ligature.
+ */
+ public static final byte LIGATURE = 1;
+
+ /**
+ * The Constant COMBINING indicates a glyph which has no caret position
+ * between glyphs (for example umlaut).
+ */
+ public static final byte COMBINING = 2;
+
+ /**
+ * The Constant COMPONENT indicates a glyph with no corresponding character
+ * in the backing store.
+ */
+ public static final byte COMPONENT = 3;
+
+ /**
+ * The Constant WHITESPACE indicates a glyph without visual
+ * representation.
+ */
+ public static final byte WHITESPACE = 4;
+
+ /**
+ * Instantiates a new GlyphMetrics object with the specified parameters.
+ *
+ * @param horizontal specifies if metrics are for a horizontal baseline
+ * (true value), or a vertical baseline (false value).
+ * @param advanceX the X component of the glyph's advance.
+ * @param advanceY the Y component of the glyph's advance.
+ * @param bounds the glyph's bounds.
+ * @param glyphType the glyph's type.
+ */
+ public GlyphMetrics(boolean horizontal, float advanceX, float advanceY,
+ Rectangle2D bounds, byte glyphType) {
+ this.horizontal = horizontal;
+ this.advanceX = advanceX;
+ this.advanceY = advanceY;
+
+ this.bounds = new Rectangle2D.Float();
+ this.bounds.setRect(bounds);
+
+ this.glyphType = glyphType;
+ }
+
+ /**
+ * Instantiates a new horizontal GlyphMetrics with the specified parameters.
+ *
+ * @param advanceX the X component of the glyph's advance.
+ * @param bounds the glyph's bounds.
+ * @param glyphType the glyph's type.
+ */
+ public GlyphMetrics(float advanceX, Rectangle2D bounds, byte glyphType) {
+ this.advanceX = advanceX;
+ this.advanceY = 0;
+
+ this.horizontal = true;
+
+ this.bounds = new Rectangle2D.Float();
+ this.bounds.setRect(bounds);
+
+ this.glyphType = glyphType;
+ }
+
+ /**
+ * Gets the glyph's bounds.
+ *
+ * @return glyph's bounds.
+ */
+ public Rectangle2D getBounds2D() {
+ return (Rectangle2D.Float) this.bounds.clone();
+ }
+
+ /**
+ * Checks if this glyph is whitespace or not.
+ *
+ * @return true, if this glyph is whitespace, false otherwise.
+ */
+ public boolean isWhitespace() {
+ return ((this.glyphType & 4) == WHITESPACE);
+ }
+
+ /**
+ * Checks if this glyph is standard or not.
+ *
+ * @return true, if this glyph is standard, false otherwise.
+ */
+ public boolean isStandard() {
+ return ((this.glyphType & 3) == STANDARD);
+ }
+
+ /**
+ * Checks if this glyph is ligature or not.
+ *
+ * @return true, if this glyph is ligature, false otherwise.
+ */
+ public boolean isLigature() {
+ return ((this.glyphType & 3) == LIGATURE);
+ }
+
+ /**
+ * Checks if this glyph is component or not.
+ *
+ * @return true, if this glyph is component, false otherwise.
+ */
+ public boolean isComponent() {
+ return ((this.glyphType & 3) == COMPONENT);
+ }
+
+ /**
+ * Checks if this glyph is combining or not.
+ *
+ * @return true, if this glyph is combining, false otherwise.
+ */
+ public boolean isCombining() {
+ return ((this.glyphType & 3) == COMBINING);
+ }
+
+ /**
+ * Gets the glyph's type.
+ *
+ * @return the glyph's type.
+ */
+ public int getType() {
+ return this.glyphType;
+ }
+
+ /**
+ * Gets the distance from the right (for horizontal) or
+ * bottom (for vertical) of the glyph bounds to the advance.
+ *
+ * @return the distance from the right (for horizontal) or
+ * bottom (for vertical) of the glyph bounds to the advance.
+ */
+ public float getRSB() {
+ if (this.horizontal) {
+ return this.advanceX - this.bounds.x - (float)this.bounds.getWidth();
+ }
+ return this.advanceY - this.bounds.y - (float)this.bounds.getHeight();
+ }
+
+ /**
+ * Gets the distance from 0, 0 to the left (for horizontal)
+ * or top (for vertical) of the glyph bounds.
+ *
+ * @return the distance from 0, 0 to the left (for horizontal)
+ * or top (for vertical) of the glyph bounds.
+ */
+ public float getLSB() {
+ if (this.horizontal) {
+ return this.bounds.x;
+ }
+ return this.bounds.y;
+ }
+
+ /**
+ * Gets the Y component of the glyph's advance.
+ *
+ * @return the Y component of the glyph's advance.
+ */
+ public float getAdvanceY() {
+ return this.advanceY;
+ }
+
+ /**
+ * Gets the X component of the glyph's advance.
+ *
+ * @return the X component of the glyph's advance.
+ */
+ public float getAdvanceX() {
+ return this.advanceX;
+ }
+
+ /**
+ * Gets the glyph's advance along the baseline.
+ *
+ * @return the glyph's advance.
+ */
+ public float getAdvance() {
+ if (this.horizontal) {
+ return this.advanceX;
+ }
+ return this.advanceY;
+ }
+
+}
+
diff --git a/awt/java/awt/font/GlyphVector.java b/awt/java/awt/font/GlyphVector.java
new file mode 100644
index 0000000..b3c9406
--- /dev/null
+++ b/awt/java/awt/font/GlyphVector.java
@@ -0,0 +1,394 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+import java.awt.Font;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphJustificationInfo;
+import java.awt.font.GlyphMetrics;
+
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * The GlyphVector class contains a collection of glyphs with geometric
+ * information and each glyph's location. Each GlyphVector can be associated
+ * with only one Font. GlyphVector contains the following properties for
+ * each glyph:
+ * <ul>
+ * <li>the glyph position;</li>
+ * <li>the transform of the glyph;</li>
+ * <li>the metrics of the glyph in the context of the GlyphVector.</li>
+ * </ul>
+ */
+public abstract class GlyphVector implements Cloneable {
+
+ /**
+ * The Constant FLAG_HAS_TRANSFORMS indicates that this GlyphVector
+ * has per-glyph transforms.
+ */
+ public static final int FLAG_HAS_TRANSFORMS = 1;
+
+ /**
+ * The Constant FLAG_HAS_POSITION_ADJUSTMENTS indicates that
+ * the GlyphVector has per-glyph position adjustments.
+ */
+ public static final int FLAG_HAS_POSITION_ADJUSTMENTS = 2;
+
+ /**
+ * The Constant FLAG_RUN_RTL indicates that this GlyphVector has a
+ * right to left run direction.
+ */
+ public static final int FLAG_RUN_RTL = 4;
+
+ /**
+ * The Constant FLAG_COMPLEX_GLYPHS indicates that this GlyphVector
+ * has a complex glyph to char mapping.
+ */
+ public static final int FLAG_COMPLEX_GLYPHS = 8;
+
+ /**
+ * The Constant FLAG_MASK indicates a mask for supported flags
+ * from getLayoutFlags.
+ */
+ public static final int FLAG_MASK = 15; // (|) mask of other flags
+
+ /**
+ * Instantiates a new GlyphVector.
+ */
+ public GlyphVector() {
+ }
+
+ /**
+ * Gets the pixel bounds of the GlyphVector when rendered
+ * at the specified location with the specified FontRenderContext.
+ *
+ * @param frc the FontRenderContext.
+ * @param x the X coordinate of the GlyphVector's location.
+ * @param y the Y coordinate of the GlyphVector's location.
+ *
+ * @return the pixel bounds
+ */
+ public Rectangle getPixelBounds(FontRenderContext frc, float x, float y) {
+ // default implementation - integer Rectangle, that encloses visual
+ // bounds rectangle
+ Rectangle2D visualRect = getVisualBounds();
+
+ int minX = (int)Math.floor(visualRect.getMinX() + x);
+ int minY = (int)Math.floor(visualRect.getMinY() + y);
+ int width = (int)Math.ceil(visualRect.getMaxX() + x) - minX;
+ int height = (int)Math.ceil(visualRect.getMaxY() + y) - minY;
+
+ return new Rectangle(minX, minY, width, height);
+ }
+
+ /**
+ * Gets the pixel bounds of the glyph with the specified index in
+ * this GlyphVector which is rendered with the specified
+ * FontRenderContext at the specified location.
+ *
+ * @param index the glyph index in this GlyphVector.
+ * @param frc the FontRenderContext.
+ * @param x the X coordinate of the GlyphVector's location.
+ * @param y the Y coordinate of the GlyphVector's location.
+ *
+ * @return a Rectangle bounds.
+ */
+ public Rectangle getGlyphPixelBounds(int index, FontRenderContext frc,
+ float x, float y) {
+ Rectangle2D visualRect = getGlyphVisualBounds(index).getBounds2D();
+
+ int minX = (int)Math.floor(visualRect.getMinX() + x);
+ int minY = (int)Math.floor(visualRect.getMinY() + y);
+ int width = (int)Math.ceil(visualRect.getMaxX() + x) - minX;
+ int height = (int)Math.ceil(visualRect.getMaxY() + y) - minY;
+
+ return new Rectangle(minX, minY, width, height);
+ }
+
+ /**
+ * Gets the visual bounds of the GlyphVector.
+ *
+ * @return the visual bounds of the GlyphVector.
+ */
+ public abstract Rectangle2D getVisualBounds();
+
+ /**
+ * Gets the logical bounds of the GlyphVector.
+ *
+ * @return the logical bounds of the GlyphVector.
+ */
+ public abstract Rectangle2D getLogicalBounds();
+
+ /**
+ * Sets the position of the specified glyph in this GlyphVector.
+ *
+ * @param glyphIndex the glyph index in this GlyphVector.
+ * @param newPos the new position of the glyph at the specified glyphIndex.
+ */
+ public abstract void setGlyphPosition(int glyphIndex, Point2D newPos);
+
+ /**
+ * Gets the position of the specified glyph in this GlyphVector.
+ *
+ * @param glyphIndex the glyph index in this GlyphVector.
+ *
+ * @return the position of the specified glyph in this GlyphVector.
+ */
+ public abstract Point2D getGlyphPosition(int glyphIndex);
+
+ /**
+ * Sets the affine transform to a glyph with the specified index
+ * in this GlyphVector.
+ *
+ * @param glyphIndex the glyth index in this GlyphVector.
+ * @param trans the AffineTransform to be assigned to the
+ * specified glyph.
+ */
+ public abstract void setGlyphTransform(int glyphIndex,
+ AffineTransform trans);
+
+ /**
+ * Gets the transform of the specified glyph in this GlyphVector.
+ *
+ * @param glyphIndex the glyph index in this GlyphVector.
+ *
+ * @return the new transform of the glyph.
+ */
+ public abstract AffineTransform getGlyphTransform(int glyphIndex);
+
+ /**
+ * Compares this GlyphVector with the specified GlyphVector objects.
+ *
+ * @param glyphVector the GlyphVector object to be compared.
+ *
+ * @return true, if this GlyphVector is equal to the specified GlyphVector
+ * object, false otherwise.
+ */
+ public abstract boolean equals(GlyphVector glyphVector);
+
+ /**
+ * Gets the metrics of the glyph with the specified index
+ * in this GlyphVector.
+ *
+ * @param glyphIndex index in this GlyphVector.
+ *
+ * @return the metrics of the glyph with the specified index
+ * in this GlyphVector.
+ */
+ public abstract GlyphMetrics getGlyphMetrics(int glyphIndex);
+
+ /**
+ * Gets the justification information of the glyph
+ * whose index is specified.
+ *
+ * @param glyphIndex the glyph index.
+ *
+ * @return the GlyphJustificationInfo for the specified glyph.
+ */
+ public abstract GlyphJustificationInfo getGlyphJustificationInfo(
+ int glyphIndex);
+
+ /**
+ * Gets the FontRenderContext of this GlyphVector.
+ *
+ * @return the FontRenderContext of this GlyphVector.
+ */
+ public abstract FontRenderContext getFontRenderContext();
+
+ /**
+ * Gets a Shape object which defines the visual representation
+ * of the specified glyph in this GlyphVector, translated a
+ * distance of x in the X direction and y in the Y direction.
+ *
+ * @param glyphIndex the glyth index in this GlyphVector.
+ * @param x the distance in the X direction to translate the
+ * shape object before returning it.
+ * @param y the distance in the Y direction to translate the
+ * shape object before returning it.
+ *
+ * @return a Shape object which represents the visual representation
+ * of the specified glyph in this GlyphVector - glyph outline.
+ */
+ public Shape getGlyphOutline(int glyphIndex, float x, float y) {
+ Shape initialShape = getGlyphOutline(glyphIndex);
+ AffineTransform trans = AffineTransform.getTranslateInstance(x, y);
+ return trans.createTransformedShape(initialShape);
+ }
+
+ /**
+ * Gets the visual bounds of the specified glyph in the GlyphVector.
+ *
+ * @param glyphIndex the glyph index in this GlyphVector.
+ *
+ * @return the glyph visual bounds of the glyph with the specified
+ * index in the GlyphVector.
+ */
+ public abstract Shape getGlyphVisualBounds(int glyphIndex);
+
+ /**
+ * Gets a Shape object which defines the visual representation
+ * of the specified glyph in this GlyphVector.
+ *
+ * @param glyphIndex the glyth index in this GlyphVector.
+ *
+ * @return a Shape object which represents the visual representation
+ * of the specified glyph in this GlyphVector - glyph outline.
+ */
+ public abstract Shape getGlyphOutline(int glyphIndex);
+
+ /**
+ * Gets the logical bounds of the specified glyph in
+ * the GlyphVector.
+ *
+ * @param glyphIndex the index in this GlyphVector of the glyph from which
+ * to retrieve its logical bounds
+ *
+ * @return the logical bounds of the specified glyph in
+ * the GlyphVector.
+ */
+ public abstract Shape getGlyphLogicalBounds(int glyphIndex);
+
+ /**
+ * Gets the visual representation of this GlyphVector rendered in
+ * x, y location as a Shape object.
+ *
+ * @param x the x coordinate of the GlyphVector.
+ * @param y the y coordinate of the GlyphVector.
+ *
+ * @return the visual representation of this GlyphVector as a Shape object.
+ */
+ public abstract Shape getOutline(float x, float y);
+
+ /**
+ * Gets the visual representation of this GlyphVector as a Shape object.
+ *
+ * @return the visual representation of this GlyphVector as a Shape object.
+ */
+ public abstract Shape getOutline();
+
+ /**
+ * Gets the font of this GlyphVector.
+ *
+ * @return the font of this GlyphVector.
+ */
+ public abstract Font getFont();
+
+ /**
+ * Gets an array of the glyph codes of the specified glyphs.
+ *
+ * @param beginGlyphIndex the index into this GlyphVector at which
+ * to start retrieving glyph codes.
+ * @param numEntries the number of glyph codes.
+ * @param codeReturn the array into which the resulting
+ * glyphcodes will be written.
+ *
+ * @return the array of the glyph codes.
+ */
+ public abstract int[] getGlyphCodes(int beginGlyphIndex, int numEntries,
+ int[] codeReturn);
+
+ /**
+ * Gets an array of the character indices of
+ * the specified glyphs.
+ *
+ * @param beginGlyphIndex the index of the first glyph to return information for.
+ * @param numEntries the number of glyph indices to return.
+ * @param codeReturn the array into which the resulting character
+ * indices will be written.
+ *
+ * @return an array of character indices for the specifies glyphs.
+ */
+ public int[] getGlyphCharIndices(int beginGlyphIndex, int numEntries,
+ int[] codeReturn) {
+ if (codeReturn == null) {
+ codeReturn = new int[numEntries];
+ }
+
+ for (int i = 0; i < numEntries; i++){
+ codeReturn[i] = getGlyphCharIndex(i+beginGlyphIndex);
+ }
+ return codeReturn;
+ }
+
+ /**
+ * Gets an array of the positions of the specified glyphs in
+ * this GlyphVector.
+ *
+ * @param beginGlyphIndex the index of the first glyph to return information for.
+ * @param numEntries the number of glyphs to return information for.
+ * @param positionReturn the array where the result will be stored.
+ *
+ * @return an array of glyph positions.
+ */
+ public abstract float[] getGlyphPositions(int beginGlyphIndex,
+ int numEntries, float[] positionReturn);
+
+ /**
+ * Gets the glyph code of the specified glyph.
+ *
+ * @param glyphIndex the index in this GlyphVector which corresponds
+ * to the glyph from which to retrieve the glyphcode.
+ *
+ * @return the glyphcode of the specified glyph.
+ */
+ public abstract int getGlyphCode(int glyphIndex);
+
+ /**
+ * Gets the first logical character's index of the specified glyph.
+ *
+ * @param glyphIndex the glyph index.
+ *
+ * @return the the first logical character's index.
+ */
+ public int getGlyphCharIndex(int glyphIndex){
+ // default implemetation one-to-one
+ return glyphIndex;
+ }
+
+ /**
+ * Sets default layout to this GlyphVector.
+ */
+ public abstract void performDefaultLayout();
+
+ /**
+ * Gets the number of glyphs in the GlyphVector.
+ *
+ * @return the number of glyphs in the GlyphVector.
+ */
+ public abstract int getNumGlyphs();
+
+ /**
+ * Gets flags which describe the global state of the GlyphVector.
+ * The default implementation returns 0.
+ *
+ * @return the layout flags
+ */
+ public int getLayoutFlags(){
+ // default implementation - returned value is 0
+ return 0;
+ }
+
+}
+
diff --git a/awt/java/awt/font/GraphicAttribute.java b/awt/java/awt/font/GraphicAttribute.java
new file mode 100644
index 0000000..2f41951
--- /dev/null
+++ b/awt/java/awt/font/GraphicAttribute.java
@@ -0,0 +1,196 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+import java.awt.Graphics2D;
+import java.awt.geom.Rectangle2D;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The GraphicAttribute abstract class provides an opportunity to
+ * insert graphical elements in printed text.
+ */
+public abstract class GraphicAttribute {
+
+ /**
+ * The Constant TOP_ALIGNMENT indicates using the top line to
+ * calculate placement of graphics.
+ */
+ public static final int TOP_ALIGNMENT = -1;
+
+ /**
+ * The Constant BOTTOM_ALIGNMENT indicates using the bottom line to
+ * calculate placement of graphics.
+ */
+ public static final int BOTTOM_ALIGNMENT = -2;
+
+ /**
+ * The Constant ROMAN_BASELINE indicates the placement of the roman
+ * baseline with respect to the graphics origin.
+ */
+ public static final int ROMAN_BASELINE = 0;
+
+ /**
+ * The Constant CENTER_BASELINE indicates the placement of the center
+ * baseline with respect to the graphics origin.
+ */
+ public static final int CENTER_BASELINE = 1;
+
+ /**
+ * The Constant HANGING_BASELINE indicates the placement of the hanging
+ * baseline with respect to the graphics origin.
+ */
+ public static final int HANGING_BASELINE = 2;
+
+ // the alignment of this GraphicAttribute
+ /** The alignment. */
+ private int alignment;
+
+ /**
+ * Instantiates a new graphic attribute with the specified alignment.
+ *
+ * @param align the specified alignment.
+ */
+ protected GraphicAttribute(int align) {
+ if ((align < BOTTOM_ALIGNMENT) || (align > HANGING_BASELINE)) {
+ // awt.198=Illegal alignment argument
+ throw new IllegalArgumentException(Messages.getString("awt.198")); //$NON-NLS-1$
+ }
+ this.alignment = align;
+ }
+
+ /**
+ * Draws the GraphicAttribute at the specified location.
+ *
+ * @param graphics the Graphics.
+ * @param x the X coordinate of GraphicAttribute location.
+ * @param y the Y coordinate of GraphicAttribute location.
+ */
+ public abstract void draw(Graphics2D graphics, float x, float y);
+
+ /**
+ * Gets the GraphicAttribute's advance. It's the distance from the point
+ * at which the graphic is rendered and the point where the next character
+ * or graphic is rendered.
+ *
+ * @return the GraphicAttribute's advance.
+ */
+ public abstract float getAdvance();
+
+ /**
+ * Gets the alignment of this GraphicAttribute.
+ *
+ * @return the alignment of this GraphicAttribute.
+ */
+ public final int getAlignment() {
+ return this.alignment;
+ }
+
+ /**
+ * Gets the ascent of this GraphicAttribute.
+ *
+ * @return the ascent of this GraphicAttribute.
+ */
+ public abstract float getAscent();
+
+ /**
+ * Gets the bounds of this GraphicAttribute.
+ *
+ * @return the bounds of this GraphicAttribute.
+ */
+ public Rectangle2D getBounds() {
+ float ascent = getAscent();
+ float advance = getAdvance();
+ float descent = getDescent();
+
+ // Default implementation - see API documentation.
+ return new Rectangle2D.Float(0, -ascent, advance, ascent + descent);
+ }
+
+ /**
+ * Gets the descent of this GraphicAttribute.
+ *
+ * @return the descent of this GraphicAttribute.
+ */
+ public abstract float getDescent();
+
+ /**
+ * Gets the GlyphJustificationInfo of this GraphicAttribute.
+ *
+ * @return the GlyphJustificationInfo of this GraphicAttribute.
+ */
+ public GlyphJustificationInfo getJustificationInfo() {
+
+ /* Default implementation.
+ * Since documentation doesn't describe default values,
+ * they were calculated based on 1.5 release
+ * behavior and can be obtained using next test sample:
+ *
+ * // Create GraphicAttribute class implementation
+ * public class MyGraphicAttribute extends GraphicAttribute {
+ * protected MyGraphicAttribute(int align) {
+ * super(align);
+ * }
+ *
+ * public float getDescent() {
+ * return 0;
+ * }
+ *
+ * public float getAdvance() {
+ * return 1;
+ * }
+ *
+ * public void draw(Graphics2D g2, float x, float y) {
+ * }
+ *
+ * public float getAscent() {
+ * return 0;
+ * }
+ * }
+ *
+ * MyGraphicAttribute myGA = gat.new MyGraphicAttribute(0);
+ * // print justification parameters
+ * System.out.println(myGA.getJustificationInfo().growAbsorb);
+ * System.out.println(myGA.getJustificationInfo().shrinkAbsorb);
+ * System.out.println(myGA.getJustificationInfo().growLeftLimit);
+ * System.out.println(myGA.getJustificationInfo().growPriority);
+ * System.out.println(myGA.getJustificationInfo().growRightLimit);
+ * System.out.println(myGA.getJustificationInfo().shrinkLeftLimit);
+ * System.out.println(myGA.getJustificationInfo().shrinkPriority);
+ * System.out.println(myGA.getJustificationInfo().shrinkRightLimit);
+ * System.out.println(myGA.getJustificationInfo().weight);
+ */
+ float advance = getAdvance();
+ return new GlyphJustificationInfo(
+ advance,
+ false,
+ GlyphJustificationInfo.PRIORITY_INTERCHAR,
+ advance / 3,
+ advance / 3,
+ false,
+ GlyphJustificationInfo.PRIORITY_WHITESPACE,
+ 0,
+ 0);
+ }
+
+}
+
diff --git a/awt/java/awt/font/ImageGraphicAttribute.java b/awt/java/awt/font/ImageGraphicAttribute.java
new file mode 100644
index 0000000..41f90b8
--- /dev/null
+++ b/awt/java/awt/font/ImageGraphicAttribute.java
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.geom.Rectangle2D;
+
+import org.apache.harmony.misc.HashCode;
+
+/**
+ * The ImageGraphicAttribute class provides an opportunity to insert
+ * images to a text.
+ */
+public final class ImageGraphicAttribute extends GraphicAttribute {
+
+ // Image object rendered by this ImageGraphicAttribute
+ /** The image. */
+ private Image fImage;
+
+ // X coordinate of the origin point
+ /** The origin x. */
+ private float fOriginX;
+
+ // Y coordinate of the origin point
+ /** The origin y. */
+ private float fOriginY;
+
+ // the width of the image object
+ /** The img width. */
+ private float fImgWidth;
+
+ // the height of the image object
+ /** The img height. */
+ private float fImgHeight;
+
+ /**
+ * Instantiates a new ImageGraphicAttribute with the specified image,
+ * alignment and origins.
+ *
+ * @param image the Image to be rendered by ImageGraphicAttribute.
+ * @param alignment the alignment of the ImageGraphicAttribute.
+ * @param originX the origin X coordinate in the image of
+ * ImageGraphicAttribute.
+ * @param originY the origin Y coordinate in the image of
+ * ImageGraphicAttribute.
+ */
+ public ImageGraphicAttribute(Image image, int alignment, float originX,
+ float originY) {
+ super(alignment);
+
+ this.fImage = image;
+ this.fOriginX = originX;
+ this.fOriginY = originY;
+
+ this.fImgWidth = fImage.getWidth(null);
+ this.fImgHeight = fImage.getHeight(null);
+
+ }
+
+ /**
+ * Instantiates a new ImageGraphicAttribute with the specified image and
+ * alignment.
+ *
+ * @param image the Image to be rendered by ImageGraphicAttribute.
+ * @param alignment the alignment of the ImageGraphicAttribute.
+ */
+ public ImageGraphicAttribute(Image image, int alignment) {
+ this(image, alignment, 0, 0);
+ }
+
+ /**
+ * Returns a hash code of this ImageGraphicAttribute object.
+ *
+ * @return the hash code of this ImageGraphicAttribute object.
+ */
+ @Override
+ public int hashCode() {
+ HashCode hash = new HashCode();
+
+ hash.append(fImage.hashCode());
+ hash.append(getAlignment());
+ return hash.hashCode();
+ }
+
+ /**
+ * Compares the specified ImageGraphicAttribute object with this
+ * ImageGraphicAttribute object.
+ *
+ * @param iga the ImageGraphicAttribute object to be compared.
+ *
+ * @return true, if the specified ImageGraphicAttribute object is equal to
+ * this ImageGraphicAttribute object, false otherwise.
+ */
+ public boolean equals(ImageGraphicAttribute iga) {
+ if (iga == null) {
+ return false;
+ }
+
+ if (iga == this) {
+ return true;
+ }
+
+ return (fOriginX == iga.fOriginX &&
+ fOriginY == iga.fOriginY &&
+ getAlignment() == iga.getAlignment() &&
+ fImage.equals(iga.fImage));
+ }
+
+ /**
+ * Compares the specified Object with this ImageGraphicAttribute object.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if the specified Object is equal to this
+ * ImageGraphicAttribute object, false otherwise.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ try {
+ return equals((ImageGraphicAttribute) obj);
+ }
+ catch(ClassCastException e) {
+ return false;
+ }
+
+ }
+
+ @Override
+ public void draw(Graphics2D g2, float x, float y) {
+ g2.drawImage(fImage, (int)(x - fOriginX), (int)(y - fOriginY), null);
+ }
+
+ /**
+ * @see java.awt.font.GraphicAttribute#getAdvance()
+ */
+ @Override
+ public float getAdvance() {
+ return Math.max(0, fImgWidth - fOriginX);
+ }
+
+ @Override
+ public float getAscent() {
+ return Math.max(0, fOriginY);
+ }
+
+ @Override
+ public Rectangle2D getBounds() {
+ return new Rectangle2D.Float(-fOriginX, -fOriginY, fImgWidth, fImgHeight);
+ }
+
+ /**
+ * @see java.awt.font.GraphicAttribute#getDescent()
+ */
+ @Override
+ public float getDescent() {
+ return Math.max(0, fImgHeight - fOriginY);
+ }
+
+}
+
diff --git a/awt/java/awt/font/LineBreakMeasurer.java b/awt/java/awt/font/LineBreakMeasurer.java
new file mode 100644
index 0000000..efce615
--- /dev/null
+++ b/awt/java/awt/font/LineBreakMeasurer.java
@@ -0,0 +1,231 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/*
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+
+package java.awt.font;
+
+import java.text.AttributedCharacterIterator;
+//???AWT: import java.text.BreakIterator;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The class LineBreakMeasurer provides methods to measure the graphical
+ * representation of a text in order to determine where to add line
+ * breaks so the resulting line of text fits its wrapping width.
+ * The wrapping width defines the visual width of the paragraph.
+ */
+public final class LineBreakMeasurer {
+
+ /** The tm. */
+ private TextMeasurer tm = null;
+ //???AWT private BreakIterator bi = null;
+ /** The position. */
+ private int position = 0;
+
+ /** The maxpos. */
+ int maxpos = 0;
+
+ /**
+ * Instantiates a new LineBreakMeasurer object for the specified text.
+ *
+ * @param text the AttributedCharacterIterator object which contains
+ * text with at least one character.
+ * @param frc the FontRenderContext represented information
+ * about graphic device.
+ */
+ public LineBreakMeasurer(AttributedCharacterIterator text, FontRenderContext frc) {
+ //???AWT: this(text, BreakIterator.getLineInstance(), frc);
+ }
+
+ /* ???AWT
+ public LineBreakMeasurer(
+ AttributedCharacterIterator text,
+ BreakIterator bi,
+ FontRenderContext frc
+ ) {
+ tm = new TextMeasurer(text, frc);
+ this.bi = bi;
+ this.bi.setText(text);
+ position = text.getBeginIndex();
+ maxpos = tm.aci.getEndIndex();
+ }
+ */
+
+ /**
+ * Deletes a character from the specified position of the text,
+ * updates this LineBreakMeasurer object.
+ *
+ * @param newText the new text.
+ * @param pos the posion of the character which is deleted.
+ */
+ public void deleteChar(AttributedCharacterIterator newText, int pos) {
+ tm.deleteChar(newText, pos);
+ //???AWT: bi.setText(newText);
+
+ position = newText.getBeginIndex();
+
+ maxpos--;
+ }
+
+ /**
+ * Gets current position of this LineBreakMeasurer.
+ *
+ * @return current position of this LineBreakMeasurer
+ */
+ public int getPosition() {
+ return position;
+ }
+
+ /**
+ * Insertes a character at the specified position in the text,
+ * updates this LineBreakMeasurer object.
+ *
+ * @param newText the new text.
+ * @param pos the posion of the character which is inserted.
+ */
+ public void insertChar(AttributedCharacterIterator newText, int pos) {
+ tm.insertChar(newText, pos);
+// ???AWT: bi.setText(newText);
+
+ position = newText.getBeginIndex();
+
+ maxpos++;
+ }
+
+ /**
+ * Returns the next line of text, updates current position in this
+ * LineBreakMeasurer.
+ *
+ * @param wrappingWidth the maximum visible line width.
+ * @param offsetLimit the limit point withing the text indicating
+ * that no further text should be included on the line; the paragraph break.
+ * @param requireNextWord if true, null is returned (the entire word at the current
+ * position does not fit within the wrapping width);
+ * if false, a valid layout is returned that includes at least the
+ * character at the current position.
+ *
+ * @return the next TextLayout which begins at the current position and
+ * represents the next line of text with width wrappingWidth, null is
+ * returned if the entire word at the current position does not fit within
+ * the wrapping width.
+ */
+ public TextLayout nextLayout(float wrappingWidth, int offsetLimit, boolean requireNextWord) {
+ if (position == maxpos) {
+ return null;
+ }
+
+ int nextPosition = nextOffset(wrappingWidth, offsetLimit, requireNextWord);
+
+ if (nextPosition == position) {
+ return null;
+ }
+ TextLayout layout = tm.getLayout(position, nextPosition);
+ position = nextPosition;
+ return layout;
+ }
+
+ /**
+ * Returns the next line of text.
+ *
+ * @param wrappingWidth the maximum visible line width.
+ *
+ * @return the next line of text.
+ */
+ public TextLayout nextLayout(float wrappingWidth) {
+ return nextLayout(wrappingWidth, maxpos, false);
+ }
+
+ /**
+ * Returns the end position of the next line of text.
+ *
+ * @param wrappingWidth the maximum visible line width.
+ *
+ * @return the end position of the next line of text.
+ */
+ public int nextOffset(float wrappingWidth) {
+ return nextOffset(wrappingWidth, maxpos, false);
+ }
+
+ /**
+ * Returns the end position of the next line of text.
+ *
+ * @param wrappingWidth the maximum visible line width.
+ * @param offsetLimit the limit point withing the text indicating
+ * that no further text should be included on the line; the paragraph break.
+ * @param requireNextWord if true, the current position is returned
+ * if the entire next word does not fit within wrappingWidth;
+ * if false, the offset returned is at least one greater than the current
+ * position.
+ *
+ * @return the end position of the next line of text.
+ *
+ * @throws IllegalArgumentException if the offsetLimit is less than
+ * the current position.
+ */
+ public int nextOffset(float wrappingWidth, int offsetLimit, boolean requireNextWord) {
+ if (offsetLimit <= position) {
+ // awt.203=Offset limit should be greater than current position.
+ throw new IllegalArgumentException(Messages.getString("awt.203")); //$NON-NLS-1$
+ }
+
+ if (position == maxpos) {
+ return position;
+ }
+
+ int breakPos = tm.getLineBreakIndex(position, wrappingWidth);
+ int correctedPos = breakPos;
+
+ // This check is required because bi.preceding(maxpos) throws an exception
+ /* ???AWT
+ if (breakPos == maxpos) {
+ correctedPos = maxpos;
+ } else if (Character.isWhitespace(bi.getText().setIndex(breakPos))) {
+ correctedPos = bi.following(breakPos);
+ } else {
+ correctedPos = bi.preceding(breakPos);
+ }
+ */
+
+ if (position >= correctedPos) {
+ if (requireNextWord) {
+ correctedPos = position;
+ } else {
+ correctedPos = Math.max(position+1, breakPos);
+ }
+ }
+
+ return Math.min(correctedPos, offsetLimit);
+ }
+
+ /**
+ * Sets the new position of this LineBreakMeasurer.
+ *
+ * @param pos the new position of this LineBreakMeasurer.
+ */
+ public void setPosition(int pos) {
+ if (tm.aci.getBeginIndex() > pos || maxpos < pos) {
+ // awt.33=index is out of range
+ throw new IllegalArgumentException(Messages.getString("awt.33")); //$NON-NLS-1$
+ }
+ position = pos;
+ }
+}
+
diff --git a/awt/java/awt/font/LineMetrics.java b/awt/java/awt/font/LineMetrics.java
new file mode 100644
index 0000000..2857187
--- /dev/null
+++ b/awt/java/awt/font/LineMetrics.java
@@ -0,0 +1,115 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+/**
+ * The LineMetrics class provides information such as concerning how the text
+ * is positioned with respect to the base line, such as ascent, descent,
+ * and leading.
+ *
+ */
+public abstract class LineMetrics {
+
+ /**
+ * Gets the baseline offsets of the text according to the
+ * the baseline of this text.
+ *
+ * @return the baseline offsets of the text according to the
+ * the baseline of this text.
+ */
+ public abstract float[] getBaselineOffsets();
+
+ /**
+ * Gets the number of characters of the text.
+ *
+ * @return the number of characters of the text.
+ */
+ public abstract int getNumChars();
+
+ /**
+ * Gets the baseline index, returns one of the following
+ * index: ROMAN_BASELINE, CENTER_BASELINE, HANGING_BASELINE.
+ *
+ * @return the baseline index: ROMAN_BASELINE, CENTER_BASELINE
+ * or HANGING_BASELINE.
+ */
+ public abstract int getBaselineIndex();
+
+ /**
+ * Gets the thickness of the underline.
+ *
+ * @return the thickness of the underline.
+ */
+ public abstract float getUnderlineThickness();
+
+ /**
+ * Gets the offset of the underline.
+ *
+ * @return the offset of the underline.
+ */
+ public abstract float getUnderlineOffset();
+
+ /**
+ * Gets the thickness of strike through line.
+ *
+ * @return the thickness of strike through line.
+ */
+ public abstract float getStrikethroughThickness();
+
+ /**
+ * Gets the offset of the strike through line.
+ *
+ * @return the offset of the strike through line.
+ */
+ public abstract float getStrikethroughOffset();
+
+ /**
+ * Gets the leading of the text.
+ *
+ * @return the leading of the text.
+ */
+ public abstract float getLeading();
+
+ /**
+ * Gets the height of the text as a sum of the ascent, the descent
+ * and the leading.
+ *
+ * @return the height of the text as a sum of the ascent, the descent
+ * and the leading.
+ */
+ public abstract float getHeight();
+
+ /**
+ * Gets the descent of the text.
+ *
+ * @return the descent of the text.
+ */
+ public abstract float getDescent();
+
+ /**
+ * Gets the ascent of the text.
+ *
+ * @return the ascent of the text.
+ */
+ public abstract float getAscent();
+
+}
+
diff --git a/awt/java/awt/font/MultipleMaster.java b/awt/java/awt/font/MultipleMaster.java
new file mode 100644
index 0000000..773bfcf
--- /dev/null
+++ b/awt/java/awt/font/MultipleMaster.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+import java.awt.Font;
+
+/**
+ * The MultipleMaster interface provides methods to manipulate MultipleMaster
+ * type fonts and retrieve graphical and design data from them.
+ */
+public interface MultipleMaster {
+
+ /**
+ * Derives a new multiple master font based on the specified
+ * parameters.
+ *
+ * @param glyphWidths float array which represents width of each glyph
+ * in font space.
+ * @param avgStemWidth the average stem width in font space.
+ * @param typicalCapHeight the typical upper case char height.
+ * @param typicalXHeight the typical lower case char height.
+ * @param italicAngle the slope angle for italics.
+ *
+ * @return a MultipleMaster font.
+ */
+ public Font deriveMMFont(float[] glyphWidths, float avgStemWidth,
+ float typicalCapHeight, float typicalXHeight, float italicAngle);
+
+ /**
+ * Derives a new multiple master font based on the design axis values
+ * contained in the specified array.
+ *
+ * @param axes an float array which contains axis values.
+ *
+ * @return a MultipleMaster font.
+ */
+ public Font deriveMMFont(float[] axes);
+
+ /**
+ * Gets default design values for the axes.
+ *
+ * @return the default design values for the axes.
+ */
+ public float[] getDesignAxisDefaults();
+
+ /**
+ * Gets the array of design axis names.
+ *
+ * @return the array of design axis names.
+ */
+ public String[] getDesignAxisNames();
+
+ /**
+ * Gets the array of design axis ranges.
+ *
+ * @return the array of design axis ranges.
+ */
+ public float[] getDesignAxisRanges();
+
+ /**
+ * Gets the number of multiple master design controls.
+ *
+ * @return the number of multiple master design controls.
+ */
+ public int getNumDesignAxes();
+
+}
+
diff --git a/awt/java/awt/font/OpenType.java b/awt/java/awt/font/OpenType.java
new file mode 100644
index 0000000..53cb6c0
--- /dev/null
+++ b/awt/java/awt/font/OpenType.java
@@ -0,0 +1,410 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+/**
+ * The OpenType interface provides constants and methods for getting
+ * instance data for fonts of type OpenType and TrueType. For more information,
+ * see the <a href="http://partners.adobe.com/public/developer/opentype/index_spec.html">OpenType specification</a>.
+ */
+public interface OpenType {
+
+ /**
+ * The Constant TAG_ACNT indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_ACNT = 1633906292;
+
+ /**
+ * The Constant TAG_AVAR indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_AVAR = 1635148146;
+
+ /**
+ * The Constant TAG_BASE indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_BASE = 1111577413;
+
+ /**
+ * The Constant TAG_BDAT indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_BDAT = 1650745716;
+
+ /**
+ * The Constant TAG_BLOC indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_BLOC = 1651273571;
+
+ /**
+ * The Constant TAG_BSLN indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_BSLN = 1651731566;
+
+ /**
+ * The Constant TAG_CFF indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_CFF = 1128678944;
+
+ /**
+ * The Constant TAG_CMAP indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_CMAP = 1668112752;
+
+ /**
+ * The Constant TAG_CVAR indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_CVAR = 1668702578;
+
+ /**
+ * The Constant TAG_CVT indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_CVT = 1668707360;
+
+ /**
+ * The Constant TAG_DSIG indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_DSIG = 1146308935;
+
+ /**
+ * The Constant TAG_EBDT indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_EBDT = 1161970772;
+
+ /**
+ * The Constant TAG_EBLC indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_EBLC = 1161972803;
+
+ /**
+ * The Constant TAG_EBSC indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_EBSC = 1161974595;
+
+ /**
+ * The Constant TAG_FDSC indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_FDSC = 1717859171;
+
+ /**
+ * The Constant TAG_FEAT indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_FEAT = 1717920116;
+
+ /**
+ * The Constant TAG_FMTX indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_FMTX = 1718449272;
+
+ /**
+ * The Constant TAG_FPGM indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_FPGM = 1718642541;
+
+ /**
+ * The Constant TAG_FVAR indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_FVAR = 1719034226;
+
+ /**
+ * The Constant TAG_GASP indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_GASP = 1734439792;
+
+ /**
+ * The Constant TAG_GDEF indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_GDEF = 1195656518;
+
+ /**
+ * The Constant TAG_GLYF indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_GLYF = 1735162214;
+
+ /**
+ * The Constant TAG_GPOS indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_GPOS = 1196445523;
+
+ /**
+ * The Constant TAG_GSUB indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_GSUB = 1196643650;
+
+ /**
+ * The Constant TAG_GVAR indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_GVAR = 1735811442;
+
+ /**
+ * The Constant TAG_HDMX indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_HDMX = 1751412088;
+
+ /**
+ * The Constant TAG_HEAD indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_HEAD = 1751474532;
+
+ /**
+ * The Constant TAG_HHEA indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_HHEA = 1751672161;
+
+ /**
+ * The Constant TAG_HMTX indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_HMTX = 1752003704;
+
+ /**
+ * The Constant TAG_JSTF indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_JSTF = 1246975046;
+
+ /**
+ * The Constant TAG_JUST indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_JUST = 1786082164;
+
+ /**
+ * The Constant TAG_KERN indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_KERN = 1801810542;
+
+ /**
+ * The Constant TAG_LCAR indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_LCAR = 1818452338;
+
+ /**
+ * The Constant TAG_LOCA indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_LOCA = 1819239265;
+
+ /**
+ * The Constant TAG_LTSH indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_LTSH = 1280594760;
+
+ /**
+ * The Constant TAG_MAXP indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_MAXP = 1835104368;
+
+ /**
+ * The Constant TAG_MMFX indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_MMFX = 1296909912;
+
+ /**
+ * The Constant TAG_MMSD indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_MMSD = 1296913220;
+
+ /**
+ * The Constant TAG_MORT indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_MORT = 1836020340;
+
+ /**
+ * The Constant TAG_NAME indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_NAME = 1851878757;
+
+ /**
+ * The Constant TAG_OPBD indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_OPBD = 1836020340;
+
+ /**
+ * The Constant TAG_OS2 indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_OS2 = 1330851634;
+
+ /**
+ * The Constant TAG_PCLT indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_PCLT = 1346587732;
+
+ /**
+ * The Constant TAG_POST indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_POST = 1886352244;
+
+ /**
+ * The Constant TAG_PREP indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_PREP = 1886545264;
+
+ /**
+ * The Constant TAG_PROP indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_PROP = 1886547824;
+
+ /**
+ * The Constant TAG_TRAK indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_TRAK = 1953653099;
+
+ /**
+ * The Constant TAG_TYP1 indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_TYP1 = 1954115633;
+
+ /**
+ * The Constant TAG_VDMX indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_VDMX = 1447316824;
+
+ /**
+ * The Constant TAG_VHEA indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_VHEA = 1986553185;
+
+ /**
+ * The Constant TAG_VMTX indicates corresponding table tag
+ * in the Open Type Specification.
+ */
+ public static final int TAG_VMTX = 1986884728;
+
+ /**
+ * Returns the OpenType font version.
+ *
+ * @return the the OpenType font version.
+ */
+ public int getVersion();
+
+ /**
+ * Gets the table for a specified tag.
+ * Sfnt tables include cmap, name and head items.
+ *
+ * @param sfntTag the sfnt tag.
+ *
+ * @return a byte array contains the font data corresponding
+ * to the specified tag.
+ */
+ public byte[] getFontTable(int sfntTag);
+
+ /**
+ * Gets the table for a specified tag.
+ * Sfnt tables include cmap, name and head items.
+ *
+ * @param sfntTag the sfnt tag.
+ * @param offset the offset of the returned table.
+ * @param count the number of returned table.
+ *
+ * @return the table corresponding to sfntTag and containing
+ * the bytes starting at offset byte and including count bytes.
+ */
+ public byte[] getFontTable(int sfntTag, int offset, int count);
+
+ /**
+ * Gets the table for a specified tag.
+ * Sfnt tables include cmap, name and head items.
+ *
+ * @param strSfntTag the str sfnt tag as a String.
+ *
+ * @return a byte array contains the font data corresponding
+ * to the specified tag.
+ */
+ public byte[] getFontTable(String strSfntTag);
+
+ /**
+ * Gets the table for a specified tag.
+ * Sfnt tables include cmap, name and head items.
+ *
+ * @param strSfntTag the sfnt tag as a String.
+ * @param offset the offset of the returned table.
+ * @param count the number of returned table.
+ *
+ * @return the table corresponding to sfntTag and containing
+ * the bytes starting at offset byte and including count bytes.
+ */
+ public byte[] getFontTable(String strSfntTag, int offset, int count);
+
+ /**
+ * Gets the table size for a specified tag.
+ *
+ * @param strSfntTag the sfnt tag as a String.
+ *
+ * @return the table size for a specified tag.
+ */
+ public int getFontTableSize(String strSfntTag);
+
+ /**
+ * Gets the table size for a specified tag.
+ *
+ * @param sfntTag the sfnt tag.
+ *
+ * @return the table size for a specified tag.
+ */
+ public int getFontTableSize(int sfntTag);
+
+}
+
diff --git a/awt/java/awt/font/ShapeGraphicAttribute.java b/awt/java/awt/font/ShapeGraphicAttribute.java
new file mode 100644
index 0000000..45199fd
--- /dev/null
+++ b/awt/java/awt/font/ShapeGraphicAttribute.java
@@ -0,0 +1,195 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+import java.awt.BasicStroke;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.Stroke;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+
+import org.apache.harmony.misc.HashCode;
+
+
+/**
+ * The ShapeGraphicAttribute class provides an opportunity to insert
+ * shapes to a text.
+ */
+public final class ShapeGraphicAttribute extends GraphicAttribute {
+
+ // shape to render
+ /** The shape. */
+ private Shape fShape;
+
+ // flag, if the shape should be stroked (true) or filled (false)
+ /** The stroke. */
+ private boolean fStroke;
+
+ // bounds of the shape
+ /** The bounds. */
+ private Rectangle2D fBounds;
+
+ // X coordinate of the origin point
+ /** The origin x. */
+ private float fOriginX;
+
+ // Y coordinate of the origin point
+ /** The origin y. */
+ private float fOriginY;
+
+ // width of the shape
+ /** The shape width. */
+ private float fShapeWidth;
+
+ // height of the shape
+ /** The shape height. */
+ private float fShapeHeight;
+
+ /**
+ * The Constant STROKE indicates whether the Shape is stroked
+ * or not.
+ */
+ public static final boolean STROKE = true;
+
+ /**
+ * The Constant FILL indicates whether the Shape is filled
+ * or not. */
+ public static final boolean FILL = false;
+
+ /**
+ * Instantiates a new ShapeGraphicAttribute object for the specified
+ * Shape.
+ *
+ * @param shape the shape to be rendered by this
+ * ShapeGraphicAttribute.
+ * @param alignment the alignment of this ShapeGraphicAttribute.
+ * @param stroke true if the Shape is stroked,
+ * false if the Shape is filled.
+ */
+ public ShapeGraphicAttribute(Shape shape, int alignment, boolean stroke) {
+ super(alignment);
+
+ this.fShape = shape;
+ this.fStroke = stroke;
+
+ this.fBounds = fShape.getBounds2D();
+
+ this.fOriginX = (float)fBounds.getMinX();
+ this.fOriginY = (float)fBounds.getMinY();
+
+ this.fShapeWidth = (float)fBounds.getWidth();
+ this.fShapeHeight = (float)fBounds.getHeight();
+ }
+
+ /**
+ * Returns a hash code of this ShapeGraphicAttribute object.
+ *
+ * @return a hash code of this ShapeGraphicAttribute object.
+ */
+ @Override
+ public int hashCode() {
+ HashCode hash = new HashCode();
+
+ hash.append(fShape.hashCode());
+ hash.append(getAlignment());
+ return hash.hashCode();
+ }
+
+ /**
+ * Compares this ShapeGraphicAttribute object to the specified
+ * ShapeGraphicAttribute object.
+ *
+ * @param sga the ShapeGraphicAttribute object to be compared.
+ *
+ * @return true, if this ShapeGraphicAttribute object is equal
+ * to the specified ShapeGraphicAttribute object, false otherwise.
+ */
+ public boolean equals(ShapeGraphicAttribute sga) {
+ if (sga == null) {
+ return false;
+ }
+
+ if (sga == this) {
+ return true;
+ }
+
+ return ( fStroke == sga.fStroke &&
+ getAlignment() == sga.getAlignment() &&
+ fShape.equals(sga.fShape));
+
+ }
+
+ /**
+ * Compares this ShapeGraphicAttribute object to the specified
+ * Object.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if this ShapeGraphicAttribute object is equal
+ * to the specified Object, false otherwise.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ try {
+ return equals((ShapeGraphicAttribute) obj);
+ }
+ catch(ClassCastException e) {
+ return false;
+ }
+ }
+
+ @Override
+ public void draw(Graphics2D g2, float x, float y) {
+ AffineTransform at = AffineTransform.getTranslateInstance(x, y);
+ if (fStroke == STROKE){
+ Stroke oldStroke = g2.getStroke();
+ g2.setStroke(new BasicStroke());
+ g2.draw(at.createTransformedShape(fShape));
+ g2.setStroke(oldStroke);
+ } else {
+ g2.fill(at.createTransformedShape(fShape));
+ }
+
+ }
+
+ @Override
+ public float getAdvance() {
+ return Math.max(0, fShapeWidth + fOriginX);
+ }
+
+ @Override
+ public float getAscent() {
+ return Math.max(0, -fOriginY);
+ }
+
+ @Override
+ public Rectangle2D getBounds() {
+ return (Rectangle2D)fBounds.clone();
+ }
+
+ @Override
+ public float getDescent() {
+ return Math.max(0, fShapeHeight + fOriginY);
+ }
+
+}
+
diff --git a/awt/java/awt/font/TextHitInfo.java b/awt/java/awt/font/TextHitInfo.java
new file mode 100644
index 0000000..17bbf71
--- /dev/null
+++ b/awt/java/awt/font/TextHitInfo.java
@@ -0,0 +1,216 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/*
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+
+package java.awt.font;
+
+import org.apache.harmony.misc.HashCode;
+
+
+/**
+ * The TextHitInfo class provides information about a caret position
+ * in a text model for insertion or deletion of a character in a text.
+ * The TextHitInfo defines two biases of the character: leading or trailing.
+ * Leading position means the left edge of the specified character
+ * (TextHitInfo.leading(2) method for "text" returns the left side of "x").
+ * Trailing position means the right edge of the specified character
+ * (TextHitInfo.trailing(2) method for "text" returns the right side of "x").
+ */
+public final class TextHitInfo {
+
+ /** The char idx. */
+ private int charIdx; // Represents character index in the line
+
+ /** The is trailing. */
+ private boolean isTrailing;
+
+ /**
+ * Instantiates a new text hit info.
+ *
+ * @param idx the idx
+ * @param isTrailing the is trailing
+ */
+ private TextHitInfo(int idx, boolean isTrailing) {
+ charIdx = idx;
+ this.isTrailing = isTrailing;
+ }
+
+ /**
+ * To string.
+ *
+ * @return the string
+ */
+ @Override
+ public String toString() {
+ return new String(
+ "TextHitInfo[" + charIdx + ", " + //$NON-NLS-1$ //$NON-NLS-2$
+ (isTrailing?"Trailing":"Leading") + "]" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ );
+ }
+
+ /**
+ * Compares this TextHitInfo object with the specified object.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if the specified object is a TextHitInfo object
+ * with the same data values as this TextHitInfo, false otherwise.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof TextHitInfo) {
+ return equals((TextHitInfo) obj);
+ }
+ return false;
+ }
+
+ /**
+ * Compares this TextHitInfo object with the specified TextHitInfo
+ * object.
+ *
+ * @param thi the TextHitInfo object to be compared.
+ *
+ * @return true, if this TextHitInfo object has the same data values as the
+ * specified TextHitInfo object, false otherwise.
+ */
+ public boolean equals(TextHitInfo thi) {
+ return
+ thi != null &&
+ thi.charIdx == charIdx &&
+ thi.isTrailing == isTrailing;
+ }
+
+ /**
+ * Gets a TextHitInfo object with its character index
+ * at the specified offset from the character index of
+ * this TextHitInfo.
+ *
+ * @param offset the offset.
+ *
+ * @return the TextHitInfo.
+ */
+ public TextHitInfo getOffsetHit(int offset) {
+ return new TextHitInfo(charIdx + offset, isTrailing);
+ }
+
+ /**
+ * Gets a TextHitInfo associated with the other side of
+ * the insertion point.
+ *
+ * @return the other hit.
+ */
+ public TextHitInfo getOtherHit() {
+ return isTrailing ?
+ new TextHitInfo(charIdx+1, false) :
+ new TextHitInfo(charIdx-1, true);
+ }
+
+ /**
+ * Returns true if the leading edge of the character is hit,
+ * false if the trailing edge of the character is hit.
+ *
+ * @return true if the leading edge of the character is hit,
+ * false if the trailing edge of the character is hit.
+ */
+ public boolean isLeadingEdge() {
+ return !isTrailing;
+ }
+
+ /**
+ * Hash code.
+ *
+ * @return the int
+ */
+ @Override
+ public int hashCode() {
+ return HashCode.combine(charIdx, isTrailing);
+ }
+
+ /**
+ * Gets the insertion index.
+ *
+ * @return the insertion index: character index if the leading edge
+ * is hit, or character index + 1 if the trailing edge is hit.
+ */
+ public int getInsertionIndex() {
+ return isTrailing ? charIdx+1 : charIdx;
+ }
+
+ /**
+ * Gets the index of the character hit.
+ *
+ * @return the character hit's index.
+ */
+ public int getCharIndex() {
+ return charIdx;
+ }
+
+ /**
+ * Returns a TextHitInfo associated with the trailing edge of
+ * the character at the specified char index.
+ *
+ * @param charIndex the char index.
+ *
+ * @return the TextHitInfo associated with the trailing edge of
+ * the character at the specified char index.
+ */
+ public static TextHitInfo trailing(int charIndex) {
+ return new TextHitInfo(charIndex, true);
+ }
+
+ /**
+ * Returns a TextHitInfo object associated with the leading edge
+ * of the character at the specified char index.
+ *
+ * @param charIndex the char index.
+ *
+ * @return the TextHitInfo object associated with the leading edge
+ * of the character at the specified char index.
+ */
+ public static TextHitInfo leading(int charIndex) {
+ return new TextHitInfo(charIndex, false);
+ }
+
+ /**
+ * Returns a (trailing) TextHitInfo object associated with the character
+ * before the specified offset.
+ *
+ * @param offset the offset.
+ *
+ * @return the TextHitInfo object associated with the character
+ * before the specified offset.
+ */
+ public static TextHitInfo beforeOffset(int offset) {
+ return new TextHitInfo(offset-1, true);
+ }
+
+ /**
+ * Returns a (leading) TextHitInfo object associated with the character
+ * after the specified offset.
+ *
+ * @param offset the offset.
+ *
+ * @return the TextHitInfo object associated with the character
+ * after the specified offset.
+ */
+ public static TextHitInfo afterOffset(int offset) {
+ return new TextHitInfo(offset, false);
+ }
+}
diff --git a/awt/java/awt/font/TextLayout.java b/awt/java/awt/font/TextLayout.java
new file mode 100644
index 0000000..e80afd0
--- /dev/null
+++ b/awt/java/awt/font/TextLayout.java
@@ -0,0 +1,916 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+
+package java.awt.font;
+
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.awt.geom.GeneralPath;
+import java.text.AttributedCharacterIterator;
+import java.text.AttributedString;
+import java.util.Map;
+
+import org.apache.harmony.awt.gl.font.BasicMetrics;
+import org.apache.harmony.awt.gl.font.CaretManager;
+import org.apache.harmony.awt.gl.font.TextMetricsCalculator;
+import org.apache.harmony.awt.gl.font.TextRunBreaker;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The TextLayout class defines the graphical representation of character data.
+ * This class provides method for obtaining information about cursor
+ * positioning and movement, split cursors for text with different directions,
+ * logical and visual highlighting, multiple baselines, hits, justification,
+ * ascent, descent, and advance, and rendering. A TextLayout object can be
+ * rendered using Graphics context.
+ */
+public final class TextLayout implements Cloneable {
+
+ /**
+ * The CaretPolicy class provides a policy for obtaining the
+ * caret location. The single getStrongCaret method specifies
+ * the policy.
+ */
+ public static class CaretPolicy {
+
+ /**
+ * Instantiates a new CaretPolicy.
+ */
+ public CaretPolicy() {
+ // Nothing to do
+ }
+
+ /**
+ * Returns whichever of the two specified TextHitInfo objects
+ * has the stronger caret (higher character level) in the
+ * specified TextLayout.
+ *
+ * @param hit1 the first TextHitInfo of the specified TextLayout.
+ * @param hit2 the second TextHitInfo of the specified TextLayout.
+ * @param layout the TextLayout.
+ *
+ * @return the TextHitInfo with the stronger caret.
+ */
+ public TextHitInfo getStrongCaret(TextHitInfo hit1, TextHitInfo hit2, TextLayout layout) {
+ // Stronger hit is the one with greater level.
+ // If the level is same, leading edge is stronger.
+
+ int level1 = layout.getCharacterLevel(hit1.getCharIndex());
+ int level2 = layout.getCharacterLevel(hit2.getCharIndex());
+
+ if (level1 == level2) {
+ return (hit2.isLeadingEdge() && (!hit1.isLeadingEdge())) ? hit2 : hit1;
+ }
+ return level1 > level2 ? hit1 : hit2;
+ }
+
+ }
+
+ /**
+ * The Constant DEFAULT_CARET_POLICY indicates the default caret policy.
+ */
+ public static final TextLayout.CaretPolicy DEFAULT_CARET_POLICY = new CaretPolicy();
+
+ /** The breaker. */
+ private TextRunBreaker breaker;
+
+ /** The metrics valid. */
+ private boolean metricsValid = false;
+
+ /** The tmc. */
+ private TextMetricsCalculator tmc;
+
+ /** The metrics. */
+ private BasicMetrics metrics;
+
+ /** The caret manager. */
+ private CaretManager caretManager;
+
+ /** The justification width. */
+ float justificationWidth = -1;
+
+ /**
+ * Instantiates a new TextLayout object from the specified string
+ * and Font.
+ *
+ * @param string the string to be displayed.
+ * @param font the font of the text.
+ * @param frc the FontRenderContext object for obtaining
+ * information about a graphics device.
+ */
+ public TextLayout(String string, Font font, FontRenderContext frc) {
+ if (string == null){
+ // awt.01='{0}' parameter is null
+ throw new IllegalArgumentException(Messages.getString("awt.01", "string")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ if (font == null){
+ // awt.01='{0}' parameter is null
+ throw new IllegalArgumentException(Messages.getString("awt.01", "font")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ if (string.length() == 0){
+ // awt.02='{0}' parameter has zero length
+ throw new IllegalArgumentException(Messages.getString("awt.02", "string")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ AttributedString as = new AttributedString(string);
+ as.addAttribute(TextAttribute.FONT, font);
+ this.breaker = new TextRunBreaker(as.getIterator(), frc);
+ caretManager = new CaretManager(breaker);
+ }
+
+ /**
+ * Instantiates a new TextLayout from the specified text and
+ * a map of attributes.
+ *
+ * @param string the string to be displayed.
+ * @param attributes the attributes to be used for obtaining the text
+ * style.
+ * @param frc the FontRenderContext object for obtaining
+ * information about a graphics device.
+ */
+ public TextLayout(
+ String string,
+ Map<? extends java.text.AttributedCharacterIterator.Attribute, ?> attributes,
+ FontRenderContext frc ) {
+ if (string == null){
+ // awt.01='{0}' parameter is null
+ throw new IllegalArgumentException(Messages.getString("awt.01", "string")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ if (attributes == null){
+ // awt.01='{0}' parameter is null
+ throw new IllegalArgumentException(Messages.getString("awt.01", "attributes")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ if (string.length() == 0){
+ // awt.02='{0}' parameter has zero length
+ throw new IllegalArgumentException(Messages.getString("awt.02", "string")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+
+ AttributedString as = new AttributedString(string);
+ as.addAttributes(attributes, 0, string.length());
+ this.breaker = new TextRunBreaker(as.getIterator(), frc);
+ caretManager = new CaretManager(breaker);
+ }
+
+ /**
+ * Instantiates a new TextLayout from the AttributedCharacterIterator.
+ *
+ * @param text the AttributedCharacterIterator.
+ * @param frc the FontRenderContext object for obtaining
+ * information about a graphics device.
+ */
+ public TextLayout(AttributedCharacterIterator text, FontRenderContext frc) {
+ if (text == null){
+ // awt.03='{0}' iterator parameter is null
+ throw new IllegalArgumentException(Messages.getString("awt.03", "text")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ if (text.getBeginIndex() == text.getEndIndex()){
+ // awt.04='{0}' iterator parameter has zero length
+ throw new IllegalArgumentException(Messages.getString("awt.04", "text")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ this.breaker = new TextRunBreaker(text, frc);
+ caretManager = new CaretManager(breaker);
+ }
+
+ /**
+ * Instantiates a new text layout.
+ *
+ * @param breaker the breaker
+ */
+ TextLayout(TextRunBreaker breaker) {
+ this.breaker = breaker;
+ caretManager = new CaretManager(this.breaker);
+ }
+
+ /**
+ * Returns a hash code of this TextLayout object.
+ *
+ * @return a hash code of this TextLayout object.
+ */
+ @Override
+ public int hashCode() {
+ return breaker.hashCode();
+ }
+
+ /**
+ * Returns a copy of this object.
+ *
+ * @return a copy of this object.
+ */
+ @Override
+ protected Object clone() {
+ TextLayout res = new TextLayout((TextRunBreaker) breaker.clone());
+
+ if (justificationWidth >= 0) {
+ res.handleJustify(justificationWidth);
+ }
+
+ return res;
+ }
+
+ /**
+ * Compares this TextLayout object to the specified TextLayout object.
+ *
+ * @param layout the TextLayout object to be compared.
+ *
+ * @return true, if this TextLayout object is equal to
+ * the specified TextLayout object, false otherwise.
+ */
+ public boolean equals(TextLayout layout) {
+ if (layout == null) {
+ return false;
+ }
+ return this.breaker.equals(layout.breaker);
+ }
+
+ /**
+ * Compares this TextLayout object to the specified Object.
+ *
+ * @param obj the Object to be compared.
+ *
+ * @return true, if this TextLayout object is equal to
+ * the specified Object, false otherwise.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ return obj instanceof TextLayout ? equals((TextLayout) obj) : false;
+ }
+
+ /**
+ * Gets the string representation for this TextLayout.
+ *
+ * @return the string representation for this TextLayout.
+ */
+ @Override
+ public String toString() { // what for?
+ return super.toString();
+ }
+
+ /**
+ * Draws this TextLayout at the specified location with the
+ * specified Graphics2D context.
+ *
+ * @param g2d the Graphics2D object which renders this TextLayout.
+ * @param x the X coordinate of the TextLayout origin.
+ * @param y the Y coordinate of the TextLayout origin.
+ */
+ public void draw(Graphics2D g2d, float x, float y) {
+ updateMetrics();
+ breaker.drawSegments(g2d, x ,y);
+ }
+
+ /**
+ * Update metrics.
+ */
+ private void updateMetrics() {
+ if (!metricsValid) {
+ breaker.createAllSegments();
+ tmc = new TextMetricsCalculator(breaker);
+ metrics = tmc.createMetrics();
+ metricsValid = true;
+ }
+ }
+
+ /**
+ * Gets the advance of this TextLayout object.
+ *
+ * @return the advance of this TextLayout object.
+ */
+ public float getAdvance() {
+ updateMetrics();
+ return metrics.getAdvance();
+ }
+
+ /**
+ * Gets the ascent of this TextLayout object.
+ *
+ * @return the ascent of this TextLayout object.
+ */
+ public float getAscent() {
+ updateMetrics();
+ return metrics.getAscent();
+ }
+
+ /**
+ * Gets the baseline of this TextLayout object.
+ *
+ * @return the baseline of this TextLayout object.
+ */
+ public byte getBaseline() {
+ updateMetrics();
+ return (byte) metrics.getBaseLineIndex();
+ }
+
+ /**
+ * Gets the float array of offsets for the baselines which
+ * are used in this TextLayout.
+ *
+ * @return the float array of offsets for the baselines which
+ * are used in this TextLayout.
+ */
+ public float[] getBaselineOffsets() {
+ updateMetrics();
+ return tmc.getBaselineOffsets();
+ }
+
+ /**
+ * Gets the black box bounds of the characters in the specified area.
+ * The black box bounds is an Shape which contains all
+ * bounding boxes of all the glyphs of the characters
+ * between firstEndpoint and secondEndpoint parameters values.
+ *
+ * @param firstEndpoint the first point of the area.
+ * @param secondEndpoint the second point of the area.
+ *
+ * @return the Shape which contains black box bounds.
+ */
+ public Shape getBlackBoxBounds(int firstEndpoint, int secondEndpoint) {
+ updateMetrics();
+ if (firstEndpoint < secondEndpoint) {
+ return breaker.getBlackBoxBounds(firstEndpoint, secondEndpoint);
+ }
+ return breaker.getBlackBoxBounds(secondEndpoint, firstEndpoint);
+ }
+
+ /**
+ * Gets the bounds of this TextLayout.
+ *
+ * @return the bounds of this TextLayout.
+ */
+ public Rectangle2D getBounds() {
+ updateMetrics();
+ return breaker.getVisualBounds();
+ }
+
+ /**
+ * Gets information about the caret of the specified TextHitInfo.
+ *
+ * @param hitInfo the TextHitInfo.
+ *
+ * @return the information about the caret of the specified TextHitInfo.
+ */
+ public float[] getCaretInfo(TextHitInfo hitInfo) {
+ updateMetrics();
+ return caretManager.getCaretInfo(hitInfo);
+ }
+
+ /**
+ * Gets information about the caret of the specified TextHitInfo
+ * of a character in this TextLayout.
+ *
+ * @param hitInfo the TextHitInfo of a character in this TextLayout.
+ * @param bounds the bounds to which the caret info is constructed.
+ *
+ * @return the caret of the specified TextHitInfo.
+ */
+ public float[] getCaretInfo(TextHitInfo hitInfo, Rectangle2D bounds) {
+ updateMetrics();
+ return caretManager.getCaretInfo(hitInfo);
+ }
+
+ /**
+ * Gets a Shape which represents the caret of the specified TextHitInfo
+ * in the bounds of this TextLayout.
+ *
+ * @param hitInfo the TextHitInfo.
+ * @param bounds the bounds to which the caret info is constructed.
+ *
+ * @return the Shape which represents the caret.
+ */
+ public Shape getCaretShape(TextHitInfo hitInfo, Rectangle2D bounds) {
+ updateMetrics();
+ return caretManager.getCaretShape(hitInfo, this);
+ }
+
+ /**
+ * Gets a Shape which represents the caret of the specified TextHitInfo
+ * in the bounds of this TextLayout.
+ *
+ * @param hitInfo the TextHitInfo.
+ *
+ * @return the Shape which represents the caret.
+ */
+ public Shape getCaretShape(TextHitInfo hitInfo) {
+ updateMetrics();
+ return caretManager.getCaretShape(hitInfo, this);
+ }
+
+ /**
+ * Gets two Shapes for the strong and weak carets with
+ * default caret policy and null bounds: the first element
+ * is the strong caret, the second is the weak caret or null.
+ *
+ * @param offset an offset in the TextLayout.
+ *
+ * @return an array of two Shapes corresponded to the strong
+ * and weak carets.
+ */
+ public Shape[] getCaretShapes(int offset) {
+ return getCaretShapes(offset, null, TextLayout.DEFAULT_CARET_POLICY);
+ }
+
+ /**
+ * Gets two Shapes for the strong and weak carets with
+ * the default caret policy: the first element is the strong
+ * caret, the second is the weak caret or null.
+ *
+ * @param offset an offset in the TextLayout.
+ * @param bounds the bounds to which to extend the carets.
+ *
+ * @return an array of two Shapes corresponded to the strong
+ * and weak carets.
+ */
+ public Shape[] getCaretShapes(int offset, Rectangle2D bounds) {
+ return getCaretShapes(offset, bounds, TextLayout.DEFAULT_CARET_POLICY);
+ }
+
+ /**
+ * Gets two Shapes for the strong and weak carets: the first
+ * element is the strong caret, the second is the weak caret
+ * or null.
+ *
+ * @param offset an offset in the TextLayout.
+ * @param bounds the bounds to which to extend the carets.
+ * @param policy the specified CaretPolicy.
+ *
+ * @return an array of two Shapes corresponded to the strong
+ * and weak carets.
+ */
+ public Shape[] getCaretShapes(int offset, Rectangle2D bounds, TextLayout.CaretPolicy policy) {
+ if (offset < 0 || offset > breaker.getCharCount()) {
+ // awt.195=Offset is out of bounds
+ throw new IllegalArgumentException(Messages.getString("awt.195")); //$NON-NLS-1$
+ }
+
+ updateMetrics();
+ return caretManager.getCaretShapes(offset, bounds, policy, this);
+ }
+
+ /**
+ * Gets the number of characters in this TextLayout.
+ *
+ * @return the number of characters in this TextLayout.
+ */
+ public int getCharacterCount() {
+ return breaker.getCharCount();
+ }
+
+ /**
+ * Gets the level of the character with the specified index.
+ *
+ * @param index the specified index of the character.
+ *
+ * @return the level of the character.
+ */
+ public byte getCharacterLevel(int index) {
+ if (index == -1 || index == getCharacterCount()) {
+ return (byte) breaker.getBaseLevel();
+ }
+ return breaker.getLevel(index);
+ }
+
+ /**
+ * Gets the descent of this TextLayout.
+ *
+ * @return the descent of this TextLayout.
+ */
+ public float getDescent() {
+ updateMetrics();
+ return metrics.getDescent();
+ }
+
+ /**
+ * Gets the TextLayout wich is justified with the specified
+ * width related to this TextLayout.
+ *
+ * @param justificationWidth the width which is used
+ * for justification.
+ *
+ * @return a TextLayout justified to the specified width.
+ *
+ * @throws Error the error occures if this TextLayout has been
+ * already justified.
+ */
+ public TextLayout getJustifiedLayout(float justificationWidth) throws Error {
+ float justification = breaker.getJustification();
+
+ if (justification < 0) {
+ // awt.196=Justification impossible, layout already justified
+ throw new Error(Messages.getString("awt.196")); //$NON-NLS-1$
+ } else if (justification == 0) {
+ return this;
+ }
+
+ TextLayout justifiedLayout = new TextLayout((TextRunBreaker) breaker.clone());
+ justifiedLayout.handleJustify(justificationWidth);
+ return justifiedLayout;
+ }
+
+ /**
+ * Gets the leading of this TextLayout.
+ *
+ * @return the leading of this TextLayout.
+ */
+ public float getLeading() {
+ updateMetrics();
+ return metrics.getLeading();
+ }
+
+ /**
+ * Gets a Shape representing the logical selection betweeen
+ * the specified endpoints and extended to the natural
+ * bounds of this TextLayout.
+ *
+ * @param firstEndpoint the first selected endpoint within the area of characters
+ * @param secondEndpoint the second selected endpoint within the area of characters
+ *
+ * @return a Shape represented the logical selection betweeen
+ * the specified endpoints.
+ */
+ public Shape getLogicalHighlightShape(int firstEndpoint, int secondEndpoint) {
+ updateMetrics();
+ return getLogicalHighlightShape(firstEndpoint, secondEndpoint, breaker.getLogicalBounds());
+ }
+
+ /**
+ * Gets a Shape representing the logical selection betweeen
+ * the specified endpoints and extended to the specified
+ * bounds of this TextLayout.
+ *
+ * @param firstEndpoint the first selected endpoint within the area of characters
+ * @param secondEndpoint the second selected endpoint within the area of characters
+ * @param bounds the specified bounds of this TextLayout.
+ *
+ * @return a Shape represented the logical selection betweeen
+ * the specified endpoints.
+ */
+ public Shape getLogicalHighlightShape(
+ int firstEndpoint,
+ int secondEndpoint,
+ Rectangle2D bounds
+ ) {
+ updateMetrics();
+
+ if (firstEndpoint > secondEndpoint) {
+ if (secondEndpoint < 0 || firstEndpoint > breaker.getCharCount()) {
+ // awt.197=Endpoints are out of range
+ throw new IllegalArgumentException(Messages.getString("awt.197")); //$NON-NLS-1$
+ }
+ return caretManager.getLogicalHighlightShape(
+ secondEndpoint,
+ firstEndpoint,
+ bounds,
+ this
+ );
+ }
+ if (firstEndpoint < 0 || secondEndpoint > breaker.getCharCount()) {
+ // awt.197=Endpoints are out of range
+ throw new IllegalArgumentException(Messages.getString("awt.197")); //$NON-NLS-1$
+ }
+ return caretManager.getLogicalHighlightShape(
+ firstEndpoint,
+ secondEndpoint,
+ bounds,
+ this
+ );
+ }
+
+ /**
+ * Gets the logical ranges of text which corresponds to a visual
+ * selection.
+ *
+ * @param hit1 the first endpoint of the visual range.
+ * @param hit2 the second endpoint of the visual range.
+ *
+ * @return the logical ranges of text which corresponds to a visual
+ * selection.
+ */
+ public int[] getLogicalRangesForVisualSelection(TextHitInfo hit1, TextHitInfo hit2) {
+ return caretManager.getLogicalRangesForVisualSelection(hit1, hit2);
+ }
+
+ /**
+ * Gets the TextHitInfo for the next caret to the left (or
+ * up at the end of the line) of the specified offset.
+ *
+ * @param offset the offset in this TextLayout.
+ *
+ * @return the TextHitInfo for the next caret to the left (or
+ * up at the end of the line) of the specified hit, or null
+ * if there is no hit.
+ */
+ public TextHitInfo getNextLeftHit(int offset) {
+ return getNextLeftHit(offset, DEFAULT_CARET_POLICY);
+ }
+
+ /**
+ * Gets the TextHitInfo for the next caret to the left (or
+ * up at the end of the line) of the specified hit.
+ *
+ * @param hitInfo the initial hit.
+ *
+ * @return the TextHitInfo for the next caret to the left (or
+ * up at the end of the line) of the specified hit, or null
+ * if there is no hit.
+ */
+ public TextHitInfo getNextLeftHit(TextHitInfo hitInfo) {
+ breaker.createAllSegments();
+ return caretManager.getNextLeftHit(hitInfo);
+ }
+
+ /**
+ * Gets the TextHitInfo for the next caret to the left (or
+ * up at the end of the line) of the specified offset, given the
+ * specified caret policy.
+ *
+ * @param offset the offset in this TextLayout.
+ * @param policy the policy to be used for obtaining the strong caret.
+ *
+ * @return the TextHitInfo for the next caret to the left of the
+ * specified offset, or null if there is no hit.
+ */
+ public TextHitInfo getNextLeftHit(int offset, TextLayout.CaretPolicy policy) {
+ if (offset < 0 || offset > breaker.getCharCount()) {
+ // awt.195=Offset is out of bounds
+ throw new IllegalArgumentException(Messages.getString("awt.195")); //$NON-NLS-1$
+ }
+
+ TextHitInfo hit = TextHitInfo.afterOffset(offset);
+ TextHitInfo strongHit = policy.getStrongCaret(hit, hit.getOtherHit(), this);
+ TextHitInfo nextLeftHit = getNextLeftHit(strongHit);
+
+ if (nextLeftHit != null) {
+ return policy.getStrongCaret(getVisualOtherHit(nextLeftHit), nextLeftHit, this);
+ }
+ return null;
+ }
+
+ /**
+ * Gets the TextHitInfo for the next caret to the right (or
+ * down at the end of the line) of the specified hit.
+ *
+ * @param hitInfo the initial hit.
+ *
+ * @return the TextHitInfo for the next caret to the right (or
+ * down at the end of the line) of the specified hit, or null
+ * if there is no hit.
+ */
+ public TextHitInfo getNextRightHit(TextHitInfo hitInfo) {
+ breaker.createAllSegments();
+ return caretManager.getNextRightHit(hitInfo);
+ }
+
+ /**
+ * Gets the TextHitInfo for the next caret to the right (or
+ * down at the end of the line) of the specified offset.
+ *
+ * @param offset the offset in this TextLayout.
+ *
+ * @return the TextHitInfo for the next caret to the right of the
+ * specified offset, or null if there is no hit.
+ */
+ public TextHitInfo getNextRightHit(int offset) {
+ return getNextRightHit(offset, DEFAULT_CARET_POLICY);
+ }
+
+ /**
+ * Gets the TextHitInfo for the next caret to the right (or
+ * down at the end of the line) of the specified offset, given the
+ * specified caret policy.
+ *
+ * @param offset the offset in this TextLayout.
+ * @param policy the policy to be used for obtaining the strong caret.
+ *
+ * @return the TextHitInfo for the next caret to the right of the
+ * specified offset, or null if there is no hit.
+ */
+ public TextHitInfo getNextRightHit(int offset, TextLayout.CaretPolicy policy) {
+ if (offset < 0 || offset > breaker.getCharCount()) {
+ // awt.195=Offset is out of bounds
+ throw new IllegalArgumentException(Messages.getString("awt.195")); //$NON-NLS-1$
+ }
+
+ TextHitInfo hit = TextHitInfo.afterOffset(offset);
+ TextHitInfo strongHit = policy.getStrongCaret(hit, hit.getOtherHit(), this);
+ TextHitInfo nextRightHit = getNextRightHit(strongHit);
+
+ if (nextRightHit != null) {
+ return policy.getStrongCaret(getVisualOtherHit(nextRightHit), nextRightHit, this);
+ }
+ return null;
+ }
+
+ /**
+ * Gets the outline of this TextLayout as a Shape.
+ *
+ * @param xform the AffineTransform to be used to transform
+ * the outline before returning it, or null if no transformation
+ * is desired.
+ *
+ * @return the outline of this TextLayout as a Shape.
+ */
+ public Shape getOutline(AffineTransform xform) {
+ breaker.createAllSegments();
+
+ GeneralPath outline = breaker.getOutline();
+
+ if (outline != null && xform != null) {
+ outline.transform(xform);
+ }
+
+ return outline;
+ }
+
+ /**
+ * Gets the visible advance of this TextLayout which is defined as
+ * diffence between leading (advance) and trailing whitespace.
+ *
+ * @return the visible advance of this TextLayout.
+ */
+ public float getVisibleAdvance() {
+ updateMetrics();
+
+ // Trailing whitespace _SHOULD_ be reordered (Unicode spec) to
+ // base direction, so it is also trailing
+ // in logical representation. We use this fact.
+ int lastNonWhitespace = breaker.getLastNonWhitespace();
+
+ if (lastNonWhitespace < 0) {
+ return 0;
+ } else if (lastNonWhitespace == getCharacterCount()-1) {
+ return getAdvance();
+ } else if (justificationWidth >= 0) { // Layout is justified
+ return justificationWidth;
+ } else {
+ breaker.pushSegments(
+ breaker.getACI().getBeginIndex(),
+ lastNonWhitespace + breaker.getACI().getBeginIndex() + 1
+ );
+
+ breaker.createAllSegments();
+
+ float visAdvance = tmc.createMetrics().getAdvance();
+
+ breaker.popSegments();
+ return visAdvance;
+ }
+ }
+
+ /**
+ * Gets a Shape which corresponds to the highlighted (selected) area
+ * based on two hit locations within the text and extends to the bounds.
+ *
+ * @param hit1 the first text hit location.
+ * @param hit2 the second text hit location.
+ * @param bounds the rectangle that the highlighted area should be
+ * extended or restricted to.
+ *
+ * @return a Shape which corresponds to the highlighted (selected) area.
+ */
+ public Shape getVisualHighlightShape(TextHitInfo hit1, TextHitInfo hit2, Rectangle2D bounds) {
+ return caretManager.getVisualHighlightShape(hit1, hit2, bounds, this);
+ }
+
+ /**
+ * Gets a Shape which corresponds to the highlighted (selected) area
+ * based on two hit locations within the text.
+ *
+ * @param hit1 the first text hit location.
+ * @param hit2 the second text hit location.
+ *
+ * @return a Shape which corresponds to the highlighted (selected) area.
+ */
+ public Shape getVisualHighlightShape(TextHitInfo hit1, TextHitInfo hit2) {
+ breaker.createAllSegments();
+ return caretManager.getVisualHighlightShape(hit1, hit2, breaker.getLogicalBounds(), this);
+ }
+
+ /**
+ * Gets the TextHitInfo for a hit on the opposite side of the
+ * specified hit's caret.
+ *
+ * @param hitInfo the specified TextHitInfo.
+ *
+ * @return the TextHitInfo for a hit on the opposite side of the
+ * specified hit's caret.
+ */
+ public TextHitInfo getVisualOtherHit(TextHitInfo hitInfo) {
+ return caretManager.getVisualOtherHit(hitInfo);
+ }
+
+ /**
+ * Justifies the text; this method should be overridden
+ * by subclasses.
+ *
+ * @param justificationWidth the width for justification.
+ */
+ protected void handleJustify(float justificationWidth) {
+ float justification = breaker.getJustification();
+
+ if (justification < 0) {
+ // awt.196=Justification impossible, layout already justified
+ throw new IllegalStateException(Messages.getString("awt.196")); //$NON-NLS-1$
+ } else if (justification == 0) {
+ return;
+ }
+
+ float gap = (justificationWidth - getVisibleAdvance()) * justification;
+ breaker.justify(gap);
+ this.justificationWidth = justificationWidth;
+
+ // Correct metrics
+ tmc = new TextMetricsCalculator(breaker);
+ tmc.correctAdvance(metrics);
+ }
+
+ /**
+ * Returns a TextHitInfo object that gives information on which
+ * division point (between two characters) is corresponds to a
+ * hit (such as a mouse click) at the specified coordinates.
+ *
+ * @param x the X coordinate in this TextLayout.
+ * @param y the Y coordinate in this TextLayout.
+ *
+ * TextHitInfo object cooresponding to the given coordinates
+ * within the text.
+ */
+ public TextHitInfo hitTestChar(float x, float y) {
+ return hitTestChar(x, y, getBounds());
+ }
+
+ /**
+ * Returns a TextHitInfo object that gives information on which
+ * division point (between two characters) is corresponds to a
+ * hit (such as a mouse click) at the specified coordinates within
+ * the specified text rectangle.
+ *
+ * @param x the X coordinate in this TextLayout.
+ * @param y the Y coordinate in this TextLayout.
+ * @param bounds the bounds of the text area.
+ *
+ * TextHitInfo object cooresponding to the given coordinates
+ * within the text.
+ */
+ public TextHitInfo hitTestChar(float x, float y, Rectangle2D bounds) {
+ if (x > bounds.getMaxX()) {
+ return breaker.isLTR() ?
+ TextHitInfo.trailing(breaker.getCharCount() - 1) : TextHitInfo.leading(0);
+ }
+
+ if (x < bounds.getMinX()) {
+ return breaker.isLTR() ?
+ TextHitInfo.leading(0) : TextHitInfo.trailing(breaker.getCharCount() - 1);
+ }
+
+ return breaker.hitTest(x, y);
+ }
+
+ /**
+ * Returns true if this TextLayout has a "left to right"
+ * direction.
+ *
+ * @return true if this TextLayout has a "left to right"
+ * direction, false if this TextLayout has a "right to left"
+ * direction.
+ */
+ public boolean isLeftToRight() {
+ return breaker.isLTR();
+ }
+
+ /**
+ * Returns true if this TextLayout is vertical, false otherwise.
+ *
+ * @return true if this TextLayout is vertical, false if horizontal.
+ */
+ public boolean isVertical() {
+ return false;
+ }
+}
+
diff --git a/awt/java/awt/font/TextMeasurer.java b/awt/java/awt/font/TextMeasurer.java
new file mode 100644
index 0000000..017f3d9
--- /dev/null
+++ b/awt/java/awt/font/TextMeasurer.java
@@ -0,0 +1,167 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/*
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+
+package java.awt.font;
+
+
+import java.text.AttributedCharacterIterator;
+
+import org.apache.harmony.awt.gl.font.TextMetricsCalculator;
+import org.apache.harmony.awt.gl.font.TextRunBreaker;
+
+/**
+ * The TextMeasurer class provides utilities for line break operations.
+ */
+public final class TextMeasurer implements Cloneable {
+
+ /** The aci. */
+ AttributedCharacterIterator aci;
+
+ /** The frc. */
+ FontRenderContext frc;
+
+ /** The breaker. */
+ TextRunBreaker breaker = null;
+
+ /** The tmc. */
+ TextMetricsCalculator tmc = null;
+
+ /**
+ * Instantiates a new text measurer from the specified text.
+ *
+ * @param text the source text.
+ * @param frc the FontRenderContext.
+ */
+ public TextMeasurer(AttributedCharacterIterator text, FontRenderContext frc) {
+ this.aci = text;
+ this.frc = frc;
+ breaker = new TextRunBreaker(aci, this.frc);
+ tmc = new TextMetricsCalculator(breaker);
+ }
+
+ /**
+ * Replaces the current text with the new text, inserting a break
+ * character at the specified insert position.
+ *
+ * @param newParagraph the new paragraph text.
+ * @param insertPos the position in the text where the character is inserted.
+ */
+ public void insertChar(AttributedCharacterIterator newParagraph, int insertPos) {
+ AttributedCharacterIterator oldAci = aci;
+ aci = newParagraph;
+ if ((oldAci.getEndIndex() - oldAci.getBeginIndex()) -
+ (aci.getEndIndex() - aci.getBeginIndex()) != -1) {
+ breaker = new TextRunBreaker(aci, this.frc);
+ tmc = new TextMetricsCalculator(breaker);
+ } else {
+ breaker.insertChar(newParagraph, insertPos);
+ }
+ }
+
+ /**
+ * Replaces the current text with the new text and deletes a
+ * character at the specified position.
+ *
+ * @param newParagraph the paragraph text after deletion.
+ * @param deletePos the position in the text where the character is removed.
+ */
+ public void deleteChar(AttributedCharacterIterator newParagraph, int deletePos) {
+ AttributedCharacterIterator oldAci = aci;
+ aci = newParagraph;
+ if ((oldAci.getEndIndex() - oldAci.getBeginIndex()) -
+ (aci.getEndIndex() - aci.getBeginIndex()) != 1) {
+ breaker = new TextRunBreaker(aci, this.frc);
+ tmc = new TextMetricsCalculator(breaker);
+ } else {
+ breaker.deleteChar(newParagraph, deletePos);
+ }
+ }
+
+ /**
+ * Returns a copy of this object.
+ *
+ * @return a copy of this object.
+ */
+ @Override
+ protected Object clone() {
+ return new TextMeasurer((AttributedCharacterIterator) aci.clone(), frc);
+ }
+
+ /**
+ * Returns a TextLayout of the specified character range.
+ *
+ * @param start the index of the first character.
+ * @param limit the index after the last character.
+ *
+ * @return a TextLayout for the characters beginning at "start" up
+ * to "end".
+ */
+ public TextLayout getLayout(int start, int limit) {
+ breaker.pushSegments(start - aci.getBeginIndex(), limit - aci.getBeginIndex());
+
+ breaker.createAllSegments();
+ TextLayout layout = new TextLayout((TextRunBreaker) breaker.clone());
+
+ breaker.popSegments();
+ return layout;
+ }
+
+ /**
+ * Returns the graphical width of a line beginning at "start"
+ * parameter and including characters up to "end" parameter.
+ * "start" and "end" are absolute indices, not relative to the
+ * "start" of the paragraph.
+ *
+ * @param start the character index at which to start measuring.
+ * @param end the character index at which to stop measuring.
+ *
+ * @return the graphical width of a line beginning at "start"
+ * and including characters up to "end".
+ */
+ public float getAdvanceBetween(int start, int end) {
+ breaker.pushSegments(start - aci.getBeginIndex(), end - aci.getBeginIndex());
+
+ breaker.createAllSegments();
+ float retval = tmc.createMetrics().getAdvance();
+
+ breaker.popSegments();
+ return retval;
+ }
+
+ /**
+ * Returns the index of the first character which is not fit on
+ * a line beginning at start and possible measuring up to maxAdvance
+ * in graphical width.
+ *
+ * @param start he character index at which to start measuring.
+ * @param maxAdvance the graphical width in which the line must fit.
+ *
+ * @return the index after the last character that is fit on a line
+ * beginning at start, which is not longer than maxAdvance in graphical
+ * width.
+ */
+ public int getLineBreakIndex(int start, float maxAdvance) {
+ breaker.createAllSegments();
+ return breaker.getLineBreakIndex(
+ start - aci.getBeginIndex(), maxAdvance) + aci.getBeginIndex();
+ }
+}
+
diff --git a/awt/java/awt/font/TransformAttribute.java b/awt/java/awt/font/TransformAttribute.java
new file mode 100644
index 0000000..7c9b0bd
--- /dev/null
+++ b/awt/java/awt/font/TransformAttribute.java
@@ -0,0 +1,80 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Ilya S. Okomin
+ * @version $Revision$
+ */
+package java.awt.font;
+
+import java.awt.geom.AffineTransform;
+import java.io.Serializable;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The TransformAttribute class is a wrapper for the AffineTransform class in
+ * order to use it as attribute.
+ */
+public final class TransformAttribute implements Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 3356247357827709530L;
+
+ // affine transform of this TransformAttribute instance
+ /** The transform. */
+ private AffineTransform fTransform;
+
+ /**
+ * Instantiates a new TransformAttribute from the specified
+ * AffineTransform.
+ *
+ * @param transform the AffineTransform to be wrapped.
+ */
+ public TransformAttribute(AffineTransform transform) {
+ if (transform == null) {
+ // awt.94=transform can not be null
+ throw new IllegalArgumentException(Messages.getString("awt.94")); //$NON-NLS-1$
+ }
+ if (!transform.isIdentity()){
+ this.fTransform = new AffineTransform(transform);
+ }
+ }
+
+ /**
+ * Gets the initial AffineTransform which is wrapped.
+ *
+ * @return the initial AffineTransform which is wrapped.
+ */
+ public AffineTransform getTransform() {
+ if (fTransform != null){
+ return new AffineTransform(fTransform);
+ }
+ return new AffineTransform();
+ }
+
+ /**
+ * Checks if this transform is an identity transform.
+ *
+ * @return true, if this transform is an identity transform,
+ * false otherwise.
+ */
+ public boolean isIdentity() {
+ return (fTransform == null);
+ }
+
+}
+
diff --git a/awt/java/awt/geom/AffineTransform.java b/awt/java/awt/geom/AffineTransform.java
new file mode 100644
index 0000000..5fd3934
--- /dev/null
+++ b/awt/java/awt/geom/AffineTransform.java
@@ -0,0 +1,1158 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.awt.Shape;
+import java.io.IOException;
+import java.io.Serializable;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+import org.apache.harmony.misc.HashCode;
+
+/**
+ * The Class AffineTransform represents a linear transformation
+ * (rotation, scaling, or shear) followed by a translation that
+ * acts on a coordinate space. It preserves colinearity of points
+ * and ratios of distances between collinear points: so if A, B,
+ * and C are on a line, then after the space has been transformed
+ * via the affine transform, the images of the three points will
+ * still be on a line, and the ratio of the distance from A to B
+ * with the distance from B to C will be the same as the corresponding
+ * ratio in the image space.
+ */
+public class AffineTransform implements Cloneable, Serializable {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 1330973210523860834L;
+
+ /** The Constant TYPE_IDENTITY. */
+ public static final int TYPE_IDENTITY = 0;
+
+ /** The Constant TYPE_TRANSLATION. */
+ public static final int TYPE_TRANSLATION = 1;
+
+ /** The Constant TYPE_UNIFORM_SCALE. */
+ public static final int TYPE_UNIFORM_SCALE = 2;
+
+ /** The Constant TYPE_GENERAL_SCALE. */
+ public static final int TYPE_GENERAL_SCALE = 4;
+
+ /** The Constant TYPE_QUADRANT_ROTATION. */
+ public static final int TYPE_QUADRANT_ROTATION = 8;
+
+ /** The Constant TYPE_GENERAL_ROTATION. */
+ public static final int TYPE_GENERAL_ROTATION = 16;
+
+ /** The Constant TYPE_GENERAL_TRANSFORM. */
+ public static final int TYPE_GENERAL_TRANSFORM = 32;
+
+ /** The Constant TYPE_FLIP. */
+ public static final int TYPE_FLIP = 64;
+
+ /** The Constant TYPE_MASK_SCALE. */
+ public static final int TYPE_MASK_SCALE = TYPE_UNIFORM_SCALE | TYPE_GENERAL_SCALE;
+
+ /** The Constant TYPE_MASK_ROTATION. */
+ public static final int TYPE_MASK_ROTATION = TYPE_QUADRANT_ROTATION | TYPE_GENERAL_ROTATION;
+
+ /** The <code>TYPE_UNKNOWN</code> is an initial type value. */
+ static final int TYPE_UNKNOWN = -1;
+
+ /** The min value equivalent to zero. If absolute value less then ZERO it considered as zero. */
+ static final double ZERO = 1E-10;
+
+ /** The values of transformation matrix. */
+ double m00;
+
+ /** The m10. */
+ double m10;
+
+ /** The m01. */
+ double m01;
+
+ /** The m11. */
+ double m11;
+
+ /** The m02. */
+ double m02;
+
+ /** The m12. */
+ double m12;
+
+ /** The transformation <code>type</code>. */
+ transient int type;
+
+ /**
+ * Instantiates a new affine transform of type <code>TYPE_IDENTITY</code>
+ * (which leaves coordinates unchanged).
+ */
+ public AffineTransform() {
+ type = TYPE_IDENTITY;
+ m00 = m11 = 1.0;
+ m10 = m01 = m02 = m12 = 0.0;
+ }
+
+ /**
+ * Instantiates a new affine transform that has the same data as
+ * the given AffineTransform.
+ *
+ * @param t the transform to copy.
+ */
+ public AffineTransform(AffineTransform t) {
+ this.type = t.type;
+ this.m00 = t.m00;
+ this.m10 = t.m10;
+ this.m01 = t.m01;
+ this.m11 = t.m11;
+ this.m02 = t.m02;
+ this.m12 = t.m12;
+ }
+
+ /**
+ * Instantiates a new affine transform by specifying the values of the 2x3
+ * transformation matrix as floats. The type is set to the default
+ * type: <code>TYPE_UNKNOWN</code>
+ *
+ * @param m00 the m00 entry in the transformation matrix.
+ * @param m10 the m10 entry in the transformation matrix.
+ * @param m01 the m01 entry in the transformation matrix.
+ * @param m11 the m11 entry in the transformation matrix.
+ * @param m02 the m02 entry in the transformation matrix.
+ * @param m12 the m12 entry in the transformation matrix.
+ */
+ public AffineTransform(float m00, float m10, float m01, float m11, float m02, float m12) {
+ this.type = TYPE_UNKNOWN;
+ this.m00 = m00;
+ this.m10 = m10;
+ this.m01 = m01;
+ this.m11 = m11;
+ this.m02 = m02;
+ this.m12 = m12;
+ }
+
+ /**
+ * Instantiates a new affine transform by specifying the values of the 2x3
+ * transformation matrix as doubles. The type is set to the default
+ * type: <code>TYPE_UNKNOWN</code>
+ *
+ * @param m00 the m00 entry in the transformation matrix.
+ * @param m10 the m10 entry in the transformation matrix.
+ * @param m01 the m01 entry in the transformation matrix.
+ * @param m11 the m11 entry in the transformation matrix.
+ * @param m02 the m02 entry in the transformation matrix.
+ * @param m12 the m12 entry in the transformation matrix.
+ */
+ public AffineTransform(double m00, double m10, double m01, double m11, double m02, double m12) {
+ this.type = TYPE_UNKNOWN;
+ this.m00 = m00;
+ this.m10 = m10;
+ this.m01 = m01;
+ this.m11 = m11;
+ this.m02 = m02;
+ this.m12 = m12;
+ }
+
+ /**
+ * Instantiates a new affine transform by reading the values of the
+ * transformation matrix from an array of floats. The mapping from the
+ * array to the matrix starts with <code>matrix[0]</code> giving the
+ * top-left entry of the matrix and
+ * proceeds with the usual left-to-right and top-down ordering.
+ * <p>
+ * If the array has only four entries, then the two entries of the
+ * last row of the transformation matrix default to zero.
+ *
+ * @param matrix the array of four or six floats giving the values
+ * of the matrix.
+ *
+ * @throws ArrayIndexOutOfBoundsException if the size of the array
+ * is 0, 1, 2, 3, or 5.
+ */
+ public AffineTransform(float[] matrix) {
+ this.type = TYPE_UNKNOWN;
+ m00 = matrix[0];
+ m10 = matrix[1];
+ m01 = matrix[2];
+ m11 = matrix[3];
+ if (matrix.length > 4) {
+ m02 = matrix[4];
+ m12 = matrix[5];
+ }
+ }
+
+ /**
+ * Instantiates a new affine transform by reading the values of the
+ * transformation matrix from an array of doubles. The mapping from the
+ * array to the matrix starts with <code>matrix[0]</code> giving the
+ * top-left entry of the matrix and
+ * proceeds with the usual left-to-right and top-down ordering.
+ * <p>
+ * If the array has only four entries, then the two entries of the
+ * last row of the transformation matrix default to zero.
+ *
+ * @param matrix the array of four or six doubles giving the values
+ * of the matrix.
+ *
+ * @throws ArrayIndexOutOfBoundsException if the size of the array
+ * is 0, 1, 2, 3, or 5.
+ */
+ public AffineTransform(double[] matrix) {
+ this.type = TYPE_UNKNOWN;
+ m00 = matrix[0];
+ m10 = matrix[1];
+ m01 = matrix[2];
+ m11 = matrix[3];
+ if (matrix.length > 4) {
+ m02 = matrix[4];
+ m12 = matrix[5];
+ }
+ }
+
+
+ /**
+ * Returns type of the affine transformation.
+ * <p>
+ * The type is computed as follows: Label the entries of the
+ * transformation matrix as three rows (m00, m01), (m10, m11), and
+ * (m02, m12). Then if the original basis vectors are (1, 0) and (0, 1),
+ * the new basis vectors after transformation are given by (m00, m01)
+ * and (m10, m11), and the translation vector is (m02, m12).
+ * <p>
+ * The types are classified as follows: <br/>
+ * TYPE_IDENTITY - no change<br/>
+ * TYPE_TRANSLATION - The translation vector isn't zero<br/>
+ * TYPE_UNIFORM_SCALE - The new basis vectors have equal length<br/>
+ * TYPE_GENERAL_SCALE - The new basis vectors dont' have equal length<br/>
+ * TYPE_FLIP - The new basis vector orientation differs from the original one<br/>
+ * TYPE_QUADRANT_ROTATION - The new basis is a rotation of the original by 90, 180, 270, or 360 degrees<br/>
+ * TYPE_GENERAL_ROTATION - The new basis is a rotation of the original by an arbitrary angle<br/>
+ * TYPE_GENERAL_TRANSFORM - The transformation can't be inverted.<br/>
+ * <p>
+ * Note that multiple types are possible, thus the types can be combined
+ * using bitwise combinations.
+ *
+ * @return the type of the Affine Transform.
+ */
+ public int getType() {
+ if (type != TYPE_UNKNOWN) {
+ return type;
+ }
+
+ int type = 0;
+
+ if (m00 * m01 + m10 * m11 != 0.0) {
+ type |= TYPE_GENERAL_TRANSFORM;
+ return type;
+ }
+
+ if (m02 != 0.0 || m12 != 0.0) {
+ type |= TYPE_TRANSLATION;
+ } else
+ if (m00 == 1.0 && m11 == 1.0 && m01 == 0.0 && m10 == 0.0) {
+ type = TYPE_IDENTITY;
+ return type;
+ }
+
+ if (m00 * m11 - m01 * m10 < 0.0) {
+ type |= TYPE_FLIP;
+ }
+
+ double dx = m00 * m00 + m10 * m10;
+ double dy = m01 * m01 + m11 * m11;
+ if (dx != dy) {
+ type |= TYPE_GENERAL_SCALE;
+ } else
+ if (dx != 1.0) {
+ type |= TYPE_UNIFORM_SCALE;
+ }
+
+ if ((m00 == 0.0 && m11 == 0.0) ||
+ (m10 == 0.0 && m01 == 0.0 && (m00 < 0.0 || m11 < 0.0)))
+ {
+ type |= TYPE_QUADRANT_ROTATION;
+ } else
+ if (m01 != 0.0 || m10 != 0.0) {
+ type |= TYPE_GENERAL_ROTATION;
+ }
+
+ return type;
+ }
+
+ /**
+ * Gets the scale x entry of the transformation matrix
+ * (the upper left matrix entry).
+ *
+ * @return the scale x value.
+ */
+ public double getScaleX() {
+ return m00;
+ }
+
+ /**
+ * Gets the scale y entry of the transformation matrix
+ * (the lower right entry of the linear transformation).
+ *
+ * @return the scale y value.
+ */
+ public double getScaleY() {
+ return m11;
+ }
+
+ /**
+ * Gets the shear x entry of the transformation matrix
+ * (the upper right entry of the linear transformation).
+ *
+ * @return the shear x value.
+ */
+ public double getShearX() {
+ return m01;
+ }
+
+ /**
+ * Gets the shear y entry of the transformation matrix
+ * (the lower left entry of the linear transformation).
+ *
+ * @return the shear y value.
+ */
+ public double getShearY() {
+ return m10;
+ }
+
+ /**
+ * Gets the x coordinate of the translation vector.
+ *
+ * @return the x coordinate of the translation vector.
+ */
+ public double getTranslateX() {
+ return m02;
+ }
+
+ /**
+ * Gets the y coordinate of the translation vector.
+ *
+ * @return the y coordinate of the translation vector.
+ */
+ public double getTranslateY() {
+ return m12;
+ }
+
+ /**
+ * Checks if the AffineTransformation is the identity.
+ *
+ * @return true, if the AffineTransformation is the identity.
+ */
+ public boolean isIdentity() {
+ return getType() == TYPE_IDENTITY;
+ }
+
+ /**
+ * Writes the values of the transformation matrix into the given
+ * array of doubles. If the array has length 4, only the linear
+ * transformation part will be written into it. If it has length
+ * greater than 4, the translation vector will be included as well.
+ *
+ * @param matrix the array to fill with the values of the matrix.
+ *
+ * @throws ArrayIndexOutOfBoundsException if the size of the array
+ * is 0, 1, 2, 3, or 5.
+ */
+ public void getMatrix(double[] matrix) {
+ matrix[0] = m00;
+ matrix[1] = m10;
+ matrix[2] = m01;
+ matrix[3] = m11;
+ if (matrix.length > 4) {
+ matrix[4] = m02;
+ matrix[5] = m12;
+ }
+ }
+
+ /**
+ * Gets the determinant of the linear transformation matrix.
+ *
+ * @return the determinant of the linear transformation matrix.
+ */
+ public double getDeterminant() {
+ return m00 * m11 - m01 * m10;
+ }
+
+ /**
+ * Sets the transform in terms of a list of double values.
+ *
+ * @param m00 the m00 coordinate of the transformation matrix.
+ * @param m10 the m10 coordinate of the transformation matrix.
+ * @param m01 the m01 coordinate of the transformation matrix.
+ * @param m11 the m11 coordinate of the transformation matrix.
+ * @param m02 the m02 coordinate of the transformation matrix.
+ * @param m12 the m12 coordinate of the transformation matrix.
+ */
+ public void setTransform(double m00, double m10, double m01, double m11, double m02, double m12) {
+ this.type = TYPE_UNKNOWN;
+ this.m00 = m00;
+ this.m10 = m10;
+ this.m01 = m01;
+ this.m11 = m11;
+ this.m02 = m02;
+ this.m12 = m12;
+ }
+
+ /**
+ * Sets the transform's data to match the data of the transform
+ * sent as a parameter.
+ *
+ * @param t the transform that gives the new values.
+ */
+ public void setTransform(AffineTransform t) {
+ type = t.type;
+ setTransform(t.m00, t.m10, t.m01, t.m11, t.m02, t.m12);
+ }
+
+ /**
+ * Sets the transform to the identity transform.
+ */
+ public void setToIdentity() {
+ type = TYPE_IDENTITY;
+ m00 = m11 = 1.0;
+ m10 = m01 = m02 = m12 = 0.0;
+ }
+
+ /**
+ * Sets the transformation to a translation alone.
+ * Sets the linear part of the transformation to identity
+ * and the translation vector to the values sent as parameters.
+ * Sets the type to <code>TYPE_IDENTITY</code>
+ * if the resulting AffineTransformation is the identity
+ * transformation, otherwise sets it to <code>TYPE_TRANSLATION</code>.
+ *
+ * @param mx the distance to translate in the x direction.
+ * @param my the distance to translate in the y direction.
+ */
+ public void setToTranslation(double mx, double my) {
+ m00 = m11 = 1.0;
+ m01 = m10 = 0.0;
+ m02 = mx;
+ m12 = my;
+ if (mx == 0.0 && my == 0.0) {
+ type = TYPE_IDENTITY;
+ } else {
+ type = TYPE_TRANSLATION;
+ }
+ }
+
+ /**
+ * Sets the transformation to being a scale alone, eliminating
+ * rotation, shear, and translation elements.
+ * Sets the type to <code>TYPE_IDENTITY</code>
+ * if the resulting AffineTransformation is the identity
+ * transformation, otherwise sets it to <code>TYPE_UNKNOWN</code>.
+ *
+ * @param scx the scaling factor in the x direction.
+ * @param scy the scaling factor in the y direction.
+ */
+ public void setToScale(double scx, double scy) {
+ m00 = scx;
+ m11 = scy;
+ m10 = m01 = m02 = m12 = 0.0;
+ if (scx != 1.0 || scy != 1.0) {
+ type = TYPE_UNKNOWN;
+ } else {
+ type = TYPE_IDENTITY;
+ }
+ }
+
+ /**
+ * Sets the transformation to being a shear alone, eliminating
+ * rotation, scaling, and translation elements.
+ * Sets the type to <code>TYPE_IDENTITY</code>
+ * if the resulting AffineTransformation is the identity
+ * transformation, otherwise sets it to <code>TYPE_UNKNOWN</code>.
+ *
+ * @param shx the shearing factor in the x direction.
+ * @param shy the shearing factor in the y direction.
+ */
+ public void setToShear(double shx, double shy) {
+ m00 = m11 = 1.0;
+ m02 = m12 = 0.0;
+ m01 = shx;
+ m10 = shy;
+ if (shx != 0.0 || shy != 0.0) {
+ type = TYPE_UNKNOWN;
+ } else {
+ type = TYPE_IDENTITY;
+ }
+ }
+
+ /**
+ * Sets the transformation to being a rotation alone, eliminating
+ * shearing, scaling, and translation elements.
+ * Sets the type to <code>TYPE_IDENTITY</code>
+ * if the resulting AffineTransformation is the identity
+ * transformation, otherwise sets it to <code>TYPE_UNKNOWN</code>.
+ *
+ * @param angle the angle of rotation in radians.
+ */
+ public void setToRotation(double angle) {
+ double sin = Math.sin(angle);
+ double cos = Math.cos(angle);
+ if (Math.abs(cos) < ZERO) {
+ cos = 0.0;
+ sin = sin > 0.0 ? 1.0 : -1.0;
+ } else
+ if (Math.abs(sin) < ZERO) {
+ sin = 0.0;
+ cos = cos > 0.0 ? 1.0 : -1.0;
+ }
+ m00 = m11 = cos;
+ m01 = -sin;
+ m10 = sin;
+ m02 = m12 = 0.0;
+ type = TYPE_UNKNOWN;
+ }
+
+ /**
+ * Sets the transformation to being a rotation followed by a
+ * translation.
+ * Sets the type to <code>TYPE_UNKNOWN</code>.
+ *
+ * @param angle the angle of rotation in radians.
+ * @param px the distance to translate in the x direction.
+ * @param py the distance to translate in the y direction.
+ */
+ public void setToRotation(double angle, double px, double py) {
+ setToRotation(angle);
+ m02 = px * (1.0 - m00) + py * m10;
+ m12 = py * (1.0 - m00) - px * m10;
+ type = TYPE_UNKNOWN;
+ }
+
+ /**
+ * Creates a new AffineTransformation that is a translation alone
+ * with the translation vector given by the values sent as parameters.
+ * The new transformation's type is <code>TYPE_IDENTITY</code>
+ * if the AffineTransformation is the identity
+ * transformation, otherwise it's <code>TYPE_TRANSLATION</code>.
+ *
+ * @param mx the distance to translate in the x direction.
+ * @param my the distance to translate in the y direction.
+
+ * @return the new AffineTransformation.
+ */
+ public static AffineTransform getTranslateInstance(double mx, double my) {
+ AffineTransform t = new AffineTransform();
+ t.setToTranslation(mx, my);
+ return t;
+ }
+
+ /**
+ * Creates a new AffineTransformation that is a scale alone.
+ * The new transformation's type is <code>TYPE_IDENTITY</code>
+ * if the AffineTransformation is the identity
+ * transformation, otherwise it's <code>TYPE_UNKNOWN</code>.
+ *
+ * @param scx the scaling factor in the x direction.
+ * @param scY the scaling factor in the y direction.
+ *
+ * @return the new AffineTransformation.
+ */
+ public static AffineTransform getScaleInstance(double scx, double scY) {
+ AffineTransform t = new AffineTransform();
+ t.setToScale(scx, scY);
+ return t;
+ }
+
+ /**
+ * Creates a new AffineTransformation that is a shear alone.
+ * The new transformation's type is <code>TYPE_IDENTITY</code>
+ * if the AffineTransformation is the identity
+ * transformation, otherwise it's <code>TYPE_UNKNOWN</code>.
+ *
+ * @param shx the shearing factor in the x direction.
+ * @param shy the shearing factor in the y direction.
+ *
+ * @return the new AffineTransformation.
+ */
+ public static AffineTransform getShearInstance(double shx, double shy) {
+ AffineTransform m = new AffineTransform();
+ m.setToShear(shx, shy);
+ return m;
+ }
+
+ /**
+ * Creates a new AffineTransformation that is a rotation alone.
+ * The new transformation's type is <code>TYPE_IDENTITY</code>
+ * if the AffineTransformation is the identity
+ * transformation, otherwise it's <code>TYPE_UNKNOWN</code>.
+ *
+ * @param angle the angle of rotation in radians.
+ *
+ * @return the new AffineTransformation.
+ */
+ public static AffineTransform getRotateInstance(double angle) {
+ AffineTransform t = new AffineTransform();
+ t.setToRotation(angle);
+ return t;
+ }
+
+ /**
+ * Creates a new AffineTransformation that is a rotation followed by a
+ * translation.
+ * Sets the type to <code>TYPE_UNKNOWN</code>.
+ *
+ * @param angle the angle of rotation in radians.
+ * @param x the distance to translate in the x direction.
+ * @param y the distance to translate in the y direction.
+ *
+ * @return the new AffineTransformation.
+ */
+ public static AffineTransform getRotateInstance(double angle, double x, double y) {
+ AffineTransform t = new AffineTransform();
+ t.setToRotation(angle, x, y);
+ return t;
+ }
+
+ /**
+ * Applies a translation to this AffineTransformation.
+ *
+ * @param mx the distance to translate in the x direction.
+ * @param my the distance to translate in the y direction.
+ */
+ public void translate(double mx, double my) {
+ concatenate(AffineTransform.getTranslateInstance(mx, my));
+ }
+
+ /**
+ * Applies a scaling transformation to this AffineTransformation.
+ *
+ * @param scx the scaling factor in the x direction.
+ * @param scy the scaling factor in the y direction.
+ */
+ public void scale(double scx, double scy) {
+ concatenate(AffineTransform.getScaleInstance(scx, scy));
+ }
+
+ /**
+ * Applies a shearing transformation to this AffineTransformation.
+ *
+ * @param shx the shearing factor in the x direction.
+ * @param shy the shearing factor in the y direction.
+ */
+ public void shear(double shx, double shy) {
+ concatenate(AffineTransform.getShearInstance(shx, shy));
+ }
+
+ /**
+ * Applies a rotation transformation to this AffineTransformation.
+ *
+ * @param angle the angle of rotation in radians.
+ */
+ public void rotate(double angle) {
+ concatenate(AffineTransform.getRotateInstance(angle));
+ }
+
+ /**
+ * Applies a rotation and translation transformation to this
+ * AffineTransformation.
+ *
+ * @param angle the angle of rotation in radians.
+ * @param px the distance to translate in the x direction.
+ * @param py the distance to translate in the y direction.
+ */
+ public void rotate(double angle, double px, double py) {
+ concatenate(AffineTransform.getRotateInstance(angle, px, py));
+ }
+
+ /**
+ * Multiplies the matrix representations of two AffineTransform objects.
+ *
+ * @param t1 - the AffineTransform object is a multiplicand
+ * @param t2 - the AffineTransform object is a multiplier
+ *
+ * @return an AffineTransform object that is the result of t1 multiplied by the matrix t2.
+ */
+ AffineTransform multiply(AffineTransform t1, AffineTransform t2) {
+ return new AffineTransform(
+ t1.m00 * t2.m00 + t1.m10 * t2.m01, // m00
+ t1.m00 * t2.m10 + t1.m10 * t2.m11, // m01
+ t1.m01 * t2.m00 + t1.m11 * t2.m01, // m10
+ t1.m01 * t2.m10 + t1.m11 * t2.m11, // m11
+ t1.m02 * t2.m00 + t1.m12 * t2.m01 + t2.m02, // m02
+ t1.m02 * t2.m10 + t1.m12 * t2.m11 + t2.m12);// m12
+ }
+
+ /**
+ * Applies the given AffineTransform to this AffineTransform
+ * via matrix multiplication.
+ *
+ * @param t the AffineTransform to apply to this AffineTransform.
+ */
+ public void concatenate(AffineTransform t) {
+ setTransform(multiply(t, this));
+ }
+
+ /**
+ * Changes the current AffineTransform the one obtained by
+ * taking the transform t and applying this AffineTransform to it.
+ *
+ * @param t the AffineTransform that this AffineTransform is multiplied by.
+ */
+ public void preConcatenate(AffineTransform t) {
+ setTransform(multiply(this, t));
+ }
+
+ /**
+ * Creates an AffineTransform that is the inverse of this transform.
+ *
+ * @return the affine transform that is the inverse of this AffineTransform.
+ *
+ * @throws NoninvertibleTransformException if this AffineTransform cannot be
+ * inverted (the determinant of the linear transformation part is zero).
+ */
+ public AffineTransform createInverse() throws NoninvertibleTransformException {
+ double det = getDeterminant();
+ if (Math.abs(det) < ZERO) {
+ // awt.204=Determinant is zero
+ throw new NoninvertibleTransformException(Messages.getString("awt.204")); //$NON-NLS-1$
+ }
+ return new AffineTransform(
+ m11 / det, // m00
+ -m10 / det, // m10
+ -m01 / det, // m01
+ m00 / det, // m11
+ (m01 * m12 - m11 * m02) / det, // m02
+ (m10 * m02 - m00 * m12) / det // m12
+ );
+ }
+
+ /**
+ * Apply the current AffineTransform to the point.
+ *
+ * @param src the original point.
+ * @param dst Point2D object to be filled with the destination
+ * coordinates (where the original point is sent by this AffineTransform). May be null.
+ *
+ * @return the point in the AffineTransform's image space where the
+ * original point is sent.
+ */
+ public Point2D transform(Point2D src, Point2D dst) {
+ if (dst == null) {
+ if (src instanceof Point2D.Double) {
+ dst = new Point2D.Double();
+ } else {
+ dst = new Point2D.Float();
+ }
+ }
+
+ double x = src.getX();
+ double y = src.getY();
+
+ dst.setLocation(x * m00 + y * m01 + m02, x * m10 + y * m11 + m12);
+ return dst;
+ }
+
+ /**
+ * Applies this AffineTransform to an array of points.
+ *
+ * @param src the array of points to be transformed.
+ * @param srcOff the offset in the source point array of the first point
+ * to be transformed.
+ * @param dst the point array where the images of the points (after
+ * applying the AffineTransformation) should be placed.
+ * @param dstOff the offset in the destination array where the new
+ * values should be written.
+ * @param length the number of points to transform.
+ *
+ * @throws ArrayIndexOutOfBoundsException if
+ * <code>srcOff + length > src.length</code> or
+ * <code>dstOff + length > dst.length</code>.
+ */
+ public void transform(Point2D[] src, int srcOff, Point2D[] dst, int dstOff, int length) {
+ while (--length >= 0) {
+ Point2D srcPoint = src[srcOff++];
+ double x = srcPoint.getX();
+ double y = srcPoint.getY();
+ Point2D dstPoint = dst[dstOff];
+ if (dstPoint == null) {
+ if (srcPoint instanceof Point2D.Double) {
+ dstPoint = new Point2D.Double();
+ } else {
+ dstPoint = new Point2D.Float();
+ }
+ }
+ dstPoint.setLocation(x * m00 + y * m01 + m02, x * m10 + y * m11 + m12);
+ dst[dstOff++] = dstPoint;
+ }
+ }
+
+ /**
+ * Applies this AffineTransform to a set of points given
+ * as an array of double values where every two values in the array
+ * give the coordinates of a point; the even-indexed values giving the
+ * x coordinates and the odd-indexed values giving the y coordinates.
+ *
+ * @param src the array of points to be transformed.
+ * @param srcOff the offset in the source point array of the first point
+ * to be transformed.
+ * @param dst the point array where the images of the points (after
+ * applying the AffineTransformation) should be placed.
+ * @param dstOff the offset in the destination array where the new
+ * values should be written.
+ * @param length the number of points to transform.
+ *
+ * @throws ArrayIndexOutOfBoundsException if
+ * <code>srcOff + length*2 > src.length</code> or
+ * <code>dstOff + length*2 > dst.length</code>.
+ */
+ public void transform(double[] src, int srcOff, double[] dst, int dstOff, int length) {
+ int step = 2;
+ if (src == dst && srcOff < dstOff && dstOff < srcOff + length * 2) {
+ srcOff = srcOff + length * 2 - 2;
+ dstOff = dstOff + length * 2 - 2;
+ step = -2;
+ }
+ while (--length >= 0) {
+ double x = src[srcOff + 0];
+ double y = src[srcOff + 1];
+ dst[dstOff + 0] = x * m00 + y * m01 + m02;
+ dst[dstOff + 1] = x * m10 + y * m11 + m12;
+ srcOff += step;
+ dstOff += step;
+ }
+ }
+
+ /**
+ * Applies this AffineTransform to a set of points given
+ * as an array of float values where every two values in the array
+ * give the coordinates of a point; the even-indexed values giving the
+ * x coordinates and the odd-indexed values giving the y coordinates.
+ *
+ * @param src the array of points to be transformed.
+ * @param srcOff the offset in the source point array of the first point
+ * to be transformed.
+ * @param dst the point array where the images of the points (after
+ * applying the AffineTransformation) should be placed.
+ * @param dstOff the offset in the destination array where the new
+ * values should be written.
+ * @param length the number of points to transform.
+ *
+ * @throws ArrayIndexOutOfBoundsException if
+ * <code>srcOff + length*2 > src.length</code> or
+ * <code>dstOff + length*2 > dst.length</code>.
+ */
+ public void transform(float[] src, int srcOff, float[] dst, int dstOff, int length) {
+ int step = 2;
+ if (src == dst && srcOff < dstOff && dstOff < srcOff + length * 2) {
+ srcOff = srcOff + length * 2 - 2;
+ dstOff = dstOff + length * 2 - 2;
+ step = -2;
+ }
+ while (--length >= 0) {
+ float x = src[srcOff + 0];
+ float y = src[srcOff + 1];
+ dst[dstOff + 0] = (float)(x * m00 + y * m01 + m02);
+ dst[dstOff + 1] = (float)(x * m10 + y * m11 + m12);
+ srcOff += step;
+ dstOff += step;
+ }
+ }
+
+ /**
+ * Applies this AffineTransform to a set of points given
+ * as an array of float values where every two values in the array
+ * give the coordinates of a point; the even-indexed values giving the
+ * x coordinates and the odd-indexed values giving the y coordinates.
+ * The destination coordinates are given as values of type <code>double</code>.
+ *
+ * @param src the array of points to be transformed.
+ * @param srcOff the offset in the source point array of the first point
+ * to be transformed.
+ * @param dst the point array where the images of the points (after
+ * applying the AffineTransformation) should be placed.
+ * @param dstOff the offset in the destination array where the new
+ * values should be written.
+ * @param length the number of points to transform.
+ *
+ * @throws ArrayIndexOutOfBoundsException if
+ * <code>srcOff + length*2 > src.length</code> or
+ * <code>dstOff + length*2 > dst.length</code>.
+ */
+ public void transform(float[] src, int srcOff, double[] dst, int dstOff, int length) {
+ while (--length >= 0) {
+ float x = src[srcOff++];
+ float y = src[srcOff++];
+ dst[dstOff++] = x * m00 + y * m01 + m02;
+ dst[dstOff++] = x * m10 + y * m11 + m12;
+ }
+ }
+
+ /**
+ * Applies this AffineTransform to a set of points given
+ * as an array of double values where every two values in the array
+ * give the coordinates of a point; the even-indexed values giving the
+ * x coordinates and the odd-indexed values giving the y coordinates.
+ * The destination coordinates are given as values of type <code>float</code>.
+ *
+ * @param src the array of points to be transformed.
+ * @param srcOff the offset in the source point array of the first point
+ * to be transformed.
+ * @param dst the point array where the images of the points (after
+ * applying the AffineTransformation) should be placed.
+ * @param dstOff the offset in the destination array where the new
+ * values should be written.
+ * @param length the number of points to transform.
+ *
+ * @throws ArrayIndexOutOfBoundsException if
+ * <code>srcOff + length*2 > src.length</code> or
+ * <code>dstOff + length*2 > dst.length</code>.
+ */
+ public void transform(double[] src, int srcOff, float[] dst, int dstOff, int length) {
+ while (--length >= 0) {
+ double x = src[srcOff++];
+ double y = src[srcOff++];
+ dst[dstOff++] = (float)(x * m00 + y * m01 + m02);
+ dst[dstOff++] = (float)(x * m10 + y * m11 + m12);
+ }
+ }
+
+ /**
+ * Transforms the point according to the linear transformation
+ * part of this AffineTransformation (without applying the translation).
+ *
+ * @param src the original point.
+ * @param dst the point object where the result of the delta transform
+ * is written.
+ *
+ * @return the result of applying the delta transform (linear part
+ * only) to the original point.
+ */
+ // TODO: is this right? if dst is null, we check what it's an
+ // instance of? Shouldn't it be src instanceof Point2D.Double?
+ public Point2D deltaTransform(Point2D src, Point2D dst) {
+ if (dst == null) {
+ if (dst instanceof Point2D.Double) {
+ dst = new Point2D.Double();
+ } else {
+ dst = new Point2D.Float();
+ }
+ }
+
+ double x = src.getX();
+ double y = src.getY();
+
+ dst.setLocation(x * m00 + y * m01, x * m10 + y * m11);
+ return dst;
+ }
+
+ /**
+ * Applies the linear transformation part of this AffineTransform
+ * (ignoring the translation part) to a set of points given
+ * as an array of double values where every two values in the array
+ * give the coordinates of a point; the even-indexed values giving the
+ * x coordinates and the odd-indexed values giving the y coordinates.
+ *
+ * @param src the array of points to be transformed.
+ * @param srcOff the offset in the source point array of the first point
+ * to be transformed.
+ * @param dst the point array where the images of the points (after
+ * applying the delta transformation) should be placed.
+ * @param dstOff the offset in the destination array where the new
+ * values should be written.
+ * @param length the number of points to transform.
+ *
+ * @throws ArrayIndexOutOfBoundsException if
+ * <code>srcOff + length*2 > src.length</code> or
+ * <code>dstOff + length*2 > dst.length</code>.
+ */
+ public void deltaTransform(double[] src, int srcOff, double[] dst, int dstOff, int length) {
+ while (--length >= 0) {
+ double x = src[srcOff++];
+ double y = src[srcOff++];
+ dst[dstOff++] = x * m00 + y * m01;
+ dst[dstOff++] = x * m10 + y * m11;
+ }
+ }
+
+ /**
+ * Transforms the point according to the inverse of this AffineTransformation.
+ *
+ * @param src the original point.
+ * @param dst the point object where the result of the inverse transform
+ * is written (may be null).
+ *
+ * @return the result of applying the inverse transform.
+ * Inverse transform.
+ *
+ * @throws NoninvertibleTransformException if this AffineTransform cannot be
+ * inverted (the determinant of the linear transformation part is zero).
+ */
+ public Point2D inverseTransform(Point2D src, Point2D dst) throws NoninvertibleTransformException {
+ double det = getDeterminant();
+ if (Math.abs(det) < ZERO) {
+ // awt.204=Determinant is zero
+ throw new NoninvertibleTransformException(Messages.getString("awt.204")); //$NON-NLS-1$
+ }
+
+ if (dst == null) {
+ if (src instanceof Point2D.Double) {
+ dst = new Point2D.Double();
+ } else {
+ dst = new Point2D.Float();
+ }
+ }
+
+ double x = src.getX() - m02;
+ double y = src.getY() - m12;
+
+ dst.setLocation((x * m11 - y * m01) / det, (y * m00 - x * m10) / det);
+ return dst;
+ }
+
+ /**
+ * Applies the inverse of this AffineTransform to a set of points given
+ * as an array of double values where every two values in the array
+ * give the coordinates of a point; the even-indexed values giving the
+ * x coordinates and the odd-indexed values giving the y coordinates.
+ *
+ * @param src the array of points to be transformed.
+ * @param srcOff the offset in the source point array of the first point
+ * to be transformed.
+ * @param dst the point array where the images of the points (after
+ * applying the inverse of the AffineTransformation) should be placed.
+ * @param dstOff the offset in the destination array where the new
+ * values should be written.
+ * @param length the number of points to transform.
+ *
+ * @throws ArrayIndexOutOfBoundsException if
+ * <code>srcOff + length*2 > src.length</code> or
+ * <code>dstOff + length*2 > dst.length</code>.
+ * @throws NoninvertibleTransformException if this AffineTransform cannot be
+ * inverted (the determinant of the linear transformation part is zero).
+ */
+ public void inverseTransform(double[] src, int srcOff, double[] dst, int dstOff, int length)
+ throws NoninvertibleTransformException
+ {
+ double det = getDeterminant();
+ if (Math.abs(det) < ZERO) {
+ // awt.204=Determinant is zero
+ throw new NoninvertibleTransformException(Messages.getString("awt.204")); //$NON-NLS-1$
+ }
+
+ while (--length >= 0) {
+ double x = src[srcOff++] - m02;
+ double y = src[srcOff++] - m12;
+ dst[dstOff++] = (x * m11 - y * m01) / det;
+ dst[dstOff++] = (y * m00 - x * m10) / det;
+ }
+ }
+
+ /**
+ * Creates a new shape whose data is given by applying this
+ * AffineTransform to the specified shape.
+ *
+ * @param src the original shape whose data is to be transformed.
+ *
+ * @return the new shape found by applying this AffineTransform to
+ * the original shape.
+ */
+ public Shape createTransformedShape(Shape src) {
+ if (src == null) {
+ return null;
+ }
+ if (src instanceof GeneralPath) {
+ return ((GeneralPath)src).createTransformedShape(this);
+ }
+ PathIterator path = src.getPathIterator(this);
+ GeneralPath dst = new GeneralPath(path.getWindingRule());
+ dst.append(path, false);
+ return dst;
+ }
+
+ @Override
+ public String toString() {
+ return
+ getClass().getName() +
+ "[[" + m00 + ", " + m01 + ", " + m02 + "], [" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ + m10 + ", " + m11 + ", " + m12 + "]]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+ @Override
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ throw new InternalError();
+ }
+ }
+
+ @Override
+ public int hashCode() {
+ HashCode hash = new HashCode();
+ hash.append(m00);
+ hash.append(m01);
+ hash.append(m02);
+ hash.append(m10);
+ hash.append(m11);
+ hash.append(m12);
+ return hash.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (obj instanceof AffineTransform) {
+ AffineTransform t = (AffineTransform)obj;
+ return
+ m00 == t.m00 && m01 == t.m01 &&
+ m02 == t.m02 && m10 == t.m10 &&
+ m11 == t.m11 && m12 == t.m12;
+ }
+ return false;
+ }
+
+
+ /**
+ * Writes the AffineTrassform object to the output steam.
+ *
+ * @param stream - the output stream
+ *
+ * @throws IOException - if there are I/O errors while writing to the output strem
+ */
+ private void writeObject(java.io.ObjectOutputStream stream) throws IOException {
+ stream.defaultWriteObject();
+ }
+
+
+ /**
+ * Read the AffineTransform object from the input stream.
+ *
+ * @param stream - the input steam
+ *
+ * @throws IOException - if there are I/O errors while reading from the input strem
+ * @throws ClassNotFoundException - if class could not be found
+ */
+ private void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException {
+ stream.defaultReadObject();
+ type = TYPE_UNKNOWN;
+ }
+
+}
+
diff --git a/awt/java/awt/geom/Arc2D.java b/awt/java/awt/geom/Arc2D.java
new file mode 100644
index 0000000..bc1e95c
--- /dev/null
+++ b/awt/java/awt/geom/Arc2D.java
@@ -0,0 +1,1028 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class Arc2D represents a segment of a curve inscribed
+ * in a rectangle. The curve is defined by a start angle and an
+ * extent angle (the end angle minus the start angle) as
+ * a pie wedge whose point is in the center of the rectangle.
+ * The Arc2D as a shape may be either OPEN (including nothing
+ * but the curved arc segment itself), CHORD (the curved arc
+ * segment closed by a connecting segment from the end to the
+ * beginning of the arc, or PIE (the segments from the end
+ * of the arc to the center of the rectangle and from the
+ * center of the rectangle back to the arc's start point are
+ * included).
+ */
+public abstract class Arc2D extends RectangularShape {
+
+ /** The arc type OPEN indicates that the shape includes only the
+ * curved arc segment. */
+ public final static int OPEN = 0;
+
+ /** The arc type CHORD indicates that as a shape the connecting
+ * segment from the end point of the curved arc to the beginning
+ * point is included. */
+ public final static int CHORD = 1;
+
+ /** The arc type PIE indicates that as a shape the two segments
+ * from the arc's endpoint to the center of the rectangle and from
+ * the center of the rectangle to the arc's endpoint are included. */
+ public final static int PIE = 2;
+
+ /**
+ * The Class Float is a subclass of Arc2D in which all of the
+ * data values are given as floats.
+ * @see Arc2D.Double
+ */
+ public static class Float extends Arc2D {
+
+ /** The x coordinate of the upper left corner of the rectangle that
+ * contains the arc. */
+ public float x;
+
+ /** The y coordinate of the upper left corner of the rectangle that
+ * contains the arc. */
+ public float y;
+
+ /** The width of the rectangle that contains the arc. */
+ public float width;
+
+ /** The height of the rectangle that contains the arc. */
+ public float height;
+
+ /** The start angle of the arc in degrees. */
+ public float start;
+
+ /** The width angle of the arc in degrees. */
+ public float extent;
+
+ /**
+ * Instantiates a new Arc2D of type OPEN with float values.
+ */
+ public Float() {
+ super(OPEN);
+ }
+
+ /**
+ * Instantiates a new Arc2D of the specified type with float values.
+ *
+ * @param type the type of the new Arc2D, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public Float(int type) {
+ super(type);
+ }
+
+ /**
+ * Instantiates a Arc2D with the specified float-valued data.
+ *
+ * @param x the x coordinate of the upper left corner of the rectangle that
+ * contains the arc.
+ * @param y the y coordinate of the upper left corner of the rectangle that
+ * contains the arc.
+ * @param width the width of the rectangle that
+ * contains the arc.
+ * @param height the height of the rectangle that
+ * contains the arc.
+ * @param start the start angle of the arc in degrees.
+ * @param extent the width angle of the arc in degrees.
+ * @param type the type of the new Arc2D, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public Float(float x, float y, float width, float height, float start, float extent, int type) {
+ super(type);
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ this.start = start;
+ this.extent = extent;
+ }
+
+ /**
+ * Instantiates a new Angle2D with the specified float-valued data
+ * and the bounding rectangle given by the parameter bounds.
+ *
+ * @param bounds the bounding rectangle of the Angle2D.
+ * @param start the start angle of the arc in degrees.
+ * @param extent the width angle of the arc in degrees.
+ * @param type the type of the new Arc2D, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public Float(Rectangle2D bounds, float start, float extent, int type) {
+ super(type);
+ this.x = (float)bounds.getX();
+ this.y = (float)bounds.getY();
+ this.width = (float)bounds.getWidth();
+ this.height = (float)bounds.getHeight();
+ this.start = start;
+ this.extent = extent;
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ @Override
+ public double getAngleStart() {
+ return start;
+ }
+
+ @Override
+ public double getAngleExtent() {
+ return extent;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return width <= 0.0f || height <= 0.0f;
+ }
+
+ @Override
+ public void setArc(double x, double y, double width, double height,
+ double start, double extent, int type)
+ {
+ this.setArcType(type);
+ this.x = (float)x;
+ this.y = (float)y;
+ this.width = (float)width;
+ this.height = (float)height;
+ this.start = (float)start;
+ this.extent = (float)extent;
+ }
+
+ @Override
+ public void setAngleStart(double start) {
+ this.start = (float)start;
+ }
+
+ @Override
+ public void setAngleExtent(double extent) {
+ this.extent = (float)extent;
+ }
+
+ @Override
+ protected Rectangle2D makeBounds(double x, double y, double width, double height) {
+ return new Rectangle2D.Float((float)x, (float)y, (float)width, (float)height);
+ }
+
+ }
+
+ /**
+ * The Class Double is a subclass of Arc2D in which all of the
+ * data values are given as doubles.
+ * @see Arc2D.Float
+ */
+ public static class Double extends Arc2D {
+
+ /** The x coordinate of the upper left corner of the rectangle that
+ * contains the arc. */
+ public double x;
+
+ /** The y coordinate of the upper left corner of the rectangle that
+ * contains the arc. */
+ public double y;
+
+ /** The width of the rectangle that contains the arc. */
+ public double width;
+
+ /** The height of the rectangle that contains the arc. */
+ public double height;
+
+ /** The start angle of the arc in degrees. */
+ public double start;
+
+ /** The width angle of the arc in degrees. */
+ public double extent;
+
+ /**
+ * Instantiates a new Arc2D of type OPEN with double values.
+ */
+ public Double() {
+ super(OPEN);
+ }
+
+ /**
+ * Instantiates a new Arc2D of the specified type with double values.
+ *
+ * @param type the type of the new Arc2D, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public Double(int type) {
+ super(type);
+ }
+
+ /**
+ * Instantiates a Arc2D with the specified double-valued data.
+ *
+ * @param x the x coordinate of the upper left corner of the rectangle that
+ * contains the arc.
+ * @param y the y coordinate of the upper left corner of the rectangle that
+ * contains the arc.
+ * @param width the width of the rectangle that
+ * contains the arc.
+ * @param height the height of the rectangle that
+ * contains the arc.
+ * @param start the start angle of the arc in degrees.
+ * @param extent the width angle of the arc in degrees.
+ * @param type the type of the new Arc2D, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public Double(double x, double y, double width, double height,
+ double start, double extent, int type)
+ {
+ super(type);
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ this.start = start;
+ this.extent = extent;
+ }
+
+ /**
+ * Instantiates a new Angle2D with the specified float-valued data
+ * and the bounding rectangle given by the parameter bounds.
+ *
+ * @param bounds the bounding rectangle of the Angle2D.
+ * @param start the start angle of the arc in degrees.
+ * @param extent the width angle of the arc in degrees.
+ * @param type the type of the new Arc2D, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public Double(Rectangle2D bounds, double start, double extent, int type) {
+ super(type);
+ this.x = bounds.getX();
+ this.y = bounds.getY();
+ this.width = bounds.getWidth();
+ this.height = bounds.getHeight();
+ this.start = start;
+ this.extent = extent;
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ @Override
+ public double getAngleStart() {
+ return start;
+ }
+
+ @Override
+ public double getAngleExtent() {
+ return extent;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return width <= 0.0 || height <= 0.0;
+ }
+
+ @Override
+ public void setArc(double x, double y, double width, double height,
+ double start, double extent, int type)
+ {
+ this.setArcType(type);
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ this.start = start;
+ this.extent = extent;
+ }
+
+ @Override
+ public void setAngleStart(double start) {
+ this.start = start;
+ }
+
+ @Override
+ public void setAngleExtent(double extent) {
+ this.extent = extent;
+ }
+
+ @Override
+ protected Rectangle2D makeBounds(double x, double y, double width, double height) {
+ return new Rectangle2D.Double(x, y, width, height);
+ }
+
+ }
+
+ /**
+ * The Class Iterator is the subclass of PathIterator that is used to
+ * traverse the boundary of a shape of type Arc2D.
+ */
+ class Iterator implements PathIterator {
+
+ /** The x coordinate of the center of the arc's bounding rectangle. */
+ double x;
+
+ /** The y coordinate of the center of the arc's bounding rectangle. */
+ double y;
+
+ /** Half of the width of the arc's bounding rectangle (the radius in the case of a circular arc). */
+ double width;
+
+ /** Half of the height of the arc's bounding rectangle (the radius in the case of a circular arc). */
+ double height;
+
+ /** The start angle of the arc in degrees. */
+ double angle;
+
+ /** The angle extent in degrees. */
+ double extent;
+
+ /** The closure type of the arc. */
+ int type;
+
+ /** The path iterator transformation. */
+ AffineTransform t;
+
+ /** The current segment index. */
+ int index;
+
+ /** The number of arc segments the source arc subdivided to be approximated by Bezier curves. Depends on extent value. */
+ int arcCount;
+
+ /** The number of line segments. Depends on closure type. */
+ int lineCount;
+
+ /** The step to calculate next arc subdivision point. */
+ double step;
+
+ /** The temporary value of cosinus of the current angle. */
+ double cos;
+
+ /** The temporary value of sinus of the current angle. */
+ double sin;
+
+ /** The coefficient to calculate control points of Bezier curves. */
+ double k;
+
+ /** The temporary value of x coordinate of the Bezier curve control vector. */
+ double kx;
+
+ /** The temporary value of y coordinate of the Bezier curve control vector. */
+ double ky;
+
+ /** The x coordinate of the first path point (MOVE_TO). */
+ double mx;
+
+ /** The y coordinate of the first path point (MOVE_TO). */
+ double my;
+
+ /**
+ * Constructs a new Arc2D.Iterator for given line and transformation
+ *
+ * @param a - the source Arc2D object
+ * @param t the AffineTransformation.
+ */
+ Iterator(Arc2D a, AffineTransform t) {
+ if (width < 0 || height < 0) {
+ arcCount = 0;
+ lineCount = 0;
+ index = 1;
+ return;
+ }
+
+ this.width = a.getWidth() / 2.0;
+ this.height = a.getHeight() / 2.0;
+ this.x = a.getX() + width;
+ this.y = a.getY() + height;
+ this.angle = -Math.toRadians(a.getAngleStart());
+ this.extent = -a.getAngleExtent();
+ this.type = a.getArcType();
+ this.t = t;
+
+ if (Math.abs(extent) >= 360.0) {
+ arcCount = 4;
+ k = 4.0 / 3.0 * (Math.sqrt(2.0) - 1.0);
+ step = Math.PI / 2.0;
+ if (extent < 0.0) {
+ step = -step;
+ k = -k;
+ }
+ } else {
+ arcCount = (int)Math.rint(Math.abs(extent) / 90.0);
+ step = Math.toRadians(extent / arcCount);
+ k = 4.0 / 3.0 * (1.0 - Math.cos(step / 2.0))
+ / Math.sin(step / 2.0);
+ }
+
+ lineCount = 0;
+ if (type == Arc2D.CHORD) {
+ lineCount++;
+ } else if (type == Arc2D.PIE) {
+ lineCount += 2;
+ }
+ }
+
+ public int getWindingRule() {
+ return WIND_NON_ZERO;
+ }
+
+ public boolean isDone() {
+ return index > arcCount + lineCount;
+ }
+
+ public void next() {
+ index++;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type;
+ int count;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ count = 1;
+ cos = Math.cos(angle);
+ sin = Math.sin(angle);
+ kx = k * width * sin;
+ ky = k * height * cos;
+ coords[0] = mx = x + cos * width;
+ coords[1] = my = y + sin * height;
+ } else if (index <= arcCount) {
+ type = SEG_CUBICTO;
+ count = 3;
+ coords[0] = mx - kx;
+ coords[1] = my + ky;
+ angle += step;
+ cos = Math.cos(angle);
+ sin = Math.sin(angle);
+ kx = k * width * sin;
+ ky = k * height * cos;
+ coords[4] = mx = x + cos * width;
+ coords[5] = my = y + sin * height;
+ coords[2] = mx + kx;
+ coords[3] = my - ky;
+ } else if (index == arcCount + lineCount) {
+ type = SEG_CLOSE;
+ count = 0;
+ } else {
+ type = SEG_LINETO;
+ count = 1;
+ coords[0] = x;
+ coords[1] = y;
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count);
+ }
+ return type;
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type;
+ int count;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ count = 1;
+ cos = Math.cos(angle);
+ sin = Math.sin(angle);
+ kx = k * width * sin;
+ ky = k * height * cos;
+ coords[0] = (float)(mx = x + cos * width);
+ coords[1] = (float)(my = y + sin * height);
+ } else if (index <= arcCount) {
+ type = SEG_CUBICTO;
+ count = 3;
+ coords[0] = (float)(mx - kx);
+ coords[1] = (float)(my + ky);
+ angle += step;
+ cos = Math.cos(angle);
+ sin = Math.sin(angle);
+ kx = k * width * sin;
+ ky = k * height * cos;
+ coords[4] = (float)(mx = x + cos * width);
+ coords[5] = (float)(my = y + sin * height);
+ coords[2] = (float)(mx + kx);
+ coords[3] = (float)(my - ky);
+ } else if (index == arcCount + lineCount) {
+ type = SEG_CLOSE;
+ count = 0;
+ } else {
+ type = SEG_LINETO;
+ count = 1;
+ coords[0] = (float)x;
+ coords[1] = (float)y;
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count);
+ }
+ return type;
+ }
+
+ }
+
+ /** The closure type of the arc. */
+ private int type;
+
+ /**
+ * Instantiates a new arc2D.
+ *
+ * @param type the closure type.
+ */
+ protected Arc2D(int type) {
+ setArcType(type);
+ }
+
+ /**
+ * Takes the double-valued data and creates the corresponding Rectangle2D
+ * object with values either of type float or of type double depending on
+ * whether this Arc2D instance is of type Float or Double.
+ *
+ * @param x the x coordinate of the upper left corner of the bounding rectangle.
+ * @param y the y coordinate of the upper left corner of the bounding rectangle.
+ * @param width the width of the bounding rectangle.
+ * @param height the height of the bounding rectangle.
+ *
+ * @return the corresponding Rectangle2D object.
+ */
+ protected abstract Rectangle2D makeBounds(double x, double y, double width, double height);
+
+ /**
+ * Gets the start angle.
+ *
+ * @return the start angle.
+ */
+ public abstract double getAngleStart();
+
+ /**
+ * Gets the width angle.
+ *
+ * @return the width angle.
+ */
+ public abstract double getAngleExtent();
+
+ /**
+ * Sets the start angle.
+ *
+ * @param start the new start angle.
+ */
+ public abstract void setAngleStart(double start);
+
+ /**
+ * Sets the width angle.
+ *
+ * @param extent the new width angle.
+ */
+ public abstract void setAngleExtent(double extent);
+
+ /**
+ * Sets the data values that define the arc.
+ *
+ * @param x the x coordinate of the upper left corner of the rectangle that
+ * contains the arc.
+ * @param y the y coordinate of the upper left corner of the rectangle that
+ * contains the arc.
+ * @param width the width of the rectangle that
+ * contains the arc.
+ * @param height the height of the rectangle that
+ * contains the arc.
+ * @param start the start angle of the arc in degrees.
+ * @param extent the width angle of the arc in degrees.
+ * @param type the type of the new Arc2D, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public abstract void setArc(double x, double y, double width,
+ double height, double start, double extent, int type);
+
+ /**
+ * Gets the arc type, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ *
+ * @return the arc type.
+ */
+ public int getArcType() {
+ return type;
+ }
+
+ /**
+ * Sets the arc type, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ *
+ * @param type the new arc type.
+ */
+ public void setArcType(int type) {
+ if (type != OPEN && type != CHORD && type != PIE) {
+ // awt.205=Invalid type of Arc: {0}
+ throw new IllegalArgumentException(Messages.getString("awt.205", type)); //$NON-NLS-1$
+ }
+ this.type = type;
+ }
+
+ /**
+ * Gets the start point of the arc as a Point2D.
+ *
+ * @return the start point of the curved arc segment.
+ */
+ public Point2D getStartPoint() {
+ double a = Math.toRadians(getAngleStart());
+ return new Point2D.Double(
+ getX() + (1.0 + Math.cos(a)) * getWidth() / 2.0,
+ getY() + (1.0 - Math.sin(a)) * getHeight() / 2.0);
+ }
+
+ /**
+ * Gets the end point of the arc as a Point2D.
+ *
+ * @return the end point of the curved arc segment.
+ */
+ public Point2D getEndPoint() {
+ double a = Math.toRadians(getAngleStart() + getAngleExtent());
+ return new Point2D.Double(
+ getX() + (1.0 + Math.cos(a)) * getWidth() / 2.0,
+ getY() + (1.0 - Math.sin(a)) * getHeight() / 2.0);
+ }
+
+ public Rectangle2D getBounds2D() {
+ if (isEmpty()) {
+ return makeBounds(getX(), getY(), getWidth(), getHeight());
+ }
+ double rx1 = getX();
+ double ry1 = getY();
+ double rx2 = rx1 + getWidth();
+ double ry2 = ry1 + getHeight();
+
+ Point2D p1 = getStartPoint();
+ Point2D p2 = getEndPoint();
+
+ double bx1 = containsAngle(180.0) ? rx1 : Math.min(p1.getX(), p2.getX());
+ double by1 = containsAngle(90.0) ? ry1 : Math.min(p1.getY(), p2.getY());
+ double bx2 = containsAngle(0.0) ? rx2 : Math.max(p1.getX(), p2.getX());
+ double by2 = containsAngle(270.0) ? ry2 : Math.max(p1.getY(), p2.getY());
+
+ if (type == PIE) {
+ double cx = getCenterX();
+ double cy = getCenterY();
+ bx1 = Math.min(bx1, cx);
+ by1 = Math.min(by1, cy);
+ bx2 = Math.max(bx2, cx);
+ by2 = Math.max(by2, cy);
+ }
+ return makeBounds(bx1, by1, bx2 - bx1, by2 - by1);
+ }
+
+ @Override
+ public void setFrame(double x, double y, double width, double height) {
+ setArc(x, y, width, height, getAngleStart(), getAngleExtent(), type);
+ }
+
+ /**
+ * Sets the data that defines the arc.
+ *
+ * @param point the upper left corner of the bounding rectangle.
+ * @param size the size of the bounding rectangle.
+ * @param start the start angle of the arc in degrees.
+ * @param extent the angle witdth of the arc in degrees.
+ * @param type the closure type, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public void setArc(Point2D point, Dimension2D size, double start, double extent, int type) {
+ setArc(point.getX(), point.getY(), size.getWidth(), size.getHeight(), start, extent, type);
+ }
+
+ /**
+ * Sets the data that defines the arc.
+ *
+ * @param rect the arc's bounding rectangle.
+ * @param start the start angle of the arc in degrees.
+ * @param extent the angle witdth of the arc in degrees.
+ * @param type the closure type, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public void setArc(Rectangle2D rect, double start, double extent, int type) {
+ setArc(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight(), start, extent, type);
+ }
+
+ /**
+ * Sets the data that defines the arc by copying it from another Arc2D.
+ *
+ * @param arc the arc whose data is copied into this arc.
+ */
+ public void setArc(Arc2D arc) {
+ setArc(arc.getX(), arc.getY(), arc.getWidth(), arc.getHeight(), arc
+ .getAngleStart(), arc.getAngleExtent(), arc.getArcType());
+ }
+
+ /**
+ * Sets the data for a circular arc by giving its center and radius.
+ *
+ * @param x the x coordinate of the center of the circle.
+ * @param y the y coordinate of the center of the circle.
+ * @param radius the radius of the circle.
+ * @param start the start angle of the arc in degrees.
+ * @param extent the angle witdth of the arc in degrees.
+ * @param type the closure type, either {@link Arc2D#OPEN},
+ * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
+ */
+ public void setArcByCenter(double x, double y, double radius, double start, double extent, int type) {
+ setArc(x - radius, y - radius, radius * 2.0, radius * 2.0, start, extent, type);
+ }
+
+ /**
+ * Sets the arc data for a circular arc based on two tangent lines
+ * and the radius. The two tangent lines are the lines from p1
+ * to p2 and from p2 to p3, which determine a unique circle
+ * with the given radius. The start and end points of the arc
+ * are the points where the circle touches the two lines, and
+ * the arc itself is the shorter of the two circle segments
+ * determined by the two points (in other words, it is the
+ * piece of the circle that is closer to the lines' intersection
+ * point p2 and forms a concave shape with the segments from p1 to p2
+ * and from p2 to p3).
+ *
+ * @param p1 a point which determines one of the two tanget lines (with p2).
+ * @param p2 the point of intersection of the two tangent lines.
+ * @param p3 a point which determines one of the two tanget lines (with p2).
+ * @param radius the radius of the circular arc.
+ */
+ public void setArcByTangent(Point2D p1, Point2D p2, Point2D p3, double radius) {
+ // Used simple geometric calculations of arc center, radius and angles by tangents
+ double a1 = -Math.atan2(p1.getY() - p2.getY(), p1.getX() - p2.getX());
+ double a2 = -Math.atan2(p3.getY() - p2.getY(), p3.getX() - p2.getX());
+ double am = (a1 + a2) / 2.0;
+ double ah = a1 - am;
+ double d = radius / Math.abs(Math.sin(ah));
+ double x = p2.getX() + d * Math.cos(am);
+ double y = p2.getY() - d * Math.sin(am);
+ ah = ah >= 0.0 ? Math.PI * 1.5 - ah : Math.PI * 0.5 - ah;
+ a1 = getNormAngle(Math.toDegrees(am - ah));
+ a2 = getNormAngle(Math.toDegrees(am + ah));
+ double delta = a2 - a1;
+ if (delta <= 0.0) {
+ delta += 360.0;
+ }
+ setArcByCenter(x, y, radius, a1, delta, type);
+ }
+
+ /**
+ * Sets a new start angle to be the angle given by the the vector
+ * from the current center point to the specified point.
+ *
+ * @param point the point that determines the new start angle.
+ */
+ public void setAngleStart(Point2D point) {
+ double angle = Math.atan2(point.getY() - getCenterY(), point.getX() - getCenterX());
+ setAngleStart(getNormAngle(-Math.toDegrees(angle)));
+ }
+
+ /**
+ * Sets the angles in terms of vectors from the current arc center
+ * to the points (x1, y1) and (x2, y2). The start angle is given
+ * by the vector from the current center to the point (x1, y1) and
+ * the end angle is given by the vector from the center to the point
+ * (x2, y2).
+ *
+ * @param x1 the x coordinate of the point whose vector from the center
+ * point determines the new start angle of the arc.
+ * @param y1 the y coordinate of the point whose vector from the center
+ * point determines the new start angle of the arc.
+ * @param x2 the x coordinate of the point whose vector from the center
+ * point determines the new end angle of the arc.
+ * @param y2 the y coordinate of the point whose vector from the center
+ * point determines the new end angle of the arc.
+ */
+ public void setAngles(double x1, double y1, double x2, double y2) {
+ double cx = getCenterX();
+ double cy = getCenterY();
+ double a1 = getNormAngle(-Math.toDegrees(Math.atan2(y1 - cy, x1 - cx)));
+ double a2 = getNormAngle(-Math.toDegrees(Math.atan2(y2 - cy, x2 - cx)));
+ a2 -= a1;
+ if (a2 <= 0.0) {
+ a2 += 360.0;
+ }
+ setAngleStart(a1);
+ setAngleExtent(a2);
+ }
+
+ /**
+ * Sets the angles in terms of vectors from the current arc center
+ * to the points p1 and p2. The start angle is given
+ * by the vector from the current center to the point p1 and
+ * the end angle is given by the vector from the center to the point
+ * p2.
+ *
+ * @param p1 the point whose vector from the center
+ * point determines the new start angle of the arc.
+ * @param p2 the point whose vector from the center
+ * point determines the new end angle of the arc.
+ */
+ public void setAngles(Point2D p1, Point2D p2) {
+ setAngles(p1.getX(), p1.getY(), p2.getX(), p2.getY());
+ }
+
+ /**
+ * Normalizes the angle by removing extra winding (past 360 degrees)
+ * and placing it in the positive degree range.
+ *
+ * @param angle - the source angle in degrees
+ *
+ * @return an angle between 0 and 360 degrees which corresponds
+ * to the same direction vector as the source angle.
+ */
+ double getNormAngle(double angle) {
+ double n = Math.floor(angle / 360.0);
+ return angle - n * 360.0;
+ }
+
+ /**
+ * Determines whether the given angle is contained in the span of the arc.
+ *
+ * @param angle the angle to test in degrees.
+ *
+ * @return true, if the given angle is between the start angle and
+ * the end angle of the arc.
+ */
+ public boolean containsAngle(double angle) {
+ double extent = getAngleExtent();
+ if (extent >= 360.0) {
+ return true;
+ }
+ angle = getNormAngle(angle);
+ double a1 = getNormAngle(getAngleStart());
+ double a2 = a1 + extent;
+ if (a2 > 360.0) {
+ return angle >= a1 || angle <= a2 - 360.0;
+ }
+ if (a2 < 0.0) {
+ return angle >= a2 + 360.0 || angle <= a1;
+ }
+ return extent > 0.0 ? a1 <= angle && angle <= a2 : a2 <= angle
+ && angle <= a1;
+ }
+
+ public boolean contains(double px, double py) {
+ // Normalize point
+ double nx = (px - getX()) / getWidth() - 0.5;
+ double ny = (py - getY()) / getHeight() - 0.5;
+
+ if ((nx * nx + ny * ny) > 0.25) {
+ return false;
+ }
+
+ double extent = getAngleExtent();
+ double absExtent = Math.abs(extent);
+ if (absExtent >= 360.0) {
+ return true;
+ }
+
+ boolean containsAngle = containsAngle(Math.toDegrees(-Math
+ .atan2(ny, nx)));
+ if (type == PIE) {
+ return containsAngle;
+ }
+ if (absExtent <= 180.0 && !containsAngle) {
+ return false;
+ }
+
+ Line2D l = new Line2D.Double(getStartPoint(), getEndPoint());
+ int ccw1 = l.relativeCCW(px, py);
+ int ccw2 = l.relativeCCW(getCenterX(), getCenterY());
+ return ccw1 == 0 || ccw2 == 0
+ || ((ccw1 + ccw2) == 0 ^ absExtent > 180.0);
+ }
+
+ public boolean contains(double rx, double ry, double rw, double rh) {
+
+ if (!(contains(rx, ry) && contains(rx + rw, ry)
+ && contains(rx + rw, ry + rh) && contains(rx, ry + rh))) {
+ return false;
+ }
+
+ double absExtent = Math.abs(getAngleExtent());
+ if (type != PIE || absExtent <= 180.0 || absExtent >= 360.0) {
+ return true;
+ }
+
+ Rectangle2D r = new Rectangle2D.Double(rx, ry, rw, rh);
+
+ double cx = getCenterX();
+ double cy = getCenterY();
+ if (r.contains(cx, cy)) {
+ return false;
+ }
+
+ Point2D p1 = getStartPoint();
+ Point2D p2 = getEndPoint();
+
+ return !r.intersectsLine(cx, cy, p1.getX(), p1.getY())
+ && !r.intersectsLine(cx, cy, p2.getX(), p2.getY());
+ }
+
+ @Override
+ public boolean contains(Rectangle2D rect) {
+ return contains(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
+ }
+
+ public boolean intersects(double rx, double ry, double rw, double rh) {
+
+ if (isEmpty() || rw <= 0.0 || rh <= 0.0) {
+ return false;
+ }
+
+ // Check: Does arc contain rectangle's points
+ if (contains(rx, ry) || contains(rx + rw, ry) || contains(rx, ry + rh)
+ || contains(rx + rw, ry + rh)) {
+ return true;
+ }
+
+ double cx = getCenterX();
+ double cy = getCenterY();
+ Point2D p1 = getStartPoint();
+ Point2D p2 = getEndPoint();
+ Rectangle2D r = new Rectangle2D.Double(rx, ry, rw, rh);
+
+ // Check: Does rectangle contain arc's points
+ if (r.contains(p1) || r.contains(p2) || (type == PIE && r.contains(cx, cy))) {
+ return true;
+ }
+
+ if (type == PIE) {
+ if (r.intersectsLine(p1.getX(), p1.getY(), cx, cy) ||
+ r.intersectsLine(p2.getX(), p2.getY(), cx, cy))
+ {
+ return true;
+ }
+ } else {
+ if (r.intersectsLine(p1.getX(), p1.getY(), p2.getX(), p2.getY())) {
+ return true;
+ }
+ }
+
+ // Nearest rectangle point
+ double nx = cx < rx ? rx : (cx > rx + rw ? rx + rw : cx);
+ double ny = cy < ry ? ry : (cy > ry + rh ? ry + rh : cy);
+ return contains(nx, ny);
+ }
+
+ public PathIterator getPathIterator(AffineTransform at) {
+ return new Iterator(this, at);
+ }
+
+}
+
diff --git a/awt/java/awt/geom/Area.java b/awt/java/awt/geom/Area.java
new file mode 100644
index 0000000..bc27d4e
--- /dev/null
+++ b/awt/java/awt/geom/Area.java
@@ -0,0 +1,317 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.geom.PathIterator;
+import java.awt.geom.Rectangle2D;
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class Area provides a minimal implementation for a generic shape.
+ */
+public class Area implements Shape, Cloneable {
+
+ /** The source Shape object. */
+ Shape s;
+
+ /**
+ * The Class NullIterator.
+ */
+ private static class NullIterator implements PathIterator {
+
+ /**
+ * Instantiates a new null iterator.
+ */
+ NullIterator() {
+ }
+
+ public int getWindingRule() {
+ return WIND_NON_ZERO;
+ }
+
+ public boolean isDone() {
+ return true;
+ }
+
+ public void next() {
+ // nothing
+ }
+
+ public int currentSegment(double[] coords) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+
+ public int currentSegment(float[] coords) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+
+ }
+
+ /**
+ * Instantiates a new area with no data.
+ */
+ public Area() {
+ }
+
+ /**
+ * Instantiates a new area with data given by the specified shape.
+ *
+ * @param s the shape that gives the data for this Area
+ */
+ public Area(Shape s) {
+ if (s == null) {
+ throw new NullPointerException();
+ }
+ this.s = s;
+ }
+
+ public boolean contains(double x, double y) {
+ return s == null ? false : s.contains(x, y);
+ }
+
+ public boolean contains(double x, double y, double width, double height) {
+ return s == null ? false : s.contains(x, y, width, height);
+ }
+
+ public boolean contains(Point2D p) {
+ if (p == null) {
+ throw new NullPointerException();
+ }
+ return s == null ? false : s.contains(p);
+ }
+
+ public boolean contains(Rectangle2D r) {
+ if (r == null) {
+ throw new NullPointerException();
+ }
+ return s == null ? false : s.contains(r);
+ }
+
+ /**
+ * Tests whether the object is equal to this Area.
+ *
+ * @param obj the object to compare
+ *
+ * @return true, if successful
+ *
+ * @throws NotImplementedException if this method is not implemented
+ */
+ public boolean equals(Area obj) throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+ }
+
+ public boolean intersects(double x, double y, double width, double height) {
+ return s == null ? false : s.intersects(x, y, width, height);
+ }
+
+ public boolean intersects(Rectangle2D r) {
+ if (r == null) {
+ throw new NullPointerException();
+ }
+ return s == null ? false : s.intersects(r);
+ }
+
+ public Rectangle getBounds() {
+ return s == null ? new Rectangle() : s.getBounds();
+ }
+
+ public Rectangle2D getBounds2D() {
+ return s == null ? new Rectangle2D.Double(): s.getBounds2D();
+ }
+
+ public PathIterator getPathIterator(AffineTransform t) {
+ return s == null ? new NullIterator() : s.getPathIterator(t);
+ }
+
+ public PathIterator getPathIterator(AffineTransform t, double flatness) {
+ return s == null ? new NullIterator() : s.getPathIterator(t, flatness);
+ }
+
+ /**
+ * Adds the specified area to this area.
+ *
+ * @param area the area to add to this area
+ *
+ * @throws NotImplementedException if this method is not implemented
+ */
+ public void add(Area area) throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+ }
+
+ /**
+ * Performs an exclusive or operation between this shape and the
+ * specified shape.
+ *
+ * @param area the area to XOR against this area
+ *
+ * @throws NotImplementedException if this method is not implemented
+ */
+ public void exclusiveOr(Area area) throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+ }
+
+ /**
+ * Extracts a Rectangle2D from the source shape if the underlying shape
+ * data describes a rectangle.
+ *
+ * @return a Rectangle2D object if the source shape is rectangle,
+ * or null if shape is empty or not rectangle.
+ */
+ Rectangle2D extractRectangle() {
+ if (s == null) {
+ return null;
+ }
+ float[] points = new float[12];
+ int count = 0;
+ PathIterator p = s.getPathIterator(null);
+ float[] coords = new float[6];
+ while(!p.isDone()) {
+ int type = p.currentSegment(coords);
+ if (count > 12 || type == PathIterator.SEG_QUADTO || type == PathIterator.SEG_CUBICTO) {
+ return null;
+ }
+ points[count++] = coords[0];
+ points[count++] = coords[1];
+ p.next();
+ }
+ if (points[0] == points[6] && points[6] == points[8] && points[2] == points[4] &&
+ points[1] == points[3] && points[3] == points[9] && points[5] == points[7])
+ {
+ return new Rectangle2D.Float(points[0], points[1], points[2] - points[0], points[7] - points[1]);
+ }
+ return null;
+ }
+
+ /**
+ * Reduces the size of this Area by intersecting it with the
+ * specified Area if they are both rectangles.
+ *
+ * @see java.awt.geom.Rectangle2D#intersect(Rectangle2D, Rectangle2D, Rectangle2D)
+ *
+ * @param area the area
+ */
+ public void intersect(Area area) {
+ Rectangle2D src1 = extractRectangle();
+ Rectangle2D src2 = area.extractRectangle();
+ if (src1 != null && src2 != null) {
+ Rectangle2D.intersect(src1, src2, (Rectangle2D)s);
+ }
+ }
+
+ /**
+ * Subtract the specified area from this area.
+ *
+ * @param area the area to subtract
+ *
+ * @throws NotImplementedException if this method is not implemented
+ */
+ public void subtract(Area area) throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+ }
+
+ /**
+ * Checks if this Area is empty.
+ *
+ * @return true, if this Area is empty
+ *
+ * @throws NotImplementedException if this method is not implemented
+ */
+ public boolean isEmpty() throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+ }
+
+ /**
+ * Checks if this Area is polygonal.
+ *
+ * @return true, if this Area is polygonal
+ *
+ * @throws NotImplementedException if this method is not implemented
+ */
+ public boolean isPolygonal() throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+ }
+
+ /**
+ * Checks if this Area is rectangular.
+ *
+ * @return true, if this Area is rectangular
+ *
+ * @throws NotImplementedException if this method is not implemented
+ */
+ public boolean isRectangular() throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+ }
+
+ /**
+ * Checks if this Area is singular.
+ *
+ * @return true, if this Area is singular
+ *
+ * @throws NotImplementedException if this method is not implemented
+ */
+ public boolean isSingular() throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+ }
+
+ /**
+ * Resets the data of this Area.
+ *
+ * @throws NotImplementedException if this method is not implemented
+ */
+ public void reset() throws org.apache.harmony.luni.util.NotImplementedException {
+ throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+ }
+
+ /**
+ * Transforms the data of this Area according to the specified
+ * AffineTransform.
+ *
+ * @param t the transform to use to transform the data
+ */
+ public void transform(AffineTransform t) {
+ s = t.createTransformedShape(s);
+ }
+
+ /**
+ * Creates a new Area that is the result of transforming the data
+ * of this Area according to the specified AffineTransform.
+ *
+ * @param t the transform to use to transform the data
+ *
+ * @return the new Area that is the result of transforming the data
+ * of this Area according to the specified AffineTransform.
+ */
+ public Area createTransformedArea(AffineTransform t) {
+ return s == null ? new Area() : new Area(t.createTransformedShape(s));
+ }
+
+ @Override
+ public Object clone() {
+ return new Area(this);
+ }
+
+}
diff --git a/awt/java/awt/geom/CubicCurve2D.java b/awt/java/awt/geom/CubicCurve2D.java
new file mode 100644
index 0000000..3e440c8
--- /dev/null
+++ b/awt/java/awt/geom/CubicCurve2D.java
@@ -0,0 +1,945 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.gl.Crossing;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class CubicCurve2D is a Shape that represents a segment of a
+ * quadratic (Bezier) curve. The curved segment is determined by four points:
+ * a start point, an end point, and two control points.
+ * The control points give information about the tangent and next
+ * derivative at the endpoints according to the standard theory of
+ * Bezier curves. For more information on Bezier curves,
+ * see <a href="http://en.wikipedia.org/wiki/B%C3%A9zier_curve">this article</a>.
+ */
+public abstract class CubicCurve2D implements Shape, Cloneable {
+
+ /**
+ * The Class Float is the subclass of CubicCurve2D that has all
+ * of its data values stored with float-level precision.
+ */
+ public static class Float extends CubicCurve2D {
+
+ /** The x coordinate of the starting point. */
+ public float x1;
+
+ /** The y coordinate of the starting point. */
+ public float y1;
+
+ /** The x coordinate of the first control point. */
+ public float ctrlx1;
+
+ /** The y coordinate of the first control point. */
+ public float ctrly1;
+
+ /** The x coordinate of the second control point. */
+ public float ctrlx2;
+
+ /** The y coordinate of the second control point. */
+ public float ctrly2;
+
+ /** The x coordinate of the end point. */
+ public float x2;
+
+ /** The y coordinate of the end point. */
+ public float y2;
+
+ /**
+ * Instantiates a new float-valued CubicCurve2D with all coordinate values
+ * set to zero.
+ */
+ public Float() {
+ }
+
+ /**
+ * Instantiates a new float-valued CubicCurve2D with the specified
+ * coordinate values.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param ctrlx1 the x coordinate of the first control point
+ * @param ctrly1 the y coordinate of the first control point
+ * @param ctrlx2 the x coordinate of the second control point
+ * @param ctrly2 the y coordinate of the second control point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ */
+ public Float(float x1, float y1, float ctrlx1, float ctrly1, float ctrlx2, float ctrly2, float x2, float y2) {
+ setCurve(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2);
+ }
+
+ @Override
+ public double getX1() {
+ return x1;
+ }
+
+ @Override
+ public double getY1() {
+ return y1;
+ }
+
+ @Override
+ public double getCtrlX1() {
+ return ctrlx1;
+ }
+
+ @Override
+ public double getCtrlY1() {
+ return ctrly1;
+ }
+
+ @Override
+ public double getCtrlX2() {
+ return ctrlx2;
+ }
+
+ @Override
+ public double getCtrlY2() {
+ return ctrly2;
+ }
+
+ @Override
+ public double getX2() {
+ return x2;
+ }
+
+ @Override
+ public double getY2() {
+ return y2;
+ }
+
+ @Override
+ public Point2D getP1() {
+ return new Point2D.Float(x1, y1);
+ }
+
+ @Override
+ public Point2D getCtrlP1() {
+ return new Point2D.Float(ctrlx1, ctrly1);
+ }
+
+ @Override
+ public Point2D getCtrlP2() {
+ return new Point2D.Float(ctrlx2, ctrly2);
+ }
+
+ @Override
+ public Point2D getP2() {
+ return new Point2D.Float(x2, y2);
+ }
+
+ @Override
+ public void setCurve(double x1, double y1, double ctrlx1, double ctrly1,
+ double ctrlx2, double ctrly2, double x2, double y2)
+ {
+ this.x1 = (float)x1;
+ this.y1 = (float)y1;
+ this.ctrlx1 = (float)ctrlx1;
+ this.ctrly1 = (float)ctrly1;
+ this.ctrlx2 = (float)ctrlx2;
+ this.ctrly2 = (float)ctrly2;
+ this.x2 = (float)x2;
+ this.y2 = (float)y2;
+ }
+
+ /**
+ * Sets the data values of the curve.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param ctrlx1 the x coordinate of the first control point
+ * @param ctrly1 the y coordinate of the first control point
+ * @param ctrlx2 the x coordinate of the second control point
+ * @param ctrly2 the y coordinate of the second control point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ */
+ public void setCurve(float x1, float y1, float ctrlx1, float ctrly1,
+ float ctrlx2, float ctrly2, float x2, float y2)
+ {
+ this.x1 = x1;
+ this.y1 = y1;
+ this.ctrlx1 = ctrlx1;
+ this.ctrly1 = ctrly1;
+ this.ctrlx2 = ctrlx2;
+ this.ctrly2 = ctrly2;
+ this.x2 = x2;
+ this.y2 = y2;
+ }
+
+ public Rectangle2D getBounds2D() {
+ float rx1 = Math.min(Math.min(x1, x2), Math.min(ctrlx1, ctrlx2));
+ float ry1 = Math.min(Math.min(y1, y2), Math.min(ctrly1, ctrly2));
+ float rx2 = Math.max(Math.max(x1, x2), Math.max(ctrlx1, ctrlx2));
+ float ry2 = Math.max(Math.max(y1, y2), Math.max(ctrly1, ctrly2));
+ return new Rectangle2D.Float(rx1, ry1, rx2 - rx1, ry2 - ry1);
+ }
+ }
+
+ /**
+ * The Class Double is the subclass of CubicCurve2D that has all
+ * of its data values stored with double-level precision.
+ */
+ public static class Double extends CubicCurve2D {
+
+ /** The x coordinate of the starting point. */
+ public double x1;
+
+ /** The y coordinate of the starting point. */
+ public double y1;
+
+ /** The x coordinate of the first control point. */
+ public double ctrlx1;
+
+ /** The y coordinate of the first control point. */
+ public double ctrly1;
+
+ /** The x coordinate of the second control point. */
+ public double ctrlx2;
+
+ /** The y coordinate of the second control point. */
+ public double ctrly2;
+
+ /** The x coordinate of the end point. */
+ public double x2;
+
+ /** The y coordinate of the end point. */
+ public double y2;
+
+ /**
+ * Instantiates a new double-valued CubicCurve2D with all coordinate values
+ * set to zero.
+ */
+ public Double() {
+ }
+
+ /**
+ * Instantiates a new double-valued CubicCurve2D with the specified
+ * coordinate values.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param ctrlx1 the x coordinate of the first control point
+ * @param ctrly1 the y coordinate of the first control point
+ * @param ctrlx2 the x coordinate of the second control point
+ * @param ctrly2 the y coordinate of the second control point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ */
+ public Double(double x1, double y1, double ctrlx1, double ctrly1,
+ double ctrlx2, double ctrly2, double x2, double y2) {
+ setCurve(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2);
+ }
+
+ @Override
+ public double getX1() {
+ return x1;
+ }
+
+ @Override
+ public double getY1() {
+ return y1;
+ }
+
+ @Override
+ public double getCtrlX1() {
+ return ctrlx1;
+ }
+
+ @Override
+ public double getCtrlY1() {
+ return ctrly1;
+ }
+
+ @Override
+ public double getCtrlX2() {
+ return ctrlx2;
+ }
+
+ @Override
+ public double getCtrlY2() {
+ return ctrly2;
+ }
+
+ @Override
+ public double getX2() {
+ return x2;
+ }
+
+ @Override
+ public double getY2() {
+ return y2;
+ }
+
+ @Override
+ public Point2D getP1() {
+ return new Point2D.Double(x1, y1);
+ }
+
+ @Override
+ public Point2D getCtrlP1() {
+ return new Point2D.Double(ctrlx1, ctrly1);
+ }
+
+ @Override
+ public Point2D getCtrlP2() {
+ return new Point2D.Double(ctrlx2, ctrly2);
+ }
+
+ @Override
+ public Point2D getP2() {
+ return new Point2D.Double(x2, y2);
+ }
+
+ @Override
+ public void setCurve(double x1, double y1, double ctrlx1, double ctrly1,
+ double ctrlx2, double ctrly2, double x2, double y2)
+ {
+ this.x1 = x1;
+ this.y1 = y1;
+ this.ctrlx1 = ctrlx1;
+ this.ctrly1 = ctrly1;
+ this.ctrlx2 = ctrlx2;
+ this.ctrly2 = ctrly2;
+ this.x2 = x2;
+ this.y2 = y2;
+ }
+
+ public Rectangle2D getBounds2D() {
+ double rx1 = Math.min(Math.min(x1, x2), Math.min(ctrlx1, ctrlx2));
+ double ry1 = Math.min(Math.min(y1, y2), Math.min(ctrly1, ctrly2));
+ double rx2 = Math.max(Math.max(x1, x2), Math.max(ctrlx1, ctrlx2));
+ double ry2 = Math.max(Math.max(y1, y2), Math.max(ctrly1, ctrly2));
+ return new Rectangle2D.Double(rx1, ry1, rx2 - rx1, ry2 - ry1);
+ }
+ }
+
+ /*
+ * CubicCurve2D path iterator
+ */
+ /**
+ * The Iterator class for the Shape CubicCurve2D.
+ */
+ class Iterator implements PathIterator {
+
+ /** The source CubicCurve2D object. */
+ CubicCurve2D c;
+
+ /** The path iterator transformation. */
+ AffineTransform t;
+
+ /** The current segmenet index. */
+ int index;
+
+ /**
+ * Constructs a new CubicCurve2D.Iterator for given line and transformation
+ *
+ * @param c - the source CubicCurve2D object
+ * @param t the t
+ */
+ Iterator(CubicCurve2D c, AffineTransform t) {
+ this.c = c;
+ this.t = t;
+ }
+
+ public int getWindingRule() {
+ return WIND_NON_ZERO;
+ }
+
+ public boolean isDone() {
+ return index > 1;
+ }
+
+ public void next() {
+ index++;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type;
+ int count;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ coords[0] = c.getX1();
+ coords[1] = c.getY1();
+ count = 1;
+ } else {
+ type = SEG_CUBICTO;
+ coords[0] = c.getCtrlX1();
+ coords[1] = c.getCtrlY1();
+ coords[2] = c.getCtrlX2();
+ coords[3] = c.getCtrlY2();
+ coords[4] = c.getX2();
+ coords[5] = c.getY2();
+ count = 3;
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count);
+ }
+ return type;
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type;
+ int count;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ coords[0] = (float)c.getX1();
+ coords[1] = (float)c.getY1();
+ count = 1;
+ } else {
+ type = SEG_CUBICTO;
+ coords[0] = (float)c.getCtrlX1();
+ coords[1] = (float)c.getCtrlY1();
+ coords[2] = (float)c.getCtrlX2();
+ coords[3] = (float)c.getCtrlY2();
+ coords[4] = (float)c.getX2();
+ coords[5] = (float)c.getY2();
+ count = 3;
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count);
+ }
+ return type;
+ }
+
+ }
+
+ /**
+ * Instantiates a new 2-D cubic curve.
+ */
+ protected CubicCurve2D() {
+ }
+
+ /**
+ * Gets the x coordinate of the starting point.
+ *
+ * @return the x coordinate of the starting point
+ */
+ public abstract double getX1();
+
+ /**
+ * Gets the y coordinate of the starting point.
+ *
+ * @return the y coordinate of the starting point
+ */
+ public abstract double getY1();
+
+ /**
+ * Gets the starting point.
+ *
+ * @return the starting point
+ */
+ public abstract Point2D getP1();
+
+ /**
+ * Gets the x coordinate of the first control point.
+ *
+ * @return the x coordinate of the first control point
+ */
+ public abstract double getCtrlX1();
+
+ /**
+ * Gets the y coordinate of the first control point.
+ *
+ * @return the y coordinate of the first control point
+ */
+ public abstract double getCtrlY1();
+
+ /**
+ * Gets the second control point.
+ *
+ * @return the second control point
+ */
+ public abstract Point2D getCtrlP1();
+
+ /**
+ * Gets the x coordinate of the second control point.
+ *
+ * @return the x coordinate of the second control point
+ */
+ public abstract double getCtrlX2();
+
+ /**
+ * Gets the y coordinate of the second control point.
+ *
+ * @return the y coordinate of the second control point
+ */
+ public abstract double getCtrlY2();
+
+ /**
+ * Gets the second control point.
+ *
+ * @return the second control point
+ */
+ public abstract Point2D getCtrlP2();
+
+ /**
+ * Gets the x coordinate of the end point.
+ *
+ * @return the x coordinate of the end point
+ */
+ public abstract double getX2();
+
+ /**
+ * Gets the y coordinate of the end point.
+ *
+ * @return the y coordinate of the end point
+ */
+ public abstract double getY2();
+
+ /**
+ * Gets the end point.
+ *
+ * @return the end point
+ */
+ public abstract Point2D getP2();
+
+ /**
+ * Sets the data of the curve.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param ctrlx1 the x coordinate of the first control point
+ * @param ctrly1 the y coordinate of the first control point
+ * @param ctrlx2 the x coordinate of the second control point
+ * @param ctrly2 the y coordinate of the second control point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ */
+ public abstract void setCurve(double x1, double y1, double ctrlx1, double ctrly1,
+ double ctrlx2, double ctrly2, double x2, double y2);
+
+ /**
+ * Sets the data of the curve as point objects.
+ *
+ * @param p1 the starting point
+ * @param cp1 the first control point
+ * @param cp2 the second control point
+ * @param p2 the end point
+ *
+ * @throws NullPointerException if any of the points is null.
+ */
+ public void setCurve(Point2D p1, Point2D cp1, Point2D cp2, Point2D p2) {
+ setCurve(
+ p1.getX(), p1.getY(),
+ cp1.getX(), cp1.getY(),
+ cp2.getX(), cp2.getY(),
+ p2.getX(), p2.getY());
+ }
+
+ /**
+ * Sets the data of the curve by reading the data from an array
+ * of values. The values are read in the same order as the arguments
+ * of the method {@link CubicCurve2D#setCurve(double, double, double, double, double, double, double, double)}.
+ *
+ * @param coords the array of values containing the new coordinates
+ * @param offset the offset of the data to read within the array
+ *
+ * @throws ArrayIndexOutOfBoundsException if coords.length < offset + 8.
+ * @throws NullPointerException if the coordinate array is null.
+ */
+ public void setCurve(double[] coords, int offset) {
+ setCurve(
+ coords[offset + 0], coords[offset + 1],
+ coords[offset + 2], coords[offset + 3],
+ coords[offset + 4], coords[offset + 5],
+ coords[offset + 6], coords[offset + 7]);
+ }
+
+ /**
+ * Sets the data of the curve by reading the data from an array
+ * of points. The values are read in the same order as the arguments
+ * of the method {@link CubicCurve2D#setCurve(Point2D, Point2D, Point2D, Point2D)}
+ *
+ * @param points the array of points containing the new coordinates
+ * @param offset the offset of the data to read within the array
+ *
+ * @throws ArrayIndexOutOfBoundsException if points.length < offset + .
+ * @throws NullPointerException if the point array is null.
+ */
+ public void setCurve(Point2D[] points, int offset) {
+ setCurve(
+ points[offset + 0].getX(), points[offset + 0].getY(),
+ points[offset + 1].getX(), points[offset + 1].getY(),
+ points[offset + 2].getX(), points[offset + 2].getY(),
+ points[offset + 3].getX(), points[offset + 3].getY());
+ }
+
+ /**
+ * Sets the data of the curve by copying it from another CubicCurve2D.
+ *
+ * @param curve the curve to copy the data points from
+ *
+ * @throws NullPointerException if the curve is null.
+ */
+ public void setCurve(CubicCurve2D curve) {
+ setCurve(
+ curve.getX1(), curve.getY1(),
+ curve.getCtrlX1(), curve.getCtrlY1(),
+ curve.getCtrlX2(), curve.getCtrlY2(),
+ curve.getX2(), curve.getY2());
+ }
+
+ /**
+ * Gets the square of the flatness of this curve, where the flatness is the
+ * maximum distance from the curves control points to the
+ * line segment connecting the two points.
+ *
+ * @return the square of the flatness
+ */
+ public double getFlatnessSq() {
+ return getFlatnessSq(
+ getX1(), getY1(),
+ getCtrlX1(), getCtrlY1(),
+ getCtrlX2(), getCtrlY2(),
+ getX2(), getY2());
+ }
+
+ /**
+ * Gets the square of the flatness of the cubic curve segment
+ * defined by the specified values.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param ctrlx1 the x coordinate of the first control point
+ * @param ctrly1 the y coordinate of the first control point
+ * @param ctrlx2 the x coordinate of the second control point
+ * @param ctrly2 the y coordinate of the second control point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ *
+ * @return the square of the flatness
+ */
+ public static double getFlatnessSq(double x1, double y1, double ctrlx1, double ctrly1,
+ double ctrlx2, double ctrly2, double x2, double y2)
+ {
+ return Math.max(
+ Line2D.ptSegDistSq(x1, y1, x2, y2, ctrlx1, ctrly1),
+ Line2D.ptSegDistSq(x1, y1, x2, y2, ctrlx2, ctrly2));
+ }
+
+ /**
+ * Gets the square of the flatness of the cubic curve segment
+ * defined by the specified values. The values are read in the same order as the arguments
+ * of the method {@link CubicCurve2D#getFlatnessSq(double, double, double, double, double, double, double, double)}.
+ *
+ * @param coords the array of points containing the new coordinates
+ * @param offset the offset of the data to read within the array
+ *
+ * @return the square of the flatness
+ *
+ * @throws ArrayIndexOutOfBoundsException if points.length < offset + .
+ * @throws NullPointerException if the point array is null.
+ */
+ public static double getFlatnessSq(double coords[], int offset) {
+ return getFlatnessSq(
+ coords[offset + 0], coords[offset + 1],
+ coords[offset + 2], coords[offset + 3],
+ coords[offset + 4], coords[offset + 5],
+ coords[offset + 6], coords[offset + 7]);
+ }
+
+ /**
+ * Gets the flatness of this curve, where the flatness is the
+ * maximum distance from the curves control points to the
+ * line segment connecting the two points.
+ *
+ * @return the flatness of this curve
+ */
+ public double getFlatness() {
+ return getFlatness(
+ getX1(), getY1(),
+ getCtrlX1(), getCtrlY1(),
+ getCtrlX2(), getCtrlY2(),
+ getX2(), getY2());
+ }
+
+ /**
+ * Gets the flatness of the cubic curve segment
+ * defined by the specified values.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param ctrlx1 the x coordinate of the first control point
+ * @param ctrly1 the y coordinate of the first control point
+ * @param ctrlx2 the x coordinate of the second control point
+ * @param ctrly2 the y coordinate of the second control point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ *
+ * @return the flatness
+ */
+ public static double getFlatness(double x1, double y1, double ctrlx1, double ctrly1,
+ double ctrlx2, double ctrly2, double x2, double y2)
+ {
+ return Math.sqrt(getFlatnessSq(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2));
+ }
+
+ /**
+ * Gets the flatness of the cubic curve segment
+ * defined by the specified values. The values are read in the same order as the arguments
+ * of the method {@link CubicCurve2D#getFlatness(double, double, double, double, double, double, double, double)}.
+ *
+ * @param coords the array of points containing the new coordinates
+ * @param offset the offset of the data to read within the array
+ *
+ * @return the flatness
+ *
+ * @throws ArrayIndexOutOfBoundsException if points.length < offset + .
+ * @throws NullPointerException if the point array is null.
+ */
+ public static double getFlatness(double coords[], int offset) {
+ return getFlatness(
+ coords[offset + 0], coords[offset + 1],
+ coords[offset + 2], coords[offset + 3],
+ coords[offset + 4], coords[offset + 5],
+ coords[offset + 6], coords[offset + 7]);
+ }
+
+ /**
+ * Creates the data for two cubic curves by dividing this
+ * curve in two. The division point is the point on the curve
+ * that is closest to the average of curve's two control points.
+ * The two new control points (nearest the new endpoint) are computed
+ * by averaging the original control points with the new endpoint.
+ * The data of this curve is left unchanged.
+ *
+ * @param left the CubicCurve2D where the left (start) segment's
+ * data is written
+ * @param right the CubicCurve2D where the right (end) segment's
+ * data is written
+ *
+ * @throws NullPointerException if either curve is null.
+ */
+ public void subdivide(CubicCurve2D left, CubicCurve2D right) {
+ subdivide(this, left, right);
+ }
+
+ /**
+ * Creates the data for two cubic curves by dividing the specified
+ * curve in two. The division point is the point on the curve
+ * that is closest to the average of curve's two control points.
+ * The two new control points (nearest the new endpoint) are computed
+ * by averaging the original control points with the new endpoint.
+ * The data of the source curve is left unchanged.
+ *
+ * @param src the original curve to be divided in two
+ * @param left the CubicCurve2D where the left (start) segment's
+ * data is written
+ * @param right the CubicCurve2D where the right (end) segment's
+ * data is written
+ *
+ * @throws NullPointerException if either curve is null.
+ */
+ public static void subdivide(CubicCurve2D src, CubicCurve2D left, CubicCurve2D right) {
+ double x1 = src.getX1();
+ double y1 = src.getY1();
+ double cx1 = src.getCtrlX1();
+ double cy1 = src.getCtrlY1();
+ double cx2 = src.getCtrlX2();
+ double cy2 = src.getCtrlY2();
+ double x2 = src.getX2();
+ double y2 = src.getY2();
+ double cx = (cx1 + cx2) / 2.0;
+ double cy = (cy1 + cy2) / 2.0;
+ cx1 = (x1 + cx1) / 2.0;
+ cy1 = (y1 + cy1) / 2.0;
+ cx2 = (x2 + cx2) / 2.0;
+ cy2 = (y2 + cy2) / 2.0;
+ double ax = (cx1 + cx) / 2.0;
+ double ay = (cy1 + cy) / 2.0;
+ double bx = (cx2 + cx) / 2.0;
+ double by = (cy2 + cy) / 2.0;
+ cx = (ax + bx) / 2.0;
+ cy = (ay + by) / 2.0;
+ if (left != null) {
+ left.setCurve(x1, y1, cx1, cy1, ax, ay, cx, cy);
+ }
+ if (right != null) {
+ right.setCurve(cx, cy, bx, by, cx2, cy2, x2, y2);
+ }
+ }
+
+ /**
+ * Creates the data for two cubic curves by dividing the specified
+ * curve in two. The division point is the point on the curve
+ * that is closest to the average of curve's two control points.
+ * The two new control points (nearest the new endpoint) are computed
+ * by averaging the original control points with the new endpoint.
+ * The data of the source curve is left unchanged. The data for the
+ * three curves is read/written in the usual order: { x1, y1,
+ * ctrlx1, ctrly1, ctrlx2, crtry2, x2, y3 }
+ *
+ * @param src the array that gives the data values for the source curve
+ * @param srcOff the offset in the src array to read the values from
+ * @param left the array where the coordinates of the start curve should be written
+ * @param leftOff the offset in the left array to start writing the values
+ * @param right the array where the coordinates of the end curve should be written
+ * @param rightOff the offset in the right array to start writing the values
+ *
+ * @throws ArrayIndexOutOfBoundsException if src.length < srcoff + 8
+ * or if left.length < leftOff + 8 or if right.length < rightOff + 8.
+ * @throws NullPointerException if one of the arrays is null.
+ */
+ public static void subdivide(double src[], int srcOff, double left[], int leftOff, double right[], int rightOff) {
+ double x1 = src[srcOff + 0];
+ double y1 = src[srcOff + 1];
+ double cx1 = src[srcOff + 2];
+ double cy1 = src[srcOff + 3];
+ double cx2 = src[srcOff + 4];
+ double cy2 = src[srcOff + 5];
+ double x2 = src[srcOff + 6];
+ double y2 = src[srcOff + 7];
+ double cx = (cx1 + cx2) / 2.0;
+ double cy = (cy1 + cy2) / 2.0;
+ cx1 = (x1 + cx1) / 2.0;
+ cy1 = (y1 + cy1) / 2.0;
+ cx2 = (x2 + cx2) / 2.0;
+ cy2 = (y2 + cy2) / 2.0;
+ double ax = (cx1 + cx) / 2.0;
+ double ay = (cy1 + cy) / 2.0;
+ double bx = (cx2 + cx) / 2.0;
+ double by = (cy2 + cy) / 2.0;
+ cx = (ax + bx) / 2.0;
+ cy = (ay + by) / 2.0;
+ if (left != null) {
+ left[leftOff + 0] = x1;
+ left[leftOff + 1] = y1;
+ left[leftOff + 2] = cx1;
+ left[leftOff + 3] = cy1;
+ left[leftOff + 4] = ax;
+ left[leftOff + 5] = ay;
+ left[leftOff + 6] = cx;
+ left[leftOff + 7] = cy;
+ }
+ if (right != null) {
+ right[rightOff + 0] = cx;
+ right[rightOff + 1] = cy;
+ right[rightOff + 2] = bx;
+ right[rightOff + 3] = by;
+ right[rightOff + 4] = cx2;
+ right[rightOff + 5] = cy2;
+ right[rightOff + 6] = x2;
+ right[rightOff + 7] = y2;
+ }
+ }
+
+ /**
+ * Finds the roots of the cubic polynomial. This is
+ * accomplished by finding the (real) values of x that solve
+ * the following equation: eqn[3]*x*x*x + eqn[2]*x*x + eqn[1]*x + eqn[0] = 0.
+ * The solutions are written back into the array eqn starting
+ * from the index 0 in the array. The return value tells how
+ * many array elements have been changed by this method call.
+ *
+ * @param eqn an array containing the coefficients of the
+ * cubic polynomial to solve.
+ *
+ * @return the number of roots of the cubic polynomial
+ *
+ * @throws ArrayIndexOutOfBoundsException if eqn.length < 4.
+ * @throws NullPointerException if the array is null.
+ */
+ public static int solveCubic(double eqn[]) {
+ return solveCubic(eqn, eqn);
+ }
+
+ /**
+ * Finds the roots of the cubic polynomial. This is
+ * accomplished by finding the (real) values of x that solve
+ * the following equation: eqn[3]*x*x*x + eqn[2]*x*x + eqn[1]*x + eqn[0] = 0.
+ * The solutions are written into the array res starting
+ * from the index 0 in the array. The return value tells how
+ * many array elements have been changed by this method call.
+ *
+ * @param eqn an array containing the coefficients of the
+ * cubic polynomial to solve.
+ * @param res the array that this method writes the results into
+ *
+ * @return the number of roots of the cubic polynomial
+ *
+ * @throws ArrayIndexOutOfBoundsException if eqn.length < 4 or
+ * if res.length is less than the number of roots.
+ * @throws NullPointerException if either array is null.
+ */
+ public static int solveCubic(double eqn[], double res[]) {
+ return Crossing.solveCubic(eqn, res);
+ }
+
+ public boolean contains(double px, double py) {
+ return Crossing.isInsideEvenOdd(Crossing.crossShape(this, px, py));
+ }
+
+ public boolean contains(double rx, double ry, double rw, double rh) {
+ int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
+ return cross != Crossing.CROSSING && Crossing.isInsideEvenOdd(cross);
+ }
+
+ public boolean intersects(double rx, double ry, double rw, double rh) {
+ int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
+ return cross == Crossing.CROSSING || Crossing.isInsideEvenOdd(cross);
+ }
+
+ public boolean contains(Point2D p) {
+ return contains(p.getX(), p.getY());
+ }
+
+ public boolean intersects(Rectangle2D r) {
+ return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ }
+
+ public boolean contains(Rectangle2D r) {
+ return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ }
+
+ public Rectangle getBounds() {
+ return getBounds2D().getBounds();
+ }
+
+ public PathIterator getPathIterator(AffineTransform t) {
+ return new Iterator(this, t);
+ }
+
+ public PathIterator getPathIterator(AffineTransform at, double flatness) {
+ return new FlatteningPathIterator(getPathIterator(at), flatness);
+ }
+
+ @Override
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ throw new InternalError();
+ }
+ }
+}
\ No newline at end of file
diff --git a/awt/java/awt/geom/Dimension2D.java b/awt/java/awt/geom/Dimension2D.java
new file mode 100644
index 0000000..eef63e6
--- /dev/null
+++ b/awt/java/awt/geom/Dimension2D.java
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+/**
+ * The Class Dimension2D represents a size (width and height) of a
+ * geometric object. It stores double-valued data in order to be compatible
+ * with high-precision geometric operations.
+ */
+public abstract class Dimension2D implements Cloneable {
+
+ /**
+ * Instantiates a new dimension 2d with no data.
+ */
+ protected Dimension2D() {
+ }
+
+ /**
+ * Gets the width.
+ *
+ * @return the width
+ */
+ public abstract double getWidth();
+
+ /**
+ * Gets the height.
+ *
+ * @return the height
+ */
+ public abstract double getHeight();
+
+ /**
+ * Sets the width and height.
+ *
+ * @param width the width
+ * @param height the height
+ */
+ public abstract void setSize(double width, double height);
+
+ /**
+ * Sets the width and height based on the data of another
+ * Dimension2D object.
+ *
+ * @param d the Dimension2D object providing the data to copy
+ * into this Dimension2D object
+ */
+ public void setSize(Dimension2D d) {
+ setSize(d.getWidth(), d.getHeight());
+ }
+
+ @Override
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ throw new InternalError();
+ }
+ }
+}
+
diff --git a/awt/java/awt/geom/Ellipse2D.java b/awt/java/awt/geom/Ellipse2D.java
new file mode 100644
index 0000000..33464af
--- /dev/null
+++ b/awt/java/awt/geom/Ellipse2D.java
@@ -0,0 +1,403 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class Ellipse2D describes an ellipse defined by a rectangular
+ * area in which it is inscribed.
+ */
+public abstract class Ellipse2D extends RectangularShape {
+
+ /**
+ * The Class Float is the subclass of Ellipse2D that has all
+ * of its data values stored with float-level precision.
+ */
+ public static class Float extends Ellipse2D {
+
+ /** The x coordinate of the upper left corner of the ellipse's
+ * bounding rectangle. */
+ public float x;
+
+ /** The y coordinate of the upper left corner of the ellipse's
+ * bounding rectangle. */
+ public float y;
+
+ /** The width of the ellipse's bounding rectangle. */
+ public float width;
+
+ /** The height of the ellipse's bounding rectangle. */
+ public float height;
+
+ /**
+ * Instantiates a new float-valued Ellipse2D.
+ */
+ public Float() {
+ }
+
+ /**
+ * Instantiates a new float-valued Ellipse2D with the specified data.
+ *
+ * @param x the x coordinate of the upper left corner of the ellipse's
+ * bounding rectangle
+ * @param y the y coordinate of the upper left corner of the ellipse's
+ * bounding rectangle
+ * @param width the width of the ellipse's bounding rectangle
+ * @param height the height of the ellipse's bounding rectangle
+ */
+ public Float(float x, float y, float width, float height) {
+ setFrame(x, y, width, height);
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return width <= 0.0 || height <= 0.0;
+ }
+
+ /**
+ * Sets the data of the ellipse's bounding rectangle.
+ *
+ * @param x the x coordinate of the upper left corner of the ellipse's
+ * bounding rectangle
+ * @param y the y coordinate of the upper left corner of the ellipse's
+ * bounding rectangle
+ * @param width the width of the ellipse's bounding rectangle
+ * @param height the height of the ellipse's bounding rectangle
+ */
+ public void setFrame(float x, float y, float width, float height) {
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ }
+
+ @Override
+ public void setFrame(double x, double y, double width, double height) {
+ this.x = (float)x;
+ this.y = (float)y;
+ this.width = (float)width;
+ this.height = (float)height;
+ }
+
+ public Rectangle2D getBounds2D() {
+ return new Rectangle2D.Float(x, y, width, height);
+ }
+ }
+
+ /**
+ * The Class Double is the subclass of Ellipse2D that has all
+ * of its data values stored with double-level precision.
+ */
+ public static class Double extends Ellipse2D {
+
+ /** The x coordinate of the upper left corner of the ellipse's
+ * bounding rectangle. */
+ public double x;
+
+ /** The y coordinate of the upper left corner of the ellipse's
+ * bounding rectangle. */
+ public double y;
+
+ /** The width of the ellipse's bounding rectangle. */
+ public double width;
+
+ /** The height of the ellipse's bounding rectangle. */
+ public double height;
+
+ /**
+ * Instantiates a new double-valued Ellipse2D.
+ */
+ public Double() {
+ }
+
+ /**
+ * Instantiates a new double-valued Ellipse2D with the specified
+ * data.
+ *
+ * @param x the x coordinate of the upper left corner of the ellipse's
+ * bounding rectangle
+ * @param y the y coordinate of the upper left corner of the ellipse's
+ * bounding rectangle
+ * @param width the width of the ellipse's bounding rectangle
+ * @param height the height of the ellipse's bounding rectangle
+ */
+ public Double(double x, double y, double width, double height) {
+ setFrame(x, y, width, height);
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return width <= 0.0 || height <= 0.0;
+ }
+
+ @Override
+ public void setFrame(double x, double y, double width, double height) {
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ }
+
+ public Rectangle2D getBounds2D() {
+ return new Rectangle2D.Double(x, y, width, height);
+ }
+ }
+
+ /*
+ * Ellipse2D path iterator
+ */
+ /**
+ * The subclass of PathIterator to traverse an Ellipse2D.
+ */
+ class Iterator implements PathIterator {
+
+ /*
+ * Ellipse is subdivided into four quarters by x and y axis. Each part approximated by
+ * cubic Bezier curve. Arc in first quarter is started in (a, 0) and finished in (0, b) points.
+ * Control points for cubic curve wiil be (a, 0), (a, m), (n, b) and (0, b) where n and m are
+ * calculated based on requirement Bezier curve in point 0.5 should lay on the arc.
+ */
+
+ /** The coefficient to calculate control points of Bezier curves. */
+ final double u = 2.0 / 3.0 * (Math.sqrt(2.0) - 1.0);
+
+ /** The points coordinates calculation table. */
+ final double points[][] = {
+ { 1.0, 0.5 + u, 0.5 + u, 1.0, 0.5, 1.0 },
+ { 0.5 - u, 1.0, 0.0, 0.5 + u, 0.0, 0.5 },
+ { 0.0, 0.5 - u, 0.5 - u, 0.0, 0.5, 0.0 },
+ { 0.5 + u, 0.0, 1.0, 0.5 - u, 1.0, 0.5 }
+ };
+
+ /** The x coordinate of left-upper corner of the ellipse bounds. */
+ double x;
+
+ /** The y coordinate of left-upper corner of the ellipse bounds. */
+ double y;
+
+ /** The width of the ellipse bounds. */
+ double width;
+
+ /** The height of the ellipse bounds. */
+ double height;
+
+ /** The path iterator transformation. */
+ AffineTransform t;
+
+ /** The current segmenet index. */
+ int index;
+
+ /**
+ * Constructs a new Ellipse2D.Iterator for given ellipse and transformation
+ *
+ * @param e - the source Ellipse2D object
+ * @param t the t
+ */
+ Iterator(Ellipse2D e, AffineTransform t) {
+ this.x = e.getX();
+ this.y = e.getY();
+ this.width = e.getWidth();
+ this.height = e.getHeight();
+ this.t = t;
+ if (width < 0.0 || height < 0.0) {
+ index = 6;
+ }
+ }
+
+ public int getWindingRule() {
+ return WIND_NON_ZERO;
+ }
+
+ public boolean isDone() {
+ return index > 5;
+ }
+
+ public void next() {
+ index++;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ if (index == 5) {
+ return SEG_CLOSE;
+ }
+ int type;
+ int count;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ count = 1;
+ double p[] = points[3];
+ coords[0] = x + p[4] * width;
+ coords[1] = y + p[5] * height;
+ } else {
+ type = SEG_CUBICTO;
+ count = 3;
+ double p[] = points[index - 1];
+ int j = 0;
+ for (int i = 0; i < 3; i++) {
+ coords[j] = x + p[j++] * width;
+ coords[j] = y + p[j++] * height;
+ }
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count);
+ }
+ return type;
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ if (index == 5) {
+ return SEG_CLOSE;
+ }
+ int type;
+ int count;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ count = 1;
+ double p[] = points[3];
+ coords[0] = (float)(x + p[4] * width);
+ coords[1] = (float)(y + p[5] * height);
+ } else {
+ type = SEG_CUBICTO;
+ count = 3;
+ int j = 0;
+ double p[] = points[index - 1];
+ for (int i = 0; i < 3; i++) {
+ coords[j] = (float)(x + p[j++] * width);
+ coords[j] = (float)(y + p[j++] * height);
+ }
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count);
+ }
+ return type;
+ }
+
+ }
+
+ /**
+ * Instantiates a new Ellipse2D.
+ */
+ protected Ellipse2D() {
+ }
+
+ public boolean contains(double px, double py) {
+ if (isEmpty()) {
+ return false;
+ }
+
+ double a = (px - getX()) / getWidth() - 0.5;
+ double b = (py - getY()) / getHeight() - 0.5;
+
+ return a * a + b * b < 0.25;
+ }
+
+ public boolean intersects(double rx, double ry, double rw, double rh) {
+ if (isEmpty() || rw <= 0.0 || rh <= 0.0) {
+ return false;
+ }
+
+ double cx = getX() + getWidth() / 2.0;
+ double cy = getY() + getHeight() / 2.0;
+
+ double rx1 = rx;
+ double ry1 = ry;
+ double rx2 = rx + rw;
+ double ry2 = ry + rh;
+
+ double nx = cx < rx1 ? rx1 : (cx > rx2 ? rx2 : cx);
+ double ny = cy < ry1 ? ry1 : (cy > ry2 ? ry2 : cy);
+
+ return contains(nx, ny);
+ }
+
+ public boolean contains(double rx, double ry, double rw, double rh) {
+ if (isEmpty() || rw <= 0.0 || rh <= 0.0) {
+ return false;
+ }
+
+ double rx1 = rx;
+ double ry1 = ry;
+ double rx2 = rx + rw;
+ double ry2 = ry + rh;
+
+ return
+ contains(rx1, ry1) &&
+ contains(rx2, ry1) &&
+ contains(rx2, ry2) &&
+ contains(rx1, ry2);
+ }
+
+ public PathIterator getPathIterator(AffineTransform at) {
+ return new Iterator(this, at);
+ }
+}
+
diff --git a/awt/java/awt/geom/FlatteningPathIterator.java b/awt/java/awt/geom/FlatteningPathIterator.java
new file mode 100644
index 0000000..ca5c7c2
--- /dev/null
+++ b/awt/java/awt/geom/FlatteningPathIterator.java
@@ -0,0 +1,326 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class FlatteningPathIterator takes a PathIterator for traversing
+ * a curved shape and flattens it by estimating the curve as a series
+ * of line segments. The flattening factor indicates how far the
+ * estimating line segments are allowed to be from the actual curve:
+ * the FlatteningPathIterator will keep dividing each curved segment
+ * into smaller and smaller flat segments until either the segments
+ * are withing the flattening factor of the curve or until the buffer
+ * limit is reached.
+ */
+public class FlatteningPathIterator implements PathIterator {
+
+ /** The default points buffer size. */
+ private static final int BUFFER_SIZE = 16;
+
+ /** The default curve subdivision limit. */
+ private static final int BUFFER_LIMIT = 16;
+
+ /** The points buffer capacity. */
+ private static final int BUFFER_CAPACITY = 16;
+
+ /** The type of current segment to be flat. */
+ int bufType;
+
+ /** The curve subdivision limit. */
+ int bufLimit;
+
+ /** The current points buffer size. */
+ int bufSize;
+
+ /** The inner cursor position in points buffer. */
+ int bufIndex;
+
+ /** The current subdivision count. */
+ int bufSubdiv;
+
+ /** The points buffer. */
+ double buf[];
+
+ /** The indicator of empty points buffer. */
+ boolean bufEmpty = true;
+
+ /** The source PathIterator. */
+ PathIterator p;
+
+ /** The flatness of new path. */
+ double flatness;
+
+ /** The square of flatness. */
+ double flatness2;
+
+ /** The x coordinate of previous path segment. */
+ double px;
+
+ /** The y coordinate of previous path segment. */
+ double py;
+
+ /** The tamporary buffer for getting points from PathIterator. */
+ double coords[] = new double[6];
+
+ /**
+ * Instantiates a new flattening path iterator given the path
+ * iterator for a (possibly) curved path and a flattening factor
+ * which indicates how close together the points on the curve
+ * should be chosen. The buffer limit defaults to 16 which means
+ * that each curve will be divided into no more than 16 segments
+ * regardless of the flattening factor.
+ *
+ * @param path the path iterator of the original curve
+ * @param flatness the flattening factor that indicates how far the
+ * flat path is allowed to be from the actual curve in order to
+ * decide when to stop dividing the path into smaller and smaller
+ * segments.
+ *
+ * @throws IllegalArgumentException if the flatness is less than zero.
+ * @throws NullPointerException if the path is null.
+ */
+ public FlatteningPathIterator(PathIterator path, double flatness) {
+ this(path, flatness, BUFFER_LIMIT);
+ }
+
+ /**
+ * Instantiates a new flattening path iterator given the path
+ * iterator for a (possibly) curved path and a flattening factor
+ * and a buffer limit. The FlatteningPathIterator will keep
+ * dividing each curved segment into smaller and smaller flat segments
+ * until either the segments are withing the flattening factor of the
+ * curve or until the buffer limit is reached.
+ *
+ * @param path the path iterator of the original curve
+ * @param flatness the flattening factor that indicates how far the
+ * flat path is allowed to be from the actual curve in order to
+ * decide when to stop dividing the path into smaller and smaller
+ * segments.
+ * @param limit the maximum number of flat segments to divide each
+ * curve into
+ *
+ * @throws IllegalArgumentException if the flatness or limit is less than zero.
+ * @throws NullPointerException if the path is null.
+ */
+ public FlatteningPathIterator(PathIterator path, double flatness, int limit) {
+ if (flatness < 0.0) {
+ // awt.206=Flatness is less then zero
+ throw new IllegalArgumentException(Messages.getString("awt.206")); //$NON-NLS-1$
+ }
+ if (limit < 0) {
+ // awt.207=Limit is less then zero
+ throw new IllegalArgumentException(Messages.getString("awt.207")); //$NON-NLS-1$
+ }
+ if (path == null) {
+ // awt.208=Path is null
+ throw new NullPointerException(Messages.getString("awt.208")); //$NON-NLS-1$
+ }
+ this.p = path;
+ this.flatness = flatness;
+ this.flatness2 = flatness * flatness;
+ this.bufLimit = limit;
+ this.bufSize = Math.min(bufLimit, BUFFER_SIZE);
+ this.buf = new double[bufSize];
+ this.bufIndex = bufSize;
+ }
+
+ /**
+ * Gets the flattening factor.
+ *
+ * @return the flattening factor
+ */
+ public double getFlatness() {
+ return flatness;
+ }
+
+ /**
+ * Gets the maximum number of subdivisions per curved segment.
+ *
+ * @return the maximum number of subdivisions per curved segment
+ */
+ public int getRecursionLimit() {
+ return bufLimit;
+ }
+
+ public int getWindingRule() {
+ return p.getWindingRule();
+ }
+
+ public boolean isDone() {
+ return bufEmpty && p.isDone();
+ }
+
+ /**
+ * Calculates flat path points for current segment of the source shape.
+ *
+ * Line segment is flat by itself. Flatness of quad and cubic curves evaluated by getFlatnessSq() method.
+ * Curves subdivided until current flatness is bigger than user defined and subdivision limit isn't exhausted.
+ * Single source segment translated to series of buffer points. The less flatness the bigger serries.
+ * Every currentSegment() call extract one point from the buffer. When series completed evaluate() takes next source shape segment.
+ */
+ void evaluate() {
+ if (bufEmpty) {
+ bufType = p.currentSegment(coords);
+ }
+
+ switch (bufType) {
+ case SEG_MOVETO:
+ case SEG_LINETO:
+ px = coords[0];
+ py = coords[1];
+ break;
+ case SEG_QUADTO:
+ if (bufEmpty) {
+ bufIndex -= 6;
+ buf[bufIndex + 0] = px;
+ buf[bufIndex + 1] = py;
+ System.arraycopy(coords, 0, buf, bufIndex + 2, 4);
+ bufSubdiv = 0;
+ }
+
+ while (bufSubdiv < bufLimit) {
+ if (QuadCurve2D.getFlatnessSq(buf, bufIndex) < flatness2) {
+ break;
+ }
+
+ // Realloc buffer
+ if (bufIndex <= 4) {
+ double tmp[] = new double[bufSize + BUFFER_CAPACITY];
+ System.arraycopy(
+ buf, bufIndex,
+ tmp, bufIndex + BUFFER_CAPACITY,
+ bufSize - bufIndex);
+ buf = tmp;
+ bufSize += BUFFER_CAPACITY;
+ bufIndex += BUFFER_CAPACITY;
+ }
+
+ QuadCurve2D.subdivide(buf, bufIndex, buf, bufIndex - 4, buf, bufIndex);
+
+ bufIndex -= 4;
+ bufSubdiv++;
+ }
+
+ bufIndex += 4;
+ px = buf[bufIndex];
+ py = buf[bufIndex + 1];
+
+ bufEmpty = (bufIndex == bufSize - 2);
+ if (bufEmpty) {
+ bufIndex = bufSize;
+ bufType = SEG_LINETO;
+ } else {
+ bufSubdiv--;
+ }
+ break;
+ case SEG_CUBICTO:
+ if (bufEmpty) {
+ bufIndex -= 8;
+ buf[bufIndex + 0] = px;
+ buf[bufIndex + 1] = py;
+ System.arraycopy(coords, 0, buf, bufIndex + 2, 6);
+ bufSubdiv = 0;
+ }
+
+ while (bufSubdiv < bufLimit) {
+ if (CubicCurve2D.getFlatnessSq(buf, bufIndex) < flatness2) {
+ break;
+ }
+
+ // Realloc buffer
+ if (bufIndex <= 6) {
+ double tmp[] = new double[bufSize + BUFFER_CAPACITY];
+ System.arraycopy(
+ buf, bufIndex,
+ tmp, bufIndex + BUFFER_CAPACITY,
+ bufSize - bufIndex);
+ buf = tmp;
+ bufSize += BUFFER_CAPACITY;
+ bufIndex += BUFFER_CAPACITY;
+ }
+
+ CubicCurve2D.subdivide(buf, bufIndex, buf, bufIndex - 6, buf, bufIndex);
+
+ bufIndex -= 6;
+ bufSubdiv++;
+ }
+
+ bufIndex += 6;
+ px = buf[bufIndex];
+ py = buf[bufIndex + 1];
+
+ bufEmpty = (bufIndex == bufSize - 2);
+ if (bufEmpty) {
+ bufIndex = bufSize;
+ bufType = SEG_LINETO;
+ } else {
+ bufSubdiv--;
+ }
+ break;
+ }
+
+ }
+
+ public void next() {
+ if (bufEmpty) {
+ p.next();
+ }
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4Bx")); //$NON-NLS-1$
+ }
+ evaluate();
+ int type = bufType;
+ if (type != SEG_CLOSE) {
+ coords[0] = (float)px;
+ coords[1] = (float)py;
+ if (type != SEG_MOVETO) {
+ type = SEG_LINETO;
+ }
+ }
+ return type;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ evaluate();
+ int type = bufType;
+ if (type != SEG_CLOSE) {
+ coords[0] = px;
+ coords[1] = py;
+ if (type != SEG_MOVETO) {
+ type = SEG_LINETO;
+ }
+ }
+ return type;
+ }
+}
+
diff --git a/awt/java/awt/geom/GeneralPath.java b/awt/java/awt/geom/GeneralPath.java
new file mode 100644
index 0000000..36b01c4
--- /dev/null
+++ b/awt/java/awt/geom/GeneralPath.java
@@ -0,0 +1,566 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.gl.Crossing;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class GeneralPath represents a shape whose outline is given
+ * by different types of curved and straight segments.
+ */
+public final class GeneralPath implements Shape, Cloneable {
+
+ /** The Constant WIND_EVEN_ODD see {@link PathIterator#WIND_EVEN_ODD}. */
+ public static final int WIND_EVEN_ODD = PathIterator.WIND_EVEN_ODD;
+
+ /** The Constant WIND_NON_ZERO see {@link PathIterator#WIND_NON_ZERO}. */
+ public static final int WIND_NON_ZERO = PathIterator.WIND_NON_ZERO;
+
+ /** The buffers size. */
+ private static final int BUFFER_SIZE = 10;
+
+ /** The buffers capacity. */
+ private static final int BUFFER_CAPACITY = 10;
+
+ /** The point's types buffer. */
+ byte[] types;
+
+ /** The points buffer. */
+ float[] points;
+
+ /** The point's type buffer size. */
+ int typeSize;
+
+ /** The points buffer size. */
+ int pointSize;
+
+ /** The path rule. */
+ int rule;
+
+ /** The space amount in points buffer for different segmenet's types. */
+ static int pointShift[] = {
+ 2, // MOVETO
+ 2, // LINETO
+ 4, // QUADTO
+ 6, // CUBICTO
+ 0}; // CLOSE
+
+ /*
+ * GeneralPath path iterator
+ */
+ /**
+ * The Class Iterator is the subclass of Iterator for traversing the
+ * outline of a GeneralPath.
+ */
+ class Iterator implements PathIterator {
+
+ /** The current cursor position in types buffer. */
+ int typeIndex;
+
+ /** The current cursor position in points buffer. */
+ int pointIndex;
+
+ /** The source GeneralPath object. */
+ GeneralPath p;
+
+ /** The path iterator transformation. */
+ AffineTransform t;
+
+ /**
+ * Constructs a new GeneralPath.Iterator for given general path
+ *
+ * @param path - the source GeneralPath object
+ */
+ Iterator(GeneralPath path) {
+ this(path, null);
+ }
+
+ /**
+ * Constructs a new GeneralPath.Iterator for given general path and transformation
+ *
+ * @param path - the source GeneralPath object
+ * @param at - the AffineTransform object to apply rectangle path
+ */
+ Iterator(GeneralPath path, AffineTransform at) {
+ this.p = path;
+ this.t = at;
+ }
+
+ public int getWindingRule() {
+ return p.getWindingRule();
+ }
+
+ public boolean isDone() {
+ return typeIndex >= p.typeSize;
+ }
+
+ public void next() {
+ typeIndex++;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type = p.types[typeIndex];
+ int count = GeneralPath.pointShift[type];
+ for (int i = 0; i < count; i++) {
+ coords[i] = p.points[pointIndex + i];
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count / 2);
+ }
+ pointIndex += count;
+ return type;
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type = p.types[typeIndex];
+ int count = GeneralPath.pointShift[type];
+ System.arraycopy(p.points, pointIndex, coords, 0, count);
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count / 2);
+ }
+ pointIndex += count;
+ return type;
+ }
+
+ }
+
+ /**
+ * Instantiates a new general path with the winding rule set
+ * to {@link PathIterator#WIND_NON_ZERO} and the initial capacity
+ * (number of segments) set to the default value 10.
+ */
+ public GeneralPath() {
+ this(WIND_NON_ZERO, BUFFER_SIZE);
+ }
+
+ /**
+ * Instantiates a new general path with the given winding rule
+ * and the initial capacity (number of segments) set to the
+ * default value 10.
+ *
+ * @param rule the winding rule, either {@link PathIterator#WIND_EVEN_ODD}
+ * or {@link PathIterator#WIND_NON_ZERO}
+ */
+ public GeneralPath(int rule) {
+ this(rule, BUFFER_SIZE);
+ }
+
+ /**
+ * Instantiates a new general path with the given winding rule
+ * and initial capacity (number of segments).
+ *
+ * @param rule the winding rule, either {@link PathIterator#WIND_EVEN_ODD}
+ * or {@link PathIterator#WIND_NON_ZERO}
+ * @param initialCapacity the number of segments the path is set to hold
+ */
+ public GeneralPath(int rule, int initialCapacity) {
+ setWindingRule(rule);
+ types = new byte[initialCapacity];
+ points = new float[initialCapacity * 2];
+ }
+
+ /**
+ * Creates a new GeneralPath from the outline of the given shape.
+ *
+ * @param shape the shape
+ */
+ public GeneralPath(Shape shape) {
+ this(WIND_NON_ZERO, BUFFER_SIZE);
+ PathIterator p = shape.getPathIterator(null);
+ setWindingRule(p.getWindingRule());
+ append(p, false);
+ }
+
+ /**
+ * Sets the winding rule, which determines how to decide whether
+ * a point that isn't on the path itself is inside or outside of
+ * the shape.
+ *
+ * @param rule the new winding rule
+ *
+ * @throws IllegalArgumentException if the winding rule is neither
+ * {@link PathIterator#WIND_EVEN_ODD} nor {@link PathIterator#WIND_NON_ZERO}.
+ */
+ public void setWindingRule(int rule) {
+ if (rule != WIND_EVEN_ODD && rule != WIND_NON_ZERO) {
+ // awt.209=Invalid winding rule value
+ throw new java.lang.IllegalArgumentException(Messages.getString("awt.209")); //$NON-NLS-1$
+ }
+ this.rule = rule;
+ }
+
+ /**
+ * Gets the winding rule.
+ *
+ * @return the winding rule, either {@link PathIterator#WIND_EVEN_ODD}
+ * or {@link PathIterator#WIND_NON_ZERO}
+ */
+ public int getWindingRule() {
+ return rule;
+ }
+
+ /**
+ * Checks the point data buffer sizes to see whether pointCount additional
+ * point-data elements can fit. (Note that the number of point data
+ * elements to add is more than one per point -- it depends on the type
+ * of point being added.) Reallocates the buffers to enlarge the size if necessary.
+ *
+ * @param pointCount - the number of point data elements to be added
+ * @param checkMove whether to check for existing points
+ *
+ * @throws IllegalPathStateException checkMove is true and the
+ * path is currently empty.
+ */
+ void checkBuf(int pointCount, boolean checkMove) {
+ if (checkMove && typeSize == 0) {
+ // awt.20A=First segment should be SEG_MOVETO type
+ throw new IllegalPathStateException(Messages.getString("awt.20A")); //$NON-NLS-1$
+ }
+ if (typeSize == types.length) {
+ byte tmp[] = new byte[typeSize + BUFFER_CAPACITY];
+ System.arraycopy(types, 0, tmp, 0, typeSize);
+ types = tmp;
+ }
+ if (pointSize + pointCount > points.length) {
+ float tmp[] = new float[pointSize + Math.max(BUFFER_CAPACITY * 2, pointCount)];
+ System.arraycopy(points, 0, tmp, 0, pointSize);
+ points = tmp;
+ }
+ }
+
+ /**
+ * Appends a new point to the end of this general path, disconnected
+ * from the existing path.
+ *
+ * @param x the x coordinate of the next point to append
+ * @param y the y coordinate of the next point to append
+ */
+ public void moveTo(float x, float y) {
+ if (typeSize > 0 && types[typeSize - 1] == PathIterator.SEG_MOVETO) {
+ points[pointSize - 2] = x;
+ points[pointSize - 1] = y;
+ } else {
+ checkBuf(2, false);
+ types[typeSize++] = PathIterator.SEG_MOVETO;
+ points[pointSize++] = x;
+ points[pointSize++] = y;
+ }
+ }
+
+ /**
+ * Appends a new segment to the end of this general path by making
+ * a straight line segment from the current endpoint to the
+ * given new point.
+ *
+ * @param x the x coordinate of the next point to append
+ * @param y the y coordinate of the next point to append
+ */
+ public void lineTo(float x, float y) {
+ checkBuf(2, true);
+ types[typeSize++] = PathIterator.SEG_LINETO;
+ points[pointSize++] = x;
+ points[pointSize++] = y;
+ }
+
+ /**
+ * Appends a new segment to the end of this general path by making
+ * a quadratic curve from the current endpoint to the point (x2, y2)
+ * using the point (x1, y1) as the quadratic curve's control point.
+ *
+ * @param x1 the x coordinate of the quadratic curve's control point
+ * @param y1 the y coordinate of the quadratic curve's control point
+ * @param x2 the x coordinate of the quadratic curve's end point
+ * @param y2 the y coordinate of the quadratic curve's end point
+ */
+ public void quadTo(float x1, float y1, float x2, float y2) {
+ checkBuf(4, true);
+ types[typeSize++] = PathIterator.SEG_QUADTO;
+ points[pointSize++] = x1;
+ points[pointSize++] = y1;
+ points[pointSize++] = x2;
+ points[pointSize++] = y2;
+ }
+
+ /**
+ * Appends a new segment to the end of this general path by making
+ * a cubic curve from the current endpoint to the point (x3, y3)
+ * using (x1, y1) and (x2, y2) as control points.
+ *
+ * @see java.awt.geom.CubicCurve2D
+ *
+ * @param x1 the x coordinate of the new cubic segment's first control point
+ * @param y1 the y coordinate of the new cubic segment's first control point
+ * @param x2 the x coordinate of the new cubic segment's second control point
+ * @param y2 the y coordinate of the new cubic segment's second control point
+ * @param x3 the x coordinate of the new cubic segment's end point
+ * @param y3 the y coordinate of the new cubic segment's end point
+ */
+ public void curveTo(float x1, float y1, float x2, float y2, float x3, float y3) {
+ checkBuf(6, true);
+ types[typeSize++] = PathIterator.SEG_CUBICTO;
+ points[pointSize++] = x1;
+ points[pointSize++] = y1;
+ points[pointSize++] = x2;
+ points[pointSize++] = y2;
+ points[pointSize++] = x3;
+ points[pointSize++] = y3;
+ }
+
+ /**
+ * Appends the type information to declare that the current
+ * endpoint closes the curve.
+ */
+ public void closePath() {
+ if (typeSize == 0 || types[typeSize - 1] != PathIterator.SEG_CLOSE) {
+ checkBuf(0, true);
+ types[typeSize++] = PathIterator.SEG_CLOSE;
+ }
+ }
+
+ /**
+ * Appends the outline of the specified shape onto the end
+ * of this GeneralPath.
+ *
+ * @param shape the shape whose outline is to be appended
+ * @param connect true to connect this path's current
+ * endpoint to the first point of the shape's outline or
+ * false to append the shape's outline without connecting it
+ *
+ * @throws NullPointerException if the shape parameter is null
+ */
+ public void append(Shape shape, boolean connect) {
+ PathIterator p = shape.getPathIterator(null);
+ append(p, connect);
+ }
+
+ /**
+ * Appends the path defined by the specified PathIterator onto the end
+ * of this GeneralPath.
+ *
+ * @param path the PathIterator that defines the new path to append
+ * @param connect true to connect this path's current
+ * endpoint to the first point of the shape's outline or
+ * false to append the shape's outline without connecting it
+ */
+ public void append(PathIterator path, boolean connect) {
+ while (!path.isDone()) {
+ float coords[] = new float[6];
+ switch (path.currentSegment(coords)) {
+ case PathIterator.SEG_MOVETO:
+ if (!connect || typeSize == 0) {
+ moveTo(coords[0], coords[1]);
+ break;
+ }
+ if (types[typeSize - 1] != PathIterator.SEG_CLOSE &&
+ points[pointSize - 2] == coords[0] &&
+ points[pointSize - 1] == coords[1])
+ {
+ break;
+ }
+ // NO BREAK;
+ case PathIterator.SEG_LINETO:
+ lineTo(coords[0], coords[1]);
+ break;
+ case PathIterator.SEG_QUADTO:
+ quadTo(coords[0], coords[1], coords[2], coords[3]);
+ break;
+ case PathIterator.SEG_CUBICTO:
+ curveTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]);
+ break;
+ case PathIterator.SEG_CLOSE:
+ closePath();
+ break;
+ }
+ path.next();
+ connect = false;
+ }
+ }
+
+ /**
+ * Gets the current end point of the path.
+ *
+ * @return the current end point of the path
+ */
+ public Point2D getCurrentPoint() {
+ if (typeSize == 0) {
+ return null;
+ }
+ int j = pointSize - 2;
+ if (types[typeSize - 1] == PathIterator.SEG_CLOSE) {
+
+ for (int i = typeSize - 2; i > 0; i--) {
+ int type = types[i];
+ if (type == PathIterator.SEG_MOVETO) {
+ break;
+ }
+ j -= pointShift[type];
+ }
+ }
+ return new Point2D.Float(points[j], points[j + 1]);
+ }
+
+ /**
+ * Resets the GeneralPath to being an empty path. The underlying
+ * point and segment data is not deleted but rather the end indices
+ * of the data arrays are set to zero.
+ */
+ public void reset() {
+ typeSize = 0;
+ pointSize = 0;
+ }
+
+ /**
+ * Transform all of the coordinates of this path according to the
+ * specified AffineTransform.
+ *
+ * @param t the AffineTransform
+ */
+ public void transform(AffineTransform t) {
+ t.transform(points, 0, points, 0, pointSize / 2);
+ }
+
+ /**
+ * Creates a new GeneralPath whose data is given by this path's
+ * data transformed according to the specified AffineTransform.
+ *
+ * @param t the AffineTransform
+ *
+ * @return the new GeneralPath whose data is given by this path's
+ * data transformed according to the specified AffineTransform
+ */
+ public Shape createTransformedShape(AffineTransform t) {
+ GeneralPath p = (GeneralPath)clone();
+ if (t != null) {
+ p.transform(t);
+ }
+ return p;
+ }
+
+ public Rectangle2D getBounds2D() {
+ float rx1, ry1, rx2, ry2;
+ if (pointSize == 0) {
+ rx1 = ry1 = rx2 = ry2 = 0.0f;
+ } else {
+ int i = pointSize - 1;
+ ry1 = ry2 = points[i--];
+ rx1 = rx2 = points[i--];
+ while (i > 0) {
+ float y = points[i--];
+ float x = points[i--];
+ if (x < rx1) {
+ rx1 = x;
+ } else
+ if (x > rx2) {
+ rx2 = x;
+ }
+ if (y < ry1) {
+ ry1 = y;
+ } else
+ if (y > ry2) {
+ ry2 = y;
+ }
+ }
+ }
+ return new Rectangle2D.Float(rx1, ry1, rx2 - rx1, ry2 - ry1);
+ }
+
+ public Rectangle getBounds() {
+ return getBounds2D().getBounds();
+ }
+
+ /**
+ * Checks the cross count (number of times a ray from the point
+ * crosses the shape's boundary) to determine whether the number
+ * of crossings corresponds to a point inside the shape or not
+ * (according to the shape's path rule).
+ *
+ * @param cross - the point's cross count
+ *
+ * @return true if the point is inside the path, or false otherwise
+ */
+ boolean isInside(int cross) {
+ if (rule == WIND_NON_ZERO) {
+ return Crossing.isInsideNonZero(cross);
+ }
+ return Crossing.isInsideEvenOdd(cross);
+ }
+
+ public boolean contains(double px, double py) {
+ return isInside(Crossing.crossShape(this, px, py));
+ }
+
+ public boolean contains(double rx, double ry, double rw, double rh) {
+ int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
+ return cross != Crossing.CROSSING && isInside(cross);
+ }
+
+ public boolean intersects(double rx, double ry, double rw, double rh) {
+ int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
+ return cross == Crossing.CROSSING || isInside(cross);
+ }
+
+ public boolean contains(Point2D p) {
+ return contains(p.getX(), p.getY());
+ }
+
+ public boolean contains(Rectangle2D r) {
+ return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ }
+
+ public boolean intersects(Rectangle2D r) {
+ return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ }
+
+ public PathIterator getPathIterator(AffineTransform t) {
+ return new Iterator(this, t);
+ }
+
+ public PathIterator getPathIterator(AffineTransform t, double flatness) {
+ return new FlatteningPathIterator(getPathIterator(t), flatness);
+ }
+
+ @Override
+ public Object clone() {
+ try {
+ GeneralPath p = (GeneralPath) super.clone();
+ p.types = types.clone();
+ p.points = points.clone();
+ return p;
+ } catch (CloneNotSupportedException e) {
+ throw new InternalError();
+ }
+ }
+
+}
+
diff --git a/awt/java/awt/geom/IllegalPathStateException.java b/awt/java/awt/geom/IllegalPathStateException.java
new file mode 100644
index 0000000..7f459e7
--- /dev/null
+++ b/awt/java/awt/geom/IllegalPathStateException.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+/**
+ * The Class IllegalPathStateException indicates errors where the
+ * current state of a path object is imcompatible with the desired
+ * action, such as performing non-trivial actions on an empty path.
+ */
+public class IllegalPathStateException extends RuntimeException {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -5158084205220481094L;
+
+ /**
+ * Instantiates a new illegal path state exception.
+ */
+ public IllegalPathStateException() {
+ }
+
+ /**
+ * Instantiates a new illegal path state exception with the
+ * specified detail message.
+ *
+ * @param s the details of the error
+ */
+ public IllegalPathStateException(String s) {
+ super(s);
+ }
+
+}
+
diff --git a/awt/java/awt/geom/Line2D.java b/awt/java/awt/geom/Line2D.java
new file mode 100644
index 0000000..a53c470
--- /dev/null
+++ b/awt/java/awt/geom/Line2D.java
@@ -0,0 +1,871 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class Line2D represents a line whose data is given in
+ * high-precision values appropriate for graphical operations.
+ */
+public abstract class Line2D implements Shape, Cloneable {
+
+ /**
+ * The Class Float is the subclass of Line2D that has all
+ * of its data values stored with float-level precision.
+ */
+ public static class Float extends Line2D {
+
+ /** The x coordinate of the starting point. */
+ public float x1;
+
+ /** The y coordinate of the starting point. */
+ public float y1;
+
+ /** The x coordinate of the end point. */
+ public float x2;
+
+ /** The y coordinate of the end point. */
+ public float y2;
+
+ /**
+ * Instantiates a new float-valued Line2D with
+ * its data values set to zero.
+ */
+ public Float() {
+ }
+
+ /**
+ * Instantiates a new float-valued Line2D with
+ * the specified endpoints.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ */
+ public Float(float x1, float y1, float x2, float y2) {
+ setLine(x1, y1, x2, y2);
+ }
+
+ /**
+ * Instantiates a new float-valued Line2D with
+ * the specified endpoints.
+ *
+ * @param p1 the starting point
+ * @param p2 the end point
+ */
+ public Float(Point2D p1, Point2D p2) {
+ setLine(p1, p2);
+ }
+
+ @Override
+ public double getX1() {
+ return x1;
+ }
+
+ @Override
+ public double getY1() {
+ return y1;
+ }
+
+ @Override
+ public double getX2() {
+ return x2;
+ }
+
+ @Override
+ public double getY2() {
+ return y2;
+ }
+
+ @Override
+ public Point2D getP1() {
+ return new Point2D.Float(x1, y1);
+ }
+
+ @Override
+ public Point2D getP2() {
+ return new Point2D.Float(x2, y2);
+ }
+
+ @Override
+ public void setLine(double x1, double y1, double x2, double y2) {
+ this.x1 = (float)x1;
+ this.y1 = (float)y1;
+ this.x2 = (float)x2;
+ this.y2 = (float)y2;
+ }
+
+ /**
+ * Sets the data values that define the line.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ */
+ public void setLine(float x1, float y1, float x2, float y2) {
+ this.x1 = x1;
+ this.y1 = y1;
+ this.x2 = x2;
+ this.y2 = y2;
+ }
+
+ public Rectangle2D getBounds2D() {
+ float rx, ry, rw, rh;
+ if (x1 < x2) {
+ rx = x1;
+ rw = x2 - x1;
+ } else {
+ rx = x2;
+ rw = x1 - x2;
+ }
+ if (y1 < y2) {
+ ry = y1;
+ rh = y2 - y1;
+ } else {
+ ry = y2;
+ rh = y1 - y2;
+ }
+ return new Rectangle2D.Float(rx, ry, rw, rh);
+ }
+ }
+
+ /**
+ * The Class Double is the subclass of Line2D that has all
+ * of its data values stored with double-level precision.
+ */
+ public static class Double extends Line2D {
+
+ /** The x coordinate of the starting point. */
+ public double x1;
+
+ /** The y coordinate of the starting point. */
+ public double y1;
+
+ /** The x coordinate of the end point. */
+ public double x2;
+
+ /** The y coordinate of the end point. */
+ public double y2;
+
+ /**
+ * Instantiates a new double-valued Line2D with
+ * its data values set to zero.
+ */
+ public Double() {
+ }
+
+ /**
+ * Instantiates a new double-valued Line2D with
+ * the specified endpoints.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ */
+ public Double(double x1, double y1, double x2, double y2) {
+ setLine(x1, y1, x2, y2);
+ }
+
+ /**
+ * Instantiates a new double-valued Line2D with
+ * the specified endpoints.
+ *
+ * @param p1 the starting point
+ * @param p2 the end point
+ */
+ public Double(Point2D p1, Point2D p2) {
+ setLine(p1, p2);
+ }
+
+ @Override
+ public double getX1() {
+ return x1;
+ }
+
+ @Override
+ public double getY1() {
+ return y1;
+ }
+
+ @Override
+ public double getX2() {
+ return x2;
+ }
+
+ @Override
+ public double getY2() {
+ return y2;
+ }
+
+ @Override
+ public Point2D getP1() {
+ return new Point2D.Double(x1, y1);
+ }
+
+ @Override
+ public Point2D getP2() {
+ return new Point2D.Double(x2, y2);
+ }
+
+ @Override
+ public void setLine(double x1, double y1, double x2, double y2) {
+ this.x1 = x1;
+ this.y1 = y1;
+ this.x2 = x2;
+ this.y2 = y2;
+ }
+
+ public Rectangle2D getBounds2D() {
+ double rx, ry, rw, rh;
+ if (x1 < x2) {
+ rx = x1;
+ rw = x2 - x1;
+ } else {
+ rx = x2;
+ rw = x1 - x2;
+ }
+ if (y1 < y2) {
+ ry = y1;
+ rh = y2 - y1;
+ } else {
+ ry = y2;
+ rh = y1 - y2;
+ }
+ return new Rectangle2D.Double(rx, ry, rw, rh);
+ }
+ }
+
+ /*
+ * Line2D path iterator
+ */
+ /**
+ * The subclass of PathIterator to traverse a Line2D.
+ */
+ class Iterator implements PathIterator {
+
+ /** The x coordinate of the start line point. */
+ double x1;
+
+ /** The y coordinate of the start line point. */
+ double y1;
+
+ /** The x coordinate of the end line point. */
+ double x2;
+
+ /** The y coordinate of the end line point. */
+ double y2;
+
+ /** The path iterator transformation. */
+ AffineTransform t;
+
+ /** The current segmenet index. */
+ int index;
+
+ /**
+ * Constructs a new Line2D.Iterator for given line and transformation
+ *
+ * @param l - the source Line2D object
+ * @param at - the AffineTransform object to apply rectangle path
+ */
+ Iterator(Line2D l, AffineTransform at) {
+ this.x1 = l.getX1();
+ this.y1 = l.getY1();
+ this.x2 = l.getX2();
+ this.y2 = l.getY2();
+ this.t = at;
+ }
+
+ public int getWindingRule() {
+ return WIND_NON_ZERO;
+ }
+
+ public boolean isDone() {
+ return index > 1;
+ }
+
+ public void next() {
+ index++;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ coords[0] = x1;
+ coords[1] = y1;
+ } else {
+ type = SEG_LINETO;
+ coords[0] = x2;
+ coords[1] = y2;
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, 1);
+ }
+ return type;
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ coords[0] = (float)x1;
+ coords[1] = (float)y1;
+ } else {
+ type = SEG_LINETO;
+ coords[0] = (float)x2;
+ coords[1] = (float)y2;
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, 1);
+ }
+ return type;
+ }
+
+ }
+
+ /**
+ * Instantiates a new Line2D.
+ */
+ protected Line2D() {
+ }
+
+ /**
+ * Gets the x coordinate of the starting point.
+ *
+ * @return the x coordinate of the starting point
+ */
+ public abstract double getX1();
+
+ /**
+ * Gets the y coordinate of the starting point.
+ *
+ * @return the y coordinate of the starting point
+ */
+ public abstract double getY1();
+
+ /**
+ * Gets the x coordinate of the end point.
+ *
+ * @return the x2
+ */
+ public abstract double getX2();
+
+ /**
+ * Gets the y coordinate of the end point.
+ *
+ * @return the y coordinate of the end point
+ */
+ public abstract double getY2();
+
+ /**
+ * Gets the p the starting point.
+ *
+ * @return the p the starting point
+ */
+ public abstract Point2D getP1();
+
+ /**
+ * Gets the p end point.
+ *
+ * @return the p end point
+ */
+ public abstract Point2D getP2();
+
+ /**
+ * Sets the line's endpoints.
+ *
+ * @param x1 the x coordinate of the starting point
+ * @param y1 the y coordinate of the starting point
+ * @param x2 the x coordinate of the end point
+ * @param y2 the y coordinate of the end point
+ */
+ public abstract void setLine(double x1, double y1, double x2, double y2);
+
+ /**
+ * Sets the line's endpoints.
+ *
+ * @param p1 the starting point
+ * @param p2 the end point
+ */
+ public void setLine(Point2D p1, Point2D p2) {
+ setLine(p1.getX(), p1.getY(), p2.getX(), p2.getY());
+ }
+
+ /**
+ * Sets the line's endpoints by copying the data from another Line2D.
+ *
+ * @param line the Line2D to copy the endpoint data from
+ */
+ public void setLine(Line2D line) {
+ setLine(line.getX1(), line.getY1(), line.getX2(), line.getY2());
+ }
+
+ public Rectangle getBounds() {
+ return getBounds2D().getBounds();
+ }
+
+ /**
+ * Tells where the point is with respect to the line segment,
+ * given the orientation of the line segment. If the ray
+ * found by extending the line segment from its starting point
+ * is rotated, this method tells whether the ray
+ * should rotate in a clockwise direction or a counter-clockwise
+ * direction to hit the point first. The return value is 0 if the
+ * point is on the line segment, it's 1 if the point is on the ray
+ * or if the ray should rotate in a counter-clockwise direction to get to the
+ * point, and it's -1 if the ray should rotate in a clockwise
+ * direction to get to the point or if the point is on the line
+ * determined by the line segment but not on the ray from the
+ * segment's starting point and through its end point.
+ *
+ * @param x1 the x coordinate of the starting point of the line segment
+ * @param y1 the y coordinate of the starting point of the line segment
+ * @param x2 the x coordinate of the end point of the line segment
+ * @param y2 the y coordinate of the end point of the line segment
+ * @param px the x coordinate of the test point
+ * @param py the p coordinate of the test point
+ *
+ * @return the value that describes where the point is with respect to the line segment,
+ * given the orientation of the line segment
+ */
+ public static int relativeCCW(double x1, double y1, double x2, double y2, double px, double py) {
+ /*
+ * A = (x2-x1, y2-y1) P = (px-x1, py-y1)
+ */
+ x2 -= x1;
+ y2 -= y1;
+ px -= x1;
+ py -= y1;
+ double t = px * y2 - py * x2; // PxA
+ if (t == 0.0) {
+ t = px * x2 + py * y2; // P*A
+ if (t > 0.0) {
+ px -= x2; // B-A
+ py -= y2;
+ t = px * x2 + py * y2; // (P-A)*A
+ if (t < 0.0) {
+ t = 0.0;
+ }
+ }
+ }
+
+ return t < 0.0 ? -1 : (t > 0.0 ? 1 : 0);
+ }
+
+ /**
+ * Tells where the point is with respect to this line segment,
+ * given the orientation of this line segment. If the ray
+ * found by extending the line segment from its starting point
+ * is rotated, this method tells whether the ray
+ * should rotate in a clockwise direction or a counter-clockwise
+ * direction to hit the point first. The return value is 0 if the
+ * point is on the line segment, it's 1 if the point is on the ray
+ * or if the ray should rotate in a counter-clockwise direction to get to the
+ * point, and it's -1 if the ray should rotate in a clockwise
+ * direction to get to the point or if the point is on the line
+ * determined by the line segment but not on the ray from the
+ * segment's starting point and through its end point.
+ *
+ * @param px the x coordinate of the test point
+ * @param py the p coordinate of the test point
+ *
+ * @return the value that describes where the point is with respect to
+ * this line segment, given the orientation of this line segment
+ */
+ public int relativeCCW(double px, double py) {
+ return relativeCCW(getX1(), getY1(), getX2(), getY2(), px, py);
+ }
+
+ /**
+ * Tells where the point is with respect to this line segment,
+ * given the orientation of this line segment. If the ray
+ * found by extending the line segment from its starting point
+ * is rotated, this method tells whether the ray
+ * should rotate in a clockwise direction or a counter-clockwise
+ * direction to hit the point first. The return value is 0 if the
+ * point is on the line segment, it's 1 if the point is on the ray
+ * or if the ray should rotate in a counter-clockwise direction to get to the
+ * point, and it's -1 if the ray should rotate in a clockwise
+ * direction to get to the point or if the point is on the line
+ * determined by the line segment but not on the ray from the
+ * segment's starting point and through its end point.
+ *
+ * @param p the test point
+ *
+ * @return the value that describes where the point is with respect to
+ * this line segment, given the orientation of this line segment
+ */
+ public int relativeCCW(Point2D p) {
+ return relativeCCW(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
+ }
+
+ /**
+ * Tells whether the two line segments cross.
+ *
+ * @param x1 the x coordinate of the starting point of the first segment
+ * @param y1 the y coordinate of the starting point of the first segment
+ * @param x2 the x coordinate of the end point of the first segment
+ * @param y2 the y coordinate of the end point of the first segment
+ * @param x3 the x coordinate of the starting point of the second segment
+ * @param y3 the y coordinate of the starting point of the second segment
+ * @param x4 the x coordinate of the end point of the second segment
+ * @param y4 the y coordinate of the end point of the second segment
+ *
+ * @return true, if the two line segments cross
+ */
+ public static boolean linesIntersect(double x1, double y1, double x2,
+ double y2, double x3, double y3, double x4, double y4)
+ {
+ /*
+ * A = (x2-x1, y2-y1) B = (x3-x1, y3-y1) C = (x4-x1, y4-y1) D = (x4-x3,
+ * y4-y3) = C-B E = (x1-x3, y1-y3) = -B F = (x2-x3, y2-y3) = A-B
+ *
+ * Result is ((AxB) * (AxC) <=0) and ((DxE) * (DxF) <= 0)
+ *
+ * DxE = (C-B)x(-B) = BxB-CxB = BxC DxF = (C-B)x(A-B) = CxA-CxB-BxA+BxB =
+ * AxB+BxC-AxC
+ */
+
+ x2 -= x1; // A
+ y2 -= y1;
+ x3 -= x1; // B
+ y3 -= y1;
+ x4 -= x1; // C
+ y4 -= y1;
+
+ double AvB = x2 * y3 - x3 * y2;
+ double AvC = x2 * y4 - x4 * y2;
+
+ // Online
+ if (AvB == 0.0 && AvC == 0.0) {
+ if (x2 != 0.0) {
+ return
+ (x4 * x3 <= 0.0) ||
+ ((x3 * x2 >= 0.0) &&
+ (x2 > 0.0 ? x3 <= x2 || x4 <= x2 : x3 >= x2 || x4 >= x2));
+ }
+ if (y2 != 0.0) {
+ return
+ (y4 * y3 <= 0.0) ||
+ ((y3 * y2 >= 0.0) &&
+ (y2 > 0.0 ? y3 <= y2 || y4 <= y2 : y3 >= y2 || y4 >= y2));
+ }
+ return false;
+ }
+
+ double BvC = x3 * y4 - x4 * y3;
+
+ return (AvB * AvC <= 0.0) && (BvC * (AvB + BvC - AvC) <= 0.0);
+ }
+
+ /**
+ * Tells whether the specified line segments crosses this line segment.
+ *
+ * @param x1 the x coordinate of the starting point of the test segment
+ * @param y1 the y coordinate of the starting point of the test segment
+ * @param x2 the x coordinate of the end point of the test segment
+ * @param y2 the y coordinate of the end point of the test segment
+ *
+ * @return true, if the specified line segments crosses this line segment
+ */
+ public boolean intersectsLine(double x1, double y1, double x2, double y2) {
+ return linesIntersect(x1, y1, x2, y2, getX1(), getY1(), getX2(), getY2());
+ }
+
+ /**
+ * Tells whether the specified line segments crosses this line segment.
+ *
+ * @param l the test segment
+ *
+ * @return true, if the specified line segments crosses this line segment
+ *
+ * @throws NullPointerException if l is null
+ */
+ public boolean intersectsLine(Line2D l) {
+ return linesIntersect(l.getX1(), l.getY1(), l.getX2(), l.getY2(), getX1(), getY1(), getX2(), getY2());
+ }
+
+ /**
+ * Gives the square of the distance between the point and the
+ * line segment.
+ *
+ * @param x1 the x coordinate of the starting point of the line segment
+ * @param y1 the y coordinate of the starting point of the line segment
+ * @param x2 the x coordinate of the end point of the line segment
+ * @param y2 the y coordinate of the end point of the line segment
+ * @param px the x coordinate of the test point
+ * @param py the y coordinate of the test point
+ *
+ * @return the the square of the distance between the point and the
+ * line segment
+ */
+ public static double ptSegDistSq(double x1, double y1, double x2, double y2, double px, double py) {
+ /*
+ * A = (x2 - x1, y2 - y1) P = (px - x1, py - y1)
+ */
+ x2 -= x1; // A = (x2, y2)
+ y2 -= y1;
+ px -= x1; // P = (px, py)
+ py -= y1;
+ double dist;
+ if (px * x2 + py * y2 <= 0.0) { // P*A
+ dist = px * px + py * py;
+ } else {
+ px = x2 - px; // P = A - P = (x2 - px, y2 - py)
+ py = y2 - py;
+ if (px * x2 + py * y2 <= 0.0) { // P*A
+ dist = px * px + py * py;
+ } else {
+ dist = px * y2 - py * x2;
+ dist = dist * dist / (x2 * x2 + y2 * y2); // pxA/|A|
+ }
+ }
+ if (dist < 0) {
+ dist = 0;
+ }
+ return dist;
+ }
+
+ /**
+ * Gives the distance between the point and the
+ * line segment.
+ *
+ * @param x1 the x coordinate of the starting point of the line segment
+ * @param y1 the y coordinate of the starting point of the line segment
+ * @param x2 the x coordinate of the end point of the line segment
+ * @param y2 the y coordinate of the end point of the line segment
+ * @param px the x coordinate of the test point
+ * @param py the y coordinate of the test point
+ *
+ * @return the the distance between the point and the
+ * line segment
+ */
+ public static double ptSegDist(double x1, double y1, double x2, double y2, double px, double py) {
+ return Math.sqrt(ptSegDistSq(x1, y1, x2, y2, px, py));
+ }
+
+ /**
+ * Gives the square of the distance between the point and this
+ * line segment.
+ *
+ * @param px the x coordinate of the test point
+ * @param py the y coordinate of the test point
+ *
+ * @return the the square of the distance between the point and this
+ * line segment
+ */
+ public double ptSegDistSq(double px, double py) {
+ return ptSegDistSq(getX1(), getY1(), getX2(), getY2(), px, py);
+ }
+
+ /**
+ * Gives the square of the distance between the point and this
+ * line segment.
+ *
+ * @param p the test point
+ *
+ * @return the square of the distance between the point and this
+ * line segment
+ */
+ public double ptSegDistSq(Point2D p) {
+ return ptSegDistSq(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
+ }
+
+ /**
+ * Gives the distance between the point and this
+ * line segment.
+ *
+ * @param px the x coordinate of the test point
+ * @param py the y coordinate of the test point
+ *
+ * @return the distance between the point and this
+ * line segment
+ */
+ public double ptSegDist(double px, double py) {
+ return ptSegDist(getX1(), getY1(), getX2(), getY2(), px, py);
+ }
+
+ /**
+ * Gives the distance between the point and this
+ * line segment.
+ *
+ * @param p the test point
+ *
+ * @return the distance between the point and this
+ * line segment
+ */
+ public double ptSegDist(Point2D p) {
+ return ptSegDist(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
+ }
+
+ /**
+ * Gives the square of the distance between the point and the
+ * line.
+ *
+ * @param x1 the x coordinate of the starting point of the line segment
+ * @param y1 the y coordinate of the starting point of the line segment
+ * @param x2 the x coordinate of the end point of the line segment
+ * @param y2 the y coordinate of the end point of the line segment
+ * @param px the x coordinate of the test point
+ * @param py the y coordinate of the test point
+ *
+ * @return the square of the distance between the point and the
+ * line
+ */
+ public static double ptLineDistSq(double x1, double y1, double x2, double y2, double px, double py) {
+ x2 -= x1;
+ y2 -= y1;
+ px -= x1;
+ py -= y1;
+ double s = px * y2 - py * x2;
+ return s * s / (x2 * x2 + y2 * y2);
+ }
+
+ /**
+ * Gives the square of the distance between the point and the
+ * line.
+ *
+ * @param x1 the x coordinate of the starting point of the line segment
+ * @param y1 the y coordinate of the starting point of the line segment
+ * @param x2 the x coordinate of the end point of the line segment
+ * @param y2 the y coordinate of the end point of the line segment
+ * @param px the x coordinate of the test point
+ * @param py the y coordinate of the test point
+ *
+ * @return the square of the distance between the point and the
+ * line
+ */
+ public static double ptLineDist(double x1, double y1, double x2, double y2, double px, double py) {
+ return Math.sqrt(ptLineDistSq(x1, y1, x2, y2, px, py));
+ }
+
+ /**
+ * Gives the square of the distance between the point and the
+ * line determined by this Line2D.
+ *
+ * @param px the x coordinate of the test point
+ * @param py the y coordinate of the test point
+ *
+ * @return the square of the distance between the point and the
+ * line determined by this Line2D
+ */
+ public double ptLineDistSq(double px, double py) {
+ return ptLineDistSq(getX1(), getY1(), getX2(), getY2(), px, py);
+ }
+
+ /**
+ * Gives the square of the distance between the point and the
+ * line determined by this Line2D.
+ *
+ * @param p the test point
+ *
+ * @return the square of the distance between the point and the
+ * line determined by this Line2D
+ */
+ public double ptLineDistSq(Point2D p) {
+ return ptLineDistSq(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
+ }
+
+ /**
+ * Gives the distance between the point and the
+ * line determined by this Line2D.
+ *
+ * @param px the x coordinate of the test point
+ * @param py the y coordinate of the test point
+ *
+ * @return the distance between the point and the
+ * line determined by this Line2D
+ */
+ public double ptLineDist(double px, double py) {
+ return ptLineDist(getX1(), getY1(), getX2(), getY2(), px, py);
+ }
+
+ /**
+ * Gives the distance between the point and the
+ * line determined by this Line2D.
+ *
+ * @param p the test point
+ *
+ * @return the distance between the point and the
+ * line determined by this Line2D
+ */
+ public double ptLineDist(Point2D p) {
+ return ptLineDist(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
+ }
+
+ public boolean contains(double px, double py) {
+ return false;
+ }
+
+ public boolean contains(Point2D p) {
+ return false;
+ }
+
+ public boolean contains(Rectangle2D r) {
+ return false;
+ }
+
+ public boolean contains(double rx, double ry, double rw, double rh) {
+ return false;
+ }
+
+ public boolean intersects(double rx, double ry, double rw, double rh) {
+ return intersects(new Rectangle2D.Double(rx, ry, rw, rh));
+ }
+
+ public boolean intersects(Rectangle2D r) {
+ return r.intersectsLine(getX1(), getY1(), getX2(), getY2());
+ }
+
+ public PathIterator getPathIterator(AffineTransform at) {
+ return new Iterator(this, at);
+ }
+
+ public PathIterator getPathIterator(AffineTransform at, double flatness) {
+ return new Iterator(this, at);
+ }
+
+ @Override
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ throw new InternalError();
+ }
+ }
+
+}
diff --git a/awt/java/awt/geom/NoninvertibleTransformException.java b/awt/java/awt/geom/NoninvertibleTransformException.java
new file mode 100644
index 0000000..2b7b542
--- /dev/null
+++ b/awt/java/awt/geom/NoninvertibleTransformException.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+/**
+ * The Class NoninvertibleTransformException is the exception that is thrown
+ * when an action requires inverting an {@link AffineTransform} that is
+ * not invertible (has determinant 0).
+ */
+public class NoninvertibleTransformException extends java.lang.Exception {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 6137225240503990466L;
+
+ /**
+ * Instantiates a new noninvertible transform exception.
+ *
+ * @param s the error message
+ */
+ public NoninvertibleTransformException(String s) {
+ super(s);
+ }
+
+}
+
diff --git a/awt/java/awt/geom/PathIterator.java b/awt/java/awt/geom/PathIterator.java
new file mode 100644
index 0000000..5a98083
--- /dev/null
+++ b/awt/java/awt/geom/PathIterator.java
@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+/**
+ * The Interface PathIterator represents an iterator object that can
+ * be used to traverse the outline of a {@link java.awt.Shape}.
+ * It returns points along the boundary of the Shape
+ * which may be actual vertices (in the case of a shape made of line
+ * segments) or may be points on a curved segment with the distance
+ * between the points determined by a chosen flattening factor.
+ * <p>
+ * If the shape is closed, the outline is traversed in the counter-clockwise
+ * direction. That means that moving forward along the boundary is to travel
+ * in such a way that the interior of the shape is to the left of the
+ * outline path and the exterior of the shape is to the right of the outline
+ * path. The interior and exterior of the shape are determined by a
+ * winding rule.
+ */
+public interface PathIterator {
+
+ /** The Constant WIND_EVEN_ODD indicates the winding rule that says
+ * that a point is outside the shape if any infinite ray from the point
+ * crosses the outline of the shape an even number of times, otherwise
+ * it is inside. */
+ public static final int WIND_EVEN_ODD = 0;
+
+ /** The Constant WIND_NON_ZERO indicates the winding rule that says that
+ * a point is inside the shape if every infinite ray starting from that
+ * point crosses the outline of the shape a non-zero number of times. */
+ public static final int WIND_NON_ZERO = 1;
+
+ /** The Constant SEG_MOVETO indicates that to follow the shape's outline
+ * from the previous point to the current point, the cursor (traversal
+ * point) should be placed directly on the current point. */
+ public static final int SEG_MOVETO = 0;
+
+ /** The Constant SEG_LINETO indicates that to follow the shape's outline
+ * from the previous point to the current point, the cursor (traversal
+ * point) should follow a straight line. */
+ public static final int SEG_LINETO = 1;
+
+ /** The Constant SEG_QUADTO indicates that to follow the shape's outline
+ * from the previous point to the current point, the cursor (traversal
+ * point) should follow a quadratic curve. */
+ public static final int SEG_QUADTO = 2;
+
+ /** The Constant SEG_CUBICTO indicates that to follow the shape's outline
+ * from the previous point to the current point, the cursor (traversal
+ * point) should follow a cubic curve. */
+ public static final int SEG_CUBICTO = 3;
+
+ /** The Constant SEG_CLOSE indicates that the previous point was the end
+ * of the shape's outline. */
+ public static final int SEG_CLOSE = 4;
+
+ /**
+ * Gets the winding rule, either {@link PathIterator#WIND_EVEN_ODD} or
+ * {@link PathIterator#WIND_NON_ZERO}.
+ *
+ * @return the winding rule
+ */
+ public int getWindingRule();
+
+ /**
+ * Checks if this PathIterator has been completely traversed.
+ *
+ * @return true, if this PathIterator has been completely traversed
+ */
+ public boolean isDone();
+
+ /**
+ * Tells this PathIterator to skip to the next segment.
+ */
+ public void next();
+
+ /**
+ * Gets the coordinates of the next vertex point along the shape's outline
+ * and a flag that indicates what kind of segment to use in order to
+ * connect the previous vertex point to the current vertex point to form
+ * the current segment.
+ *
+ * @param coords the array that the coordinates of the end point of the current
+ * segment are written into.
+ *
+ * @return the flag that indicates how to follow the shape's outline
+ * from the previous point to the current one, chosen from
+ * the following constants:
+ * {@link PathIterator#SEG_MOVETO}, {@link PathIterator#SEG_LINETO},
+ * {@link PathIterator#SEG_QUADTO}, {@link PathIterator#SEG_CUBICTO},
+ * or {@link PathIterator#SEG_CLOSE}
+ */
+ public int currentSegment(float[] coords);
+
+ /**
+ * Gets the coordinates of the next vertex point along the shape's outline
+ * and a flag that indicates what kind of segment to use in order to
+ * connect the previous vertex point to the current vertex point to form
+ * the current segment.
+ *
+ * @param coords the array that the coordinates of the end point of the current
+ * segment are written into.
+ *
+ * @return the flag that indicates how to follow the shape's outline
+ * from the previous point to the current one, chosen from
+ * the following constants:
+ * {@link PathIterator#SEG_MOVETO}, {@link PathIterator#SEG_LINETO},
+ * {@link PathIterator#SEG_QUADTO}, {@link PathIterator#SEG_CUBICTO},
+ * or {@link PathIterator#SEG_CLOSE}
+ */
+ public int currentSegment(double[] coords);
+
+}
+
diff --git a/awt/java/awt/geom/Point2D.java b/awt/java/awt/geom/Point2D.java
new file mode 100644
index 0000000..7719e67
--- /dev/null
+++ b/awt/java/awt/geom/Point2D.java
@@ -0,0 +1,288 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import org.apache.harmony.misc.HashCode;
+
+/**
+ * The Class Point2D represents a point whose data is given in
+ * high-precision values appropriate for graphical operations.
+ */
+public abstract class Point2D implements Cloneable {
+
+ /**
+ * The Class Float is the subclass of Point2D that has all
+ * of its data values stored with float-level precision.
+ */
+ public static class Float extends Point2D {
+
+ /** The x coordinate. */
+ public float x;
+
+ /** The y coordinate. */
+ public float y;
+
+ /**
+ * Instantiates a new float-valued Point2D with its data
+ * set to zero.
+ */
+ public Float() {
+ }
+
+ /**
+ * Instantiates a new float-valued Point2D with the specified coordinates.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+ public Float(float x, float y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ /**
+ * Sets the point's coordinates.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+ public void setLocation(float x, float y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ @Override
+ public void setLocation(double x, double y) {
+ this.x = (float)x;
+ this.y = (float)y;
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getName() + "[x=" + x + ",y=" + y + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+ }
+
+ /**
+ * The Class Double is the subclass of Point2D that has all
+ * of its data values stored with double-level precision.
+ */
+ public static class Double extends Point2D {
+
+ /** The x coordinate. */
+ public double x;
+
+ /** The y coordinate. */
+ public double y;
+
+ /**
+ * Instantiates a new double-valued Point2D with its data
+ * set to zero.
+ */
+ public Double() {
+ }
+
+ /**
+ * Instantiates a new double-valued Point2D with the specified coordinates.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+ public Double(double x, double y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public void setLocation(double x, double y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getName() + "[x=" + x + ",y=" + y + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+ }
+
+ /**
+ * Instantiates a new Point2D.
+ */
+ protected Point2D() {
+ }
+
+ /**
+ * Gets the x coordinate.
+ *
+ * @return the x coordinate
+ */
+ public abstract double getX();
+
+ /**
+ * Gets the y coordinate.
+ *
+ * @return the y coordinate
+ */
+ public abstract double getY();
+
+ /**
+ * Sets the point's coordinates.
+ *
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+ public abstract void setLocation(double x, double y);
+
+ /**
+ * Sets the point's coordinates by copying them from another point.
+ *
+ * @param p the point to copy the data from
+ */
+ public void setLocation(Point2D p) {
+ setLocation(p.getX(), p.getY());
+ }
+
+ /**
+ * Finds the square of the distance between the two specified points.
+ *
+ * @param x1 the x coordinate of the first point
+ * @param y1 the y coordinate of the first point
+ * @param x2 the x coordinate of the second point
+ * @param y2 the y coordinate of the second point
+ *
+ * @return the square of the distance between the two specified points
+ */
+ public static double distanceSq(double x1, double y1, double x2, double y2) {
+ x2 -= x1;
+ y2 -= y1;
+ return x2 * x2 + y2 * y2;
+ }
+
+ /**
+ * Finds the square of the distance between this point and the specified point.
+ *
+ * @param px the x coordinate of the point
+ * @param py the y coordinate of the point
+ *
+ * @return the square of the distance between this point and the specified point
+ */
+ public double distanceSq(double px, double py) {
+ return Point2D.distanceSq(getX(), getY(), px, py);
+ }
+
+ /**
+ * Finds the square of the distance between this point and the specified point.
+ *
+ * @param p the other point
+ *
+ * @return the square of the distance between this point and the specified point
+ */
+ public double distanceSq(Point2D p) {
+ return Point2D.distanceSq(getX(), getY(), p.getX(), p.getY());
+ }
+
+ /**
+ * Finds the distance between the two specified points.
+ *
+ * @param x1 the x coordinate of the first point
+ * @param y1 the y coordinate of the first point
+ * @param x2 the x coordinate of the second point
+ * @param y2 the y coordinate of the second point
+ *
+ * @return the distance between the two specified points
+ */
+ public static double distance(double x1, double y1, double x2, double y2) {
+ return Math.sqrt(distanceSq(x1, y1, x2, y2));
+ }
+
+ /**
+ * Finds the distance between this point and the specified point.
+ *
+ * @param px the x coordinate of the point
+ * @param py the y coordinate of the point
+ *
+ * @return the distance between this point and the specified point
+ */
+ public double distance(double px, double py) {
+ return Math.sqrt(distanceSq(px, py));
+ }
+
+ /**
+ * Finds the distance between this point and the specified point.
+ *
+ * @param p the other point
+ *
+ * @return the distance between this point and the specified point
+ */
+ public double distance(Point2D p) {
+ return Math.sqrt(distanceSq(p));
+ }
+
+ @Override
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ throw new InternalError();
+ }
+ }
+
+ @Override
+ public int hashCode() {
+ HashCode hash = new HashCode();
+ hash.append(getX());
+ hash.append(getY());
+ return hash.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (obj instanceof Point2D) {
+ Point2D p = (Point2D) obj;
+ return getX() == p.getX() && getY() == p.getY();
+ }
+ return false;
+ }
+}
+
diff --git a/awt/java/awt/geom/QuadCurve2D.java b/awt/java/awt/geom/QuadCurve2D.java
new file mode 100644
index 0000000..64ea6d6
--- /dev/null
+++ b/awt/java/awt/geom/QuadCurve2D.java
@@ -0,0 +1,824 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.gl.Crossing;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class QuadCurve2D is a Shape that represents a segment of a
+ * quadratic (Bezier) curve. The curved segment is determined by three points:
+ * a start point, an end point, and a control point. The line from the control
+ * point to the starting point gives the tangent to the curve at the
+ * starting point, and the line from the control point to the end point
+ * gives the tangent to the curve at the end point.
+ */
+public abstract class QuadCurve2D implements Shape, Cloneable {
+
+ /**
+ * The Class Float is the subclass of QuadCurve2D that has all
+ * of its data values stored with float-level precision.
+ */
+ public static class Float extends QuadCurve2D {
+
+ /** The x coordinate of the starting point of the curved segment. */
+ public float x1;
+
+ /** The y coordinate of the starting point of the curved segment. */
+ public float y1;
+
+ /** The x coordinate of the control point. */
+ public float ctrlx;
+
+ /** The y coordinate of the control point. */
+ public float ctrly;
+
+ /** The x coordinate of the end point of the curved segment. */
+ public float x2;
+
+ /** The y coordinate of the end point of the curved segment. */
+ public float y2;
+
+ /**
+ * Instantiates a new float-valued QuadCurve2D with all coordinate values
+ * set to zero.
+ */
+ public Float() {
+ }
+
+ /**
+ * Instantiates a new float-valued QuadCurve2D with the specified
+ * coordinate values.
+ *
+ * @param x1 the x coordinate of the starting point of the curved segment
+ * @param y1 the y coordinate of the starting point of the curved segment
+ * @param ctrlx the x coordinate of the control point
+ * @param ctrly the y coordinate of the control point
+ * @param x2 the x coordinate of the end point of the curved segment
+ * @param y2 the y coordinate of the end point of the curved segment
+ */
+ public Float(float x1, float y1, float ctrlx, float ctrly, float x2, float y2) {
+ setCurve(x1, y1, ctrlx, ctrly, x2, y2);
+ }
+
+ @Override
+ public double getX1() {
+ return x1;
+ }
+
+ @Override
+ public double getY1() {
+ return y1;
+ }
+
+ @Override
+ public double getCtrlX() {
+ return ctrlx;
+ }
+
+ @Override
+ public double getCtrlY() {
+ return ctrly;
+ }
+
+ @Override
+ public double getX2() {
+ return x2;
+ }
+
+ @Override
+ public double getY2() {
+ return y2;
+ }
+
+ @Override
+ public Point2D getP1() {
+ return new Point2D.Float(x1, y1);
+ }
+
+ @Override
+ public Point2D getCtrlPt() {
+ return new Point2D.Float(ctrlx, ctrly);
+ }
+
+ @Override
+ public Point2D getP2() {
+ return new Point2D.Float(x2, y2);
+ }
+
+ @Override
+ public void setCurve(double x1, double y1, double ctrlx, double ctrly, double x2, double y2) {
+ this.x1 = (float)x1;
+ this.y1 = (float)y1;
+ this.ctrlx = (float)ctrlx;
+ this.ctrly = (float)ctrly;
+ this.x2 = (float)x2;
+ this.y2 = (float)y2;
+ }
+
+ /**
+ * Sets the data values of the curve.
+ *
+ * @param x1 the x coordinate of the starting point of the curved segment
+ * @param y1 the y coordinate of the starting point of the curved segment
+ * @param ctrlx the x coordinate of the control point
+ * @param ctrly the y coordinate of the control point
+ * @param x2 the x coordinate of the end point of the curved segment
+ * @param y2 the y coordinate of the end point of the curved segment
+ */
+ public void setCurve(float x1, float y1, float ctrlx, float ctrly, float x2, float y2) {
+ this.x1 = x1;
+ this.y1 = y1;
+ this.ctrlx = ctrlx;
+ this.ctrly = ctrly;
+ this.x2 = x2;
+ this.y2 = y2;
+ }
+
+ public Rectangle2D getBounds2D() {
+ float rx0 = Math.min(Math.min(x1, x2), ctrlx);
+ float ry0 = Math.min(Math.min(y1, y2), ctrly);
+ float rx1 = Math.max(Math.max(x1, x2), ctrlx);
+ float ry1 = Math.max(Math.max(y1, y2), ctrly);
+ return new Rectangle2D.Float(rx0, ry0, rx1 - rx0, ry1 - ry0);
+ }
+ }
+
+ /**
+ * The Class Double is the subclass of QuadCurve2D that has all
+ * of its data values stored with double-level precision.
+ */
+ public static class Double extends QuadCurve2D {
+
+ /** The x coordinate of the starting point of the curved segment. */
+ public double x1;
+
+ /** The y coordinate of the starting point of the curved segment. */
+ public double y1;
+
+ /** The x coordinate of the control point. */
+ public double ctrlx;
+
+ /** The y coordinate of the control point. */
+ public double ctrly;
+
+ /** The x coordinate of the end point of the curved segment. */
+ public double x2;
+
+ /** The y coordinate of the end point of the curved segment. */
+ public double y2;
+
+ /**
+ * Instantiates a new double-valued QuadCurve2D with all coordinate values
+ * set to zero.
+ */
+ public Double() {
+ }
+
+ /**
+ * Instantiates a new double-valued QuadCurve2D with the specified
+ * coordinate values.
+ *
+ * @param x1 the x coordinate of the starting point of the curved segment
+ * @param y1 the y coordinate of the starting point of the curved segment
+ * @param ctrlx the x coordinate of the control point
+ * @param ctrly the y coordinate of the control point
+ * @param x2 the x coordinate of the end point of the curved segment
+ * @param y2 the y coordinate of the end point of the curved segment
+ */
+ public Double(double x1, double y1, double ctrlx, double ctrly, double x2, double y2) {
+ setCurve(x1, y1, ctrlx, ctrly, x2, y2);
+ }
+
+ @Override
+ public double getX1() {
+ return x1;
+ }
+
+ @Override
+ public double getY1() {
+ return y1;
+ }
+
+ @Override
+ public double getCtrlX() {
+ return ctrlx;
+ }
+
+ @Override
+ public double getCtrlY() {
+ return ctrly;
+ }
+
+ @Override
+ public double getX2() {
+ return x2;
+ }
+
+ @Override
+ public double getY2() {
+ return y2;
+ }
+
+ @Override
+ public Point2D getP1() {
+ return new Point2D.Double(x1, y1);
+ }
+
+ @Override
+ public Point2D getCtrlPt() {
+ return new Point2D.Double(ctrlx, ctrly);
+ }
+
+ @Override
+ public Point2D getP2() {
+ return new Point2D.Double(x2, y2);
+ }
+
+ @Override
+ public void setCurve(double x1, double y1, double ctrlx, double ctrly, double x2, double y2) {
+ this.x1 = x1;
+ this.y1 = y1;
+ this.ctrlx = ctrlx;
+ this.ctrly = ctrly;
+ this.x2 = x2;
+ this.y2 = y2;
+ }
+
+ public Rectangle2D getBounds2D() {
+ double rx0 = Math.min(Math.min(x1, x2), ctrlx);
+ double ry0 = Math.min(Math.min(y1, y2), ctrly);
+ double rx1 = Math.max(Math.max(x1, x2), ctrlx);
+ double ry1 = Math.max(Math.max(y1, y2), ctrly);
+ return new Rectangle2D.Double(rx0, ry0, rx1 - rx0, ry1 - ry0);
+ }
+ }
+
+ /*
+ * QuadCurve2D path iterator
+ */
+ /**
+ * The PathIterator for a Quad2D curve.
+ */
+ class Iterator implements PathIterator {
+
+ /** The source QuadCurve2D object. */
+ QuadCurve2D c;
+
+ /** The path iterator transformation. */
+ AffineTransform t;
+
+ /** The current segment index. */
+ int index;
+
+ /**
+ * Constructs a new QuadCurve2D.Iterator for given curve and transformation
+ *
+ * @param q - the source QuadCurve2D object
+ * @param t the AffineTransform that acts on the coordinates before
+ * returning them (or null)
+ */
+ Iterator(QuadCurve2D q, AffineTransform t) {
+ this.c = q;
+ this.t = t;
+ }
+
+ public int getWindingRule() {
+ return WIND_NON_ZERO;
+ }
+
+ public boolean isDone() {
+ return (index > 1);
+ }
+
+ public void next() {
+ index++;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type;
+ int count;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ coords[0] = c.getX1();
+ coords[1] = c.getY1();
+ count = 1;
+ } else {
+ type = SEG_QUADTO;
+ coords[0] = c.getCtrlX();
+ coords[1] = c.getCtrlY();
+ coords[2] = c.getX2();
+ coords[3] = c.getY2();
+ count = 2;
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count);
+ }
+ return type;
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ int type;
+ int count;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ coords[0] = (float)c.getX1();
+ coords[1] = (float)c.getY1();
+ count = 1;
+ } else {
+ type = SEG_QUADTO;
+ coords[0] = (float)c.getCtrlX();
+ coords[1] = (float)c.getCtrlY();
+ coords[2] = (float)c.getX2();
+ coords[3] = (float)c.getY2();
+ count = 2;
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, count);
+ }
+ return type;
+ }
+
+ }
+
+ /**
+ * Instantiates a new quadratic curve.
+ */
+ protected QuadCurve2D() {
+ }
+
+ /**
+ * Gets the x coordinate of the starting point.
+ *
+ * @return the x coordinate of the starting point
+ */
+ public abstract double getX1();
+
+ /**
+ * Gets the y coordinate of the starting point.
+ *
+ * @return the y coordinate of the starting point
+ */
+ public abstract double getY1();
+
+ /**
+ * Gets the starting point.
+ *
+ * @return the starting point
+ */
+ public abstract Point2D getP1();
+
+ /**
+ * Gets the x coordinate of the control point.
+ *
+ * @return the x coordinate of the control point
+ */
+ public abstract double getCtrlX();
+
+ /**
+ * Gets the y coordinate of the control point.
+ *
+ * @return y coordinate of the control point
+ */
+ public abstract double getCtrlY();
+
+ /**
+ * Gets the control point.
+ *
+ * @return the control point
+ */
+ public abstract Point2D getCtrlPt();
+
+ /**
+ * Gets the x coordinate of the end point.
+ *
+ * @return the x coordinate of the end point
+ */
+ public abstract double getX2();
+
+ /**
+ * Gets the y coordinate of the end point.
+ *
+ * @return the y coordinate of the end point
+ */
+ public abstract double getY2();
+
+ /**
+ * Gets the end point.
+ *
+ * @return the end point
+ */
+ public abstract Point2D getP2();
+
+ /**
+ * Sets the data of the curve.
+ *
+ * @param x1 the x coordinate of the starting point of the curved segment
+ * @param y1 the y coordinate of the starting point of the curved segment
+ * @param ctrlx the x coordinate of the control point
+ * @param ctrly the y coordinate of the control point
+ * @param x2 the x coordinate of the end point of the curved segment
+ * @param y2 the y coordinate of the end point of the curved segment
+ */
+ public abstract void setCurve(double x1, double y1, double ctrlx, double ctrly, double x2, double y2);
+
+ /**
+ * Sets the data of the curve.
+ *
+ * @param p1 the starting point of the curved segment
+ * @param cp the control point
+ * @param p2 the end point of the curved segment
+ *
+ * @throws NullPointerException if any of the three points is null.
+ */
+ public void setCurve(Point2D p1, Point2D cp, Point2D p2) {
+ setCurve(p1.getX(), p1.getY(), cp.getX(), cp.getY(), p2.getX(), p2.getY());
+ }
+
+ /**
+ * Sets the data of the curve by reading the data from an array
+ * of values. The values are read in the same order as the arguments
+ * of the method {@link QuadCurve2D#setCurve(double, double, double, double, double, double)}.
+ *
+ * @param coords the array of values containing the new coordinates
+ * @param offset the offset of the data to read within the array
+ *
+ * @throws ArrayIndexOutOfBoundsException if coords.length < offset + 6.
+ * @throws NullPointerException if the coordinate array is null.
+ */
+ public void setCurve(double[] coords, int offset) {
+ setCurve(
+ coords[offset + 0], coords[offset + 1],
+ coords[offset + 2], coords[offset + 3],
+ coords[offset + 4], coords[offset + 5]);
+ }
+
+ /**
+ * Sets the data of the curve by reading the data from an array
+ * of points. The values are read in the same order as the arguments
+ * of the method {@link QuadCurve2D#setCurve(Point2D, Point2D, Point2D)}
+ *
+ * @param points the array of points containing the new coordinates
+ * @param offset the offset of the data to read within the array
+ *
+ * @throws ArrayIndexOutOfBoundsException if points.length < offset + 3.
+ * @throws NullPointerException if the point array is null.
+ */
+ public void setCurve(Point2D[] points, int offset) {
+ setCurve(
+ points[offset + 0].getX(), points[offset + 0].getY(),
+ points[offset + 1].getX(), points[offset + 1].getY(),
+ points[offset + 2].getX(), points[offset + 2].getY());
+ }
+
+ /**
+ * Sets the data of the curve by copying it from another QuadCurve2D.
+ *
+ * @param curve the curve to copy the data points from
+ *
+ * @throws NullPointerException if the curve is null.
+ */
+ public void setCurve(QuadCurve2D curve) {
+ setCurve(
+ curve.getX1(), curve.getY1(),
+ curve.getCtrlX(), curve.getCtrlY(),
+ curve.getX2(), curve.getY2());
+ }
+
+ /**
+ * Gets the square of the distance from the control point to the
+ * straight line segment connecting the start point and the end point
+ * for this curve.
+ *
+ * @return the square of the distance from the control point to the
+ * straight line segment connecting the start point and the end point.
+ */
+ public double getFlatnessSq() {
+ return Line2D.ptSegDistSq(
+ getX1(), getY1(),
+ getX2(), getY2(),
+ getCtrlX(), getCtrlY());
+ }
+
+ /**
+ * Gets the square of the distance from the control point to the
+ * straight line segment connecting the start point and the end point.
+ *
+ * @param x1 the x coordinate of the starting point of the curved segment
+ * @param y1 the y coordinate of the starting point of the curved segment
+ * @param ctrlx the x coordinate of the control point
+ * @param ctrly the y coordinate of the control point
+ * @param x2 the x coordinate of the end point of the curved segment
+ * @param y2 the y coordinate of the end point of the curved segment
+ *
+ * @return the square of the distance from the control point to the
+ * straight line segment connecting the start point and the end point.
+ */
+ public static double getFlatnessSq(double x1, double y1, double ctrlx, double ctrly, double x2, double y2) {
+ return Line2D.ptSegDistSq(x1, y1, x2, y2, ctrlx, ctrly);
+ }
+
+ /**
+ * Gets the square of the distance from the control point to the
+ * straight line segment connecting the start point and the end point
+ * by reading the coordinates of the points from an array of values.
+ * The values are read in the same order as the arguments
+ * of the method {@link QuadCurve2D#getFlatnessSq(double, double, double, double, double, double)}.
+ *
+ * @param coords the array of points containing the coordinates to use for
+ * the calculation
+ * @param offset the offset of the data to read within the array
+ *
+ * @return the square of the distance from the control point to the
+ * straight line segment connecting the start point and the end point.
+ *
+ * @throws ArrayIndexOutOfBoundsException if coords.length < offset + 6.
+ * @throws NullPointerException if the coordinate array is null.
+ */
+ public static double getFlatnessSq(double coords[], int offset) {
+ return Line2D.ptSegDistSq(
+ coords[offset + 0], coords[offset + 1],
+ coords[offset + 4], coords[offset + 5],
+ coords[offset + 2], coords[offset + 3]);
+ }
+
+ /**
+ * Gets the distance from the control point to the
+ * straight line segment connecting the start point and the end point
+ * of this QuadCurve2D.
+ *
+ * @return the the distance from the control point to the
+ * straight line segment connecting the start point and the end point
+ * of this QuadCurve2D
+ */
+ public double getFlatness() {
+ return Line2D.ptSegDist(getX1(), getY1(), getX2(), getY2(), getCtrlX(), getCtrlY());
+ }
+
+ /**
+ * Gets the distance from the control point to the
+ * straight line segment connecting the start point and the end point.
+ *
+ * @param x1 the x coordinate of the starting point of the curved segment
+ * @param y1 the y coordinate of the starting point of the curved segment
+ * @param ctrlx the x coordinate of the control point
+ * @param ctrly the y coordinate of the control point
+ * @param x2 the x coordinate of the end point of the curved segment
+ * @param y2 the y coordinate of the end point of the curved segment
+ *
+ * @return the the distance from the control point to the
+ * straight line segment connecting the start point and the end point
+ */
+ public static double getFlatness(double x1, double y1, double ctrlx,
+ double ctrly, double x2, double y2)
+ {
+ return Line2D.ptSegDist(x1, y1, x2, y2, ctrlx, ctrly);
+ }
+
+ /**
+ * Gets the the distance from the control point to the
+ * straight line segment connecting the start point and the end point.
+ * The values are read in the same order as the arguments
+ * of the method {@link QuadCurve2D#getFlatness(double, double, double, double, double, double)}.
+ *
+ * @param coords the array of points containing the coordinates to use for
+ * the calculation
+ * @param offset the offset of the data to read within the array
+ *
+ * @return the the distance from the control point to the
+ * straight line segment connecting the start point and the end point
+ *
+ * @throws ArrayIndexOutOfBoundsException if coords.length < offset + 6.
+ * @throws NullPointerException if the coordinate array is null.
+ */
+ public static double getFlatness(double coords[], int offset) {
+ return Line2D.ptSegDist(
+ coords[offset + 0], coords[offset + 1],
+ coords[offset + 4], coords[offset + 5],
+ coords[offset + 2], coords[offset + 3]);
+ }
+
+ /**
+ * Creates the data for two quadratic curves by dividing this
+ * curve in two. The division point is the point on the curve
+ * that is closest to this curve's control point. The data of
+ * this curve is left unchanged.
+ *
+ * @param left the QuadCurve2D where the left (start) segment's
+ * data is written
+ * @param right the QuadCurve2D where the right (end) segment's
+ * data is written
+ *
+ * @throws NullPointerException if either curve is null.
+ */
+ public void subdivide(QuadCurve2D left, QuadCurve2D right) {
+ subdivide(this, left, right);
+ }
+
+ /**
+ * Creates the data for two quadratic curves by dividing a source
+ * curve in two. The division point is the point on the curve
+ * that is closest to the source curve's control point. The data of
+ * the source curve is left unchanged.
+ *
+ * @param src the curve that provides the initial data
+ * @param left the QuadCurve2D where the left (start) segment's
+ * data is written
+ * @param right the QuadCurve2D where the right (end) segment's
+ * data is written
+ *
+ * @throws NullPointerException if one of the curves is null.
+ */
+ public static void subdivide(QuadCurve2D src, QuadCurve2D left, QuadCurve2D right) {
+ double x1 = src.getX1();
+ double y1 = src.getY1();
+ double cx = src.getCtrlX();
+ double cy = src.getCtrlY();
+ double x2 = src.getX2();
+ double y2 = src.getY2();
+ double cx1 = (x1 + cx) / 2.0;
+ double cy1 = (y1 + cy) / 2.0;
+ double cx2 = (x2 + cx) / 2.0;
+ double cy2 = (y2 + cy) / 2.0;
+ cx = (cx1 + cx2) / 2.0;
+ cy = (cy1 + cy2) / 2.0;
+ if (left != null) {
+ left.setCurve(x1, y1, cx1, cy1, cx, cy);
+ }
+ if (right != null) {
+ right.setCurve(cx, cy, cx2, cy2, x2, y2);
+ }
+ }
+
+ /**
+ * Creates the data for two quadratic curves by dividing a source
+ * curve in two. The division point is the point on the curve
+ * that is closest to the source curve's control point. The data
+ * for the three curves is read and written from arrays of values in
+ * the usual order: x1, y1, cx, cy, x2, y2.
+ *
+ * @param src the array that gives the data values for the source curve
+ * @param srcoff the offset in the src array to read the values from
+ * @param left the array where the coordinates of the start curve should be written
+ * @param leftOff the offset in the left array to start writing the values
+ * @param right the array where the coordinates of the end curve should be written
+ * @param rightOff the offset in the right array to start writing the values
+ *
+ * @throws ArrayIndexOutOfBoundsException if src.length < srcoff + 6
+ * or if left.length < leftOff + 6 or if right.length < rightOff + 6.
+ * @throws NullPointerException if one of the arrays is null.
+ */
+ public static void subdivide(double src[], int srcoff, double left[],
+ int leftOff, double right[], int rightOff)
+ {
+ double x1 = src[srcoff + 0];
+ double y1 = src[srcoff + 1];
+ double cx = src[srcoff + 2];
+ double cy = src[srcoff + 3];
+ double x2 = src[srcoff + 4];
+ double y2 = src[srcoff + 5];
+ double cx1 = (x1 + cx) / 2.0;
+ double cy1 = (y1 + cy) / 2.0;
+ double cx2 = (x2 + cx) / 2.0;
+ double cy2 = (y2 + cy) / 2.0;
+ cx = (cx1 + cx2) / 2.0;
+ cy = (cy1 + cy2) / 2.0;
+ if (left != null) {
+ left[leftOff + 0] = x1;
+ left[leftOff + 1] = y1;
+ left[leftOff + 2] = cx1;
+ left[leftOff + 3] = cy1;
+ left[leftOff + 4] = cx;
+ left[leftOff + 5] = cy;
+ }
+ if (right != null) {
+ right[rightOff + 0] = cx;
+ right[rightOff + 1] = cy;
+ right[rightOff + 2] = cx2;
+ right[rightOff + 3] = cy2;
+ right[rightOff + 4] = x2;
+ right[rightOff + 5] = y2;
+ }
+ }
+
+ /**
+ * Finds the roots of the quadratic polynomial. This is
+ * accomplished by finding the (real) values of x that solve
+ * the following equation: eqn[2]*x*x + eqn[1]*x + eqn[0] = 0.
+ * The solutions are written back into the array eqn starting
+ * from the index 0 in the array. The return value tells how
+ * many array elements have been changed by this method call.
+ *
+ * @param eqn an array containing the coefficients of the
+ * quadratic polynomial to solve.
+ *
+ * @return the number of roots of the quadratic polynomial
+ *
+ * @throws ArrayIndexOutOfBoundsException if eqn.length < 3.
+ * @throws NullPointerException if the array is null.
+ */
+ public static int solveQuadratic(double eqn[]) {
+ return solveQuadratic(eqn, eqn);
+ }
+
+ /**
+ * Finds the roots of the quadratic polynomial. This is
+ * accomplished by finding the (real) values of x that solve
+ * the following equation: eqn[2]*x*x + eqn[1]*x + eqn[0] = 0.
+ * The solutions are written into the array res starting
+ * from the index 0 in the array. The return value tells how
+ * many array elements have been written by this method call.
+ *
+ * @param eqn an array containing the coefficients of the
+ * quadratic polynomial to solve.
+ * @param res the array that this method writes the results into
+ *
+ * @return the number of roots of the quadratic polynomial
+ *
+ * @throws ArrayIndexOutOfBoundsException if eqn.length < 3 or
+ * if res.length is less than the number of roots.
+ * @throws NullPointerException if either array is null.
+ */
+ public static int solveQuadratic(double eqn[], double res[]) {
+ return Crossing.solveQuad(eqn, res);
+ }
+
+ public boolean contains(double px, double py) {
+ return Crossing.isInsideEvenOdd(Crossing.crossShape(this, px, py));
+ }
+
+ public boolean contains(double rx, double ry, double rw, double rh) {
+ int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
+ return cross != Crossing.CROSSING && Crossing.isInsideEvenOdd(cross);
+ }
+
+ public boolean intersects(double rx, double ry, double rw, double rh) {
+ int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
+ return cross == Crossing.CROSSING || Crossing.isInsideEvenOdd(cross);
+ }
+
+ public boolean contains(Point2D p) {
+ return contains(p.getX(), p.getY());
+ }
+
+ public boolean intersects(Rectangle2D r) {
+ return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ }
+
+ public boolean contains(Rectangle2D r) {
+ return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ }
+
+ public Rectangle getBounds() {
+ return getBounds2D().getBounds();
+ }
+
+ public PathIterator getPathIterator(AffineTransform t) {
+ return new Iterator(this, t);
+ }
+
+ public PathIterator getPathIterator(AffineTransform t, double flatness) {
+ return new FlatteningPathIterator(getPathIterator(t), flatness);
+ }
+
+ @Override
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ throw new InternalError();
+ }
+ }
+
+}
+
diff --git a/awt/java/awt/geom/Rectangle2D.java b/awt/java/awt/geom/Rectangle2D.java
new file mode 100644
index 0000000..d33dd91
--- /dev/null
+++ b/awt/java/awt/geom/Rectangle2D.java
@@ -0,0 +1,761 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+import org.apache.harmony.misc.HashCode;
+
+/**
+ * The Class Rectangle2D represents a rectangle whose coordinates are given
+ * with the correct precision to be used with the Graphics2D classes.
+ */
+public abstract class Rectangle2D extends RectangularShape {
+
+ /** The Constant OUT_LEFT is a mask that is used to indicate that a
+ * given point is outside the rectangle and to its left. */
+ public static final int OUT_LEFT = 1;
+
+ /** The Constant OUT_TOP is a mask that is used to indicate that a
+ * given point is outside the rectangle and above it. */
+ public static final int OUT_TOP = 2;
+
+ /** The Constant OUT_RIGHT is a mask that is used to indicate that a
+ * given point is outside the rectangle and to its right. */
+ public static final int OUT_RIGHT = 4;
+
+ /** The Constant OUT_BOTTOM is a mask that is used to indicate that a
+ * given point is outside the rectangle and above it. */
+ public static final int OUT_BOTTOM = 8;
+
+ /**
+ * The Class Float is the subclass of Rectangle2D that represents a
+ * rectangle whose data values are given as floats (with float-level
+ * precision).
+ */
+ public static class Float extends Rectangle2D {
+
+ /** The x coordinate of the rectangle's upper left corner. */
+ public float x;
+
+ /** The y coordinate of the rectangle's upper left corner. */
+ public float y;
+
+ /** The width of the rectangle. */
+ public float width;
+
+ /** The height of the rectangle. */
+ public float height;
+
+ /**
+ * Instantiates a new empty rectangle with float-precision data fields.
+ */
+ public Float() {
+ }
+
+ /**
+ * Instantiates a new rectangle with the specified float-precision data.
+ *
+ * @param x the x coordinate of the rectangle's upper left corner
+ * @param y the y coordinate of the rectangle's upper left corner
+ * @param width the width of the rectangle
+ * @param height the height of the rectangle
+ */
+ public Float(float x, float y, float width, float height) {
+ setRect(x, y, width, height);
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return width <= 0.0f || height <= 0.0f;
+ }
+
+ /**
+ * Sets the rectangle's data to the given values.
+ *
+ * @param x the x coordinate of the rectangle's upper left corner
+ * @param y the y coordinate of the rectangle's upper left corner
+ * @param width the width of the rectangle
+ * @param height the height of the rectangle
+ */
+ public void setRect(float x, float y, float width, float height) {
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ }
+
+ @Override
+ public void setRect(double x, double y, double width, double height) {
+ this.x = (float)x;
+ this.y = (float)y;
+ this.width = (float)width;
+ this.height = (float)height;
+ }
+
+ @Override
+ public void setRect(Rectangle2D r) {
+ this.x = (float)r.getX();
+ this.y = (float)r.getY();
+ this.width = (float)r.getWidth();
+ this.height = (float)r.getHeight();
+ }
+
+ @Override
+ public int outcode(double px, double py) {
+ int code = 0;
+
+ if (width <= 0.0f) {
+ code |= OUT_LEFT | OUT_RIGHT;
+ } else
+ if (px < x) {
+ code |= OUT_LEFT;
+ } else
+ if (px > x + width) {
+ code |= OUT_RIGHT;
+ }
+
+ if (height <= 0.0f) {
+ code |= OUT_TOP | OUT_BOTTOM;
+ } else
+ if (py < y) {
+ code |= OUT_TOP;
+ } else
+ if (py > y + height) {
+ code |= OUT_BOTTOM;
+ }
+
+ return code;
+ }
+
+ @Override
+ public Rectangle2D getBounds2D() {
+ return new Float(x, y, width, height);
+ }
+
+ @Override
+ public Rectangle2D createIntersection(Rectangle2D r) {
+ Rectangle2D dst;
+ if (r instanceof Double) {
+ dst = new Rectangle2D.Double();
+ } else {
+ dst = new Rectangle2D.Float();
+ }
+ Rectangle2D.intersect(this, r, dst);
+ return dst;
+ }
+
+ @Override
+ public Rectangle2D createUnion(Rectangle2D r) {
+ Rectangle2D dst;
+ if (r instanceof Double) {
+ dst = new Rectangle2D.Double();
+ } else {
+ dst = new Rectangle2D.Float();
+ }
+ Rectangle2D.union(this, r, dst);
+ return dst;
+ }
+
+ @Override
+ public String toString() {
+ // The output format based on 1.5 release behaviour. It could be obtained in the following way
+ // System.out.println(new Rectangle2D.Float().toString())
+ return getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
+ }
+ }
+
+ /**
+ * The Class Double is the subclass of Rectangle2D that represents a
+ * rectangle whose data values are given as doubles (with double-precision-level
+ * precision).
+ */
+ public static class Double extends Rectangle2D {
+
+ /** The x coordinate of the rectangle's upper left corner. */
+ public double x;
+
+ /** The y coordinate of the rectangle's upper left corner. */
+ public double y;
+
+ /** The width of the rectangle. */
+ public double width;
+
+ /** The height of the rectangle. */
+ public double height;
+
+ /**
+ * Instantiates a new empty rectangle with double-precision data fields.
+ */
+ public Double() {
+ }
+
+ /**
+ * Instantiates a new rectangle with the given double values.
+ *
+ * @param x the x coordinate of the rectangle's upper left corner
+ * @param y the y coordinate of the rectangle's upper left corner
+ * @param width the width of the rectangle
+ * @param height the height of the rectangle
+ */
+ public Double(double x, double y, double width, double height) {
+ setRect(x, y, width, height);
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return width <= 0.0 || height <= 0.0;
+ }
+
+ @Override
+ public void setRect(double x, double y, double width, double height) {
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ }
+
+ @Override
+ public void setRect(Rectangle2D r) {
+ this.x = r.getX();
+ this.y = r.getY();
+ this.width = r.getWidth();
+ this.height = r.getHeight();
+ }
+
+ @Override
+ public int outcode(double px, double py) {
+ int code = 0;
+
+ if (width <= 0.0) {
+ code |= OUT_LEFT | OUT_RIGHT;
+ } else
+ if (px < x) {
+ code |= OUT_LEFT;
+ } else
+ if (px > x + width) {
+ code |= OUT_RIGHT;
+ }
+
+ if (height <= 0.0) {
+ code |= OUT_TOP | OUT_BOTTOM;
+ } else
+ if (py < y) {
+ code |= OUT_TOP;
+ } else
+ if (py > y + height) {
+ code |= OUT_BOTTOM;
+ }
+
+ return code;
+ }
+
+ @Override
+ public Rectangle2D getBounds2D() {
+ return new Double(x, y, width, height);
+ }
+
+ @Override
+ public Rectangle2D createIntersection(Rectangle2D r) {
+ Rectangle2D dst = new Rectangle2D.Double();
+ Rectangle2D.intersect(this, r, dst);
+ return dst;
+ }
+
+ @Override
+ public Rectangle2D createUnion(Rectangle2D r) {
+ Rectangle2D dest = new Rectangle2D.Double();
+ Rectangle2D.union(this, r, dest);
+ return dest;
+ }
+
+ @Override
+ public String toString() {
+ // The output format based on 1.5 release behaviour. It could be obtained in the following way
+ // System.out.println(new Rectangle2D.Double().toString())
+ return getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
+ }
+ }
+
+ /**
+ * The Class Iterator provides
+ * access to the coordinates of the Rectangle2D's boundary modified
+ * by an AffineTransform.
+ */
+ class Iterator implements PathIterator {
+
+ /** The x coordinate of the rectangle's upper left corner. */
+ double x;
+
+ /** The y coordinate of the rectangle's upper left corner. */
+ double y;
+
+
+ /** The width of the rectangle. */
+ double width;
+
+ /** The height of the rectangle. */
+ double height;
+
+ /** The AffineTransform that is used to modify the coordinates
+ * that are returned by the path iterator. */
+ AffineTransform t;
+
+ /** The current segment index. */
+ int index;
+
+ /**
+ * Constructs a new Rectangle2D.Iterator for given rectangle and transformation.
+ *
+ * @param r - the source Rectangle2D object
+ * @param at - the AffineTransform object to apply to the coordinates
+ * before returning them
+ */
+ Iterator(Rectangle2D r, AffineTransform at) {
+ this.x = r.getX();
+ this.y = r.getY();
+ this.width = r.getWidth();
+ this.height = r.getHeight();
+ this.t = at;
+ if (width < 0.0 || height < 0.0) {
+ index = 6;
+ }
+ }
+
+ public int getWindingRule() {
+ return WIND_NON_ZERO;
+ }
+
+ public boolean isDone() {
+ return index > 5;
+ }
+
+ public void next() {
+ index++;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ if (index == 5) {
+ return SEG_CLOSE;
+ }
+ int type;
+ if (index == 0) {
+ type = SEG_MOVETO;
+ coords[0] = x;
+ coords[1] = y;
+ } else {
+ type = SEG_LINETO;
+ switch(index) {
+ case 1:
+ coords[0] = x + width;
+ coords[1] = y;
+ break;
+ case 2:
+ coords[0] = x + width;
+ coords[1] = y + height;
+ break;
+ case 3:
+ coords[0] = x;
+ coords[1] = y + height;
+ break;
+ case 4:
+ coords[0] = x;
+ coords[1] = y;
+ break;
+ }
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, 1);
+ }
+ return type;
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ if (index == 5) {
+ return SEG_CLOSE;
+ }
+ int type;
+ if (index == 0) {
+ coords[0] = (float)x;
+ coords[1] = (float)y;
+ type = SEG_MOVETO;
+ } else {
+ type = SEG_LINETO;
+ switch(index) {
+ case 1:
+ coords[0] = (float)(x + width);
+ coords[1] = (float)y;
+ break;
+ case 2:
+ coords[0] = (float)(x + width);
+ coords[1] = (float)(y + height);
+ break;
+ case 3:
+ coords[0] = (float)x;
+ coords[1] = (float)(y + height);
+ break;
+ case 4:
+ coords[0] = (float)x;
+ coords[1] = (float)y;
+ break;
+ }
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, 1);
+ }
+ return type;
+ }
+
+ }
+
+ /**
+ * Instantiates a new rectangle2 d.
+ */
+ protected Rectangle2D() {
+ }
+
+ /**
+ * Sets the rectangle's location and dimension.
+ *
+ * @param x the x coordinate of the rectangle's upper left corner
+ * @param y the y coordinate of the rectangle's upper left corner
+ * @param width the width of the rectangle
+ * @param height the height of the rectangle
+ */
+ public abstract void setRect(double x, double y, double width, double height);
+
+ /**
+ * Gets the location of the point with respect to the rectangle and
+ * packs the information into a single int using the bitmasks
+ * {@link Rectangle2D#OUT_LEFT}, {@link Rectangle2D#OUT_RIGHT},
+ * {@link Rectangle2D#OUT_TOP}, and {@link Rectangle2D#OUT_BOTTOM}.
+ * If the rectangle has zero or negative width, then every point
+ * is regarded as being both to the left and to the right of the
+ * rectangle. Similarly, if the height is zero or negative then
+ * all points are considered to be both both above and below it.
+ *
+ * @param x the x coordinate of the point to check
+ * @param y the y coordinate of the point to check
+ *
+ * @return the point's location with respect to the rectangle.
+ */
+ public abstract int outcode(double x, double y);
+
+ /**
+ * Creates an new rectangle that is the intersection of this rectangle
+ * with the given rectangle. The resulting rectangle may be empty.
+ * The data of this rectangle is left unchanged.
+ *
+ * @param r the rectangle to intersect with this rectangle.
+ *
+ * @return the new rectangle given by intersection.
+ */
+ public abstract Rectangle2D createIntersection(Rectangle2D r);
+
+ /**
+ * Creates an new rectangle that is the union of this rectangle
+ * with the given rectangle. The new rectangle is the smallest
+ * rectangle which contains both this rectangle and the rectangle
+ * specified as a parameter. The data of this rectangle is left unchanged.
+ *
+ * @param r the rectangle to combine with this rectangle
+ *
+ * @return the new rectangle given by union
+ */
+ public abstract Rectangle2D createUnion(Rectangle2D r);
+
+ /**
+ * Sets the data of this rectangle to match the data of the given
+ * rectangle.
+ *
+ * @param r the rectangle whose data is to be copied into this rectangle's fields.
+ */
+ public void setRect(Rectangle2D r) {
+ setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ }
+
+ @Override
+ public void setFrame(double x, double y, double width, double height) {
+ setRect(x, y, width, height);
+ }
+
+ public Rectangle2D getBounds2D() {
+ return (Rectangle2D)clone();
+ }
+
+ /**
+ * Determines whether any part of the line segment between (and including)
+ * the two given points touches any
+ * part of the rectangle, including its boundary.
+ *
+ * @param x1 the x coordinate of one of the points that determines the
+ * line segment to test
+ * @param y1 the y coordinate of one of the points that determines the
+ * line segment to test
+ * @param x2 the x coordinate of one of the points that determines the
+ * line segment to test
+ * @param y2 the y coordinate of one of the points that determines the
+ * line segment to test
+ *
+ * @return true, if at least one point of the line segment between the
+ * two points matches any point of the interior of the rectangle or the
+ * rectangle's boundary.
+ */
+ public boolean intersectsLine(double x1, double y1, double x2, double y2) {
+ double rx1 = getX();
+ double ry1 = getY();
+ double rx2 = rx1 + getWidth();
+ double ry2 = ry1 + getHeight();
+ return
+ (rx1 <= x1 && x1 <= rx2 && ry1 <= y1 && y1 <= ry2) ||
+ (rx1 <= x2 && x2 <= rx2 && ry1 <= y2 && y2 <= ry2) ||
+ Line2D.linesIntersect(rx1, ry1, rx2, ry2, x1, y1, x2, y2) ||
+ Line2D.linesIntersect(rx2, ry1, rx1, ry2, x1, y1, x2, y2);
+ }
+
+ /**
+ * Determines whether any part of the specified line segment touches any
+ * part of the rectangle, including its boundary.
+ *
+ * @param l the line segment to test
+ *
+ * @return true, if at least one point of the given line segment
+ * matches any point of the interior of the rectangle or the
+ * rectangle's boundary.
+ */
+ public boolean intersectsLine(Line2D l) {
+ return intersectsLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
+ }
+
+ /**
+ * Gets the location of the point with respect to the rectangle and
+ * packs the information into a single int using the bitmasks
+ * {@link Rectangle2D#OUT_LEFT}, {@link Rectangle2D#OUT_RIGHT},
+ * {@link Rectangle2D#OUT_TOP}, and {@link Rectangle2D#OUT_BOTTOM}.
+ * If the rectangle has zero or negative width, then every point
+ * is regarded as being both to the left and to the right of the
+ * rectangle. Similarly, if the height is zero or negative then
+ * all points are considered to be both both above and below it.
+ *
+ * @param p the point to check
+ *
+ * @return the point's location with respect to the rectangle.
+ */
+ public int outcode(Point2D p) {
+ return outcode(p.getX(), p.getY());
+ }
+
+ public boolean contains(double x, double y) {
+ if (isEmpty()) {
+ return false;
+ }
+
+ double x1 = getX();
+ double y1 = getY();
+ double x2 = x1 + getWidth();
+ double y2 = y1 + getHeight();
+
+ return
+ x1 <= x && x < x2 &&
+ y1 <= y && y < y2;
+ }
+
+ public boolean intersects(double x, double y, double width, double height) {
+ if (isEmpty() || width <= 0.0 || height <= 0.0) {
+ return false;
+ }
+
+ double x1 = getX();
+ double y1 = getY();
+ double x2 = x1 + getWidth();
+ double y2 = y1 + getHeight();
+
+ return
+ x + width > x1 && x < x2 &&
+ y + height > y1 && y < y2;
+ }
+
+ public boolean contains(double x, double y, double width, double height) {
+ if (isEmpty() || width <= 0.0 || height <= 0.0) {
+ return false;
+ }
+
+ double x1 = getX();
+ double y1 = getY();
+ double x2 = x1 + getWidth();
+ double y2 = y1 + getHeight();
+
+ return
+ x1 <= x && x + width <= x2 &&
+ y1 <= y && y + height <= y2;
+ }
+
+ /**
+ * Changes the data values of the destination rectangle to match
+ * the intersection of the two source rectangles, leaving the
+ * two source rectangles unchanged. The resulting rectangle may be empty.
+ *
+ * @param src1 one of the two source rectangles giving the data to intersect
+ * @param src2 one of the two source rectangles giving the data to intersect
+ * @param dst the destination object where the data of the intersection is written
+ */
+ public static void intersect(Rectangle2D src1, Rectangle2D src2, Rectangle2D dst) {
+ double x1 = Math.max(src1.getMinX(), src2.getMinX());
+ double y1 = Math.max(src1.getMinY(), src2.getMinY());
+ double x2 = Math.min(src1.getMaxX(), src2.getMaxX());
+ double y2 = Math.min(src1.getMaxY(), src2.getMaxY());
+ dst.setFrame(x1, y1, x2 - x1, y2 - y1);
+ }
+
+ /**
+ * Changes the data values of the destination rectangle to match
+ * the union of the two source rectangles, leaving the
+ * two source rectangles unchanged. The union is the smallest rectangle
+ * tha completely covers the two source rectangles.
+ *
+ * @param src1 one of the two source rectangles giving the data
+ * @param src2 one of the two source rectangles giving the data
+ * @param dst the destination object where the data of the union is written
+ */
+ public static void union(Rectangle2D src1, Rectangle2D src2, Rectangle2D dst) {
+ double x1 = Math.min(src1.getMinX(), src2.getMinX());
+ double y1 = Math.min(src1.getMinY(), src2.getMinY());
+ double x2 = Math.max(src1.getMaxX(), src2.getMaxX());
+ double y2 = Math.max(src1.getMaxY(), src2.getMaxY());
+ dst.setFrame(x1, y1, x2 - x1, y2 - y1);
+ }
+
+ /**
+ * Enlarges the rectangle so that it includes the given point.
+ *
+ * @param x the x coordinate of the new point to be covered by the rectangle
+ * @param y the y coordinate of the new point to be covered by the rectangle
+ */
+ public void add(double x, double y) {
+ double x1 = Math.min(getMinX(), x);
+ double y1 = Math.min(getMinY(), y);
+ double x2 = Math.max(getMaxX(), x);
+ double y2 = Math.max(getMaxY(), y);
+ setRect(x1, y1, x2 - x1, y2 - y1);
+ }
+
+ /**
+ * Enlarges the rectangle so that it includes the given point.
+ *
+ * @param p the new point to be covered by the rectangle
+ */
+ public void add(Point2D p) {
+ add(p.getX(), p.getY());
+ }
+
+ /**
+ * Enlarges the rectangle so that it covers the given rectangle.
+ *
+ * @param r the new rectangle to be covered by this rectangle
+ */
+ public void add(Rectangle2D r) {
+ union(this, r, this);
+ }
+
+ public PathIterator getPathIterator(AffineTransform t) {
+ return new Iterator(this, t);
+ }
+
+ @Override
+ public PathIterator getPathIterator(AffineTransform t, double flatness) {
+ return new Iterator(this, t);
+ }
+
+ @Override
+ public int hashCode() {
+ HashCode hash = new HashCode();
+ hash.append(getX());
+ hash.append(getY());
+ hash.append(getWidth());
+ hash.append(getHeight());
+ return hash.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (obj instanceof Rectangle2D) {
+ Rectangle2D r = (Rectangle2D)obj;
+ return
+ getX() == r.getX() &&
+ getY() == r.getY() &&
+ getWidth() == r.getWidth() &&
+ getHeight() == r.getHeight();
+ }
+ return false;
+ }
+
+}
+
diff --git a/awt/java/awt/geom/RectangularShape.java b/awt/java/awt/geom/RectangularShape.java
new file mode 100644
index 0000000..0a77dfd
--- /dev/null
+++ b/awt/java/awt/geom/RectangularShape.java
@@ -0,0 +1,276 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.awt.Rectangle;
+import java.awt.Shape;
+
+/**
+ * The Class RectangularShape represents a Shape whose data is
+ * (at least partially) described by a rectangular frame. This includes
+ * shapes which are obviously rectangular (such as Rectangle2D) as well as
+ * shapes like Arc2D which are largely determined by the rectangle they
+ * fit inside.
+ */
+public abstract class RectangularShape implements Shape, Cloneable {
+
+ /**
+ * Instantiates a new rectangular shape.
+ */
+ protected RectangularShape() {
+ }
+
+ /**
+ * Gets the x coordinate of the upper left corner of the rectangle.
+ *
+ * @return the x coordinate of the upper left corner of the rectangle.
+ */
+ public abstract double getX();
+
+ /**
+ * Gets the y coordinate of the upper left corner of the rectangle.
+ *
+ * @return the y coordinate of the upper left corner of the rectangle.
+ */
+ public abstract double getY();
+
+ /**
+ * Gets the width of the rectangle.
+ *
+ * @return the width of the rectangle.
+ */
+ public abstract double getWidth();
+
+ /**
+ * Gets the height of the rectangle.
+ *
+ * @return the height of the rectangle.
+ */
+ public abstract double getHeight();
+
+ /**
+ * Checks if this is an empty rectangle: one with zero as its width or height.
+ *
+ * @return true, if the width or height is empty.
+ */
+ public abstract boolean isEmpty();
+
+ /**
+ * Sets the data for the bounding rectangle in terms of double values.
+ *
+ * @param x the x coordinate of the upper left corner of the rectangle.
+ * @param y the y coordinate of the upper left corner of the rectangle.
+ * @param w the width of the rectangle.
+ * @param h the height of the rectangle.
+ */
+ public abstract void setFrame(double x, double y, double w, double h);
+
+ /**
+ * Gets the minimum x value of the bounding rectangle (the x
+ * coordinate of the upper left corner of the rectangle).
+ *
+ * @return the minimum x value of the bounding rectangle.
+ */
+ public double getMinX() {
+ return getX();
+ }
+
+ /**
+ * Gets the minimum y value of the bounding rectangle (the y
+ * coordinate of the upper left corner of the rectangle).
+ *
+ * @return the minimum y value of the bounding rectangle.
+ */
+ public double getMinY() {
+ return getY();
+ }
+
+ /**
+ * Gets the maximum x value of the bounding rectangle (the x
+ * coordinate of the upper left corner of the rectangle plus the
+ * rectangle's width).
+ *
+ * @return the maximum x value of the bounding rectangle.
+ */
+ public double getMaxX() {
+ return getX() + getWidth();
+ }
+
+ /**
+ * Gets the maximum y value of the bounding rectangle (the y
+ * coordinate of the upper left corner of the rectangle plus the
+ * rectangle's height).
+ *
+ * @return the maximum y value of the bounding rectangle.
+ */
+ public double getMaxY() {
+ return getY() + getHeight();
+ }
+
+ /**
+ * Gets the x coordinate of the center of the rectangle.
+ *
+ * @return the x coordinate of the center of the rectangle.
+ */
+ public double getCenterX() {
+ return getX() + getWidth() / 2.0;
+ }
+
+ /**
+ * Gets the y coordinate of the center of the rectangle.
+ *
+ * @return the y coordinate of the center of the rectangle.
+ */
+ public double getCenterY() {
+ return getY() + getHeight() / 2.0;
+ }
+
+ /**
+ * Places the rectangle's size and location data in a new Rectangle2D
+ * object and returns it.
+ *
+ * @return the bounding rectangle as a new Rectangle2D object.
+ */
+ public Rectangle2D getFrame() {
+ return new Rectangle2D.Double(getX(), getY(), getWidth(), getHeight());
+ }
+
+ /**
+ * Sets the bounding rectangle in terms of a Point2D which gives its
+ * upper left corner and a Dimension2D object giving its width and height.
+ *
+ * @param loc the new upper left corner coordinate.
+ * @param size the new size dimensions.
+ */
+ public void setFrame(Point2D loc, Dimension2D size) {
+ setFrame(loc.getX(), loc.getY(), size.getWidth(), size.getHeight());
+ }
+
+ /**
+ * Sets the bounding rectangle to match the data contained in the
+ * specified Rectangle2D.
+ *
+ * @param r the rectangle that gives the new frame data.
+ */
+ public void setFrame(Rectangle2D r) {
+ setFrame(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+ }
+
+ /**
+ * Sets the framing rectangle given two opposite corners. Any two corners
+ * may be used in any order as long as they are diagonally opposite one another.
+ *
+ * @param x1 the x coordinate of one of the corner points.
+ * @param y1 the y coordinate of one of the corner points.
+ * @param x2 the x coordinate of the other corner point.
+ * @param y2 the y coordinate of the other corner point.
+ */
+ public void setFrameFromDiagonal(double x1, double y1, double x2, double y2) {
+ double rx, ry, rw, rh;
+ if (x1 < x2) {
+ rx = x1;
+ rw = x2 - x1;
+ } else {
+ rx = x2;
+ rw = x1 - x2;
+ }
+ if (y1 < y2) {
+ ry = y1;
+ rh = y2 - y1;
+ } else {
+ ry = y2;
+ rh = y1 - y2;
+ }
+ setFrame(rx, ry, rw, rh);
+ }
+
+ /**
+ * Sets the framing rectangle given two opposite corners. Any two corners
+ * may be used in any order as long as they are diagonally opposite one another.
+ *
+ * @param p1 one of the corner points.
+ * @param p2 the other corner point.
+ */
+ public void setFrameFromDiagonal(Point2D p1, Point2D p2) {
+ setFrameFromDiagonal(p1.getX(), p1.getY(), p2.getX(), p2.getY());
+ }
+
+ /**
+ * Sets the framing rectangle given the center point and one corner. Any
+ * corner may be used.
+ *
+ * @param centerX the x coordinate of the center point.
+ * @param centerY the y coordinate of the center point.
+ * @param cornerX the x coordinate of one of the corner points.
+ * @param cornerY the y coordinate of one of the corner points.
+ */
+ public void setFrameFromCenter(double centerX, double centerY, double cornerX, double cornerY) {
+ double width = Math.abs(cornerX - centerX);
+ double height = Math.abs(cornerY - centerY);
+ setFrame(centerX - width, centerY - height, width * 2.0, height * 2.0);
+ }
+
+ /**
+ * Sets the framing rectangle given the center point and one corner. Any
+ * corner may be used.
+ *
+ * @param center the center point.
+ * @param corner a corner point.
+ */
+ public void setFrameFromCenter(Point2D center, Point2D corner) {
+ setFrameFromCenter(center.getX(), center.getY(), corner.getX(), corner.getY());
+ }
+
+ public boolean contains(Point2D point) {
+ return contains(point.getX(), point.getY());
+ }
+
+ public boolean intersects(Rectangle2D rect) {
+ return intersects(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
+ }
+
+ public boolean contains(Rectangle2D rect) {
+ return contains(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
+ }
+
+ public Rectangle getBounds() {
+ int x1 = (int)Math.floor(getMinX());
+ int y1 = (int)Math.floor(getMinY());
+ int x2 = (int)Math.ceil(getMaxX());
+ int y2 = (int)Math.ceil(getMaxY());
+ return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+ }
+
+ public PathIterator getPathIterator(AffineTransform t, double flatness) {
+ return new FlatteningPathIterator(getPathIterator(t), flatness);
+ }
+
+ @Override
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ throw new InternalError();
+ }
+ }
+
+}
+
diff --git a/awt/java/awt/geom/RoundRectangle2D.java b/awt/java/awt/geom/RoundRectangle2D.java
new file mode 100644
index 0000000..680a146
--- /dev/null
+++ b/awt/java/awt/geom/RoundRectangle2D.java
@@ -0,0 +1,552 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Denis M. Kishenko
+ * @version $Revision$
+ */
+package java.awt.geom;
+
+import java.util.NoSuchElementException;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class RoundRectangle2D describes a rectangle with rounded
+ * corners with high-precision data that is appropriate for geometric
+ * operations.
+ */
+public abstract class RoundRectangle2D extends RectangularShape {
+
+ /**
+ * The Class Float is the subclass of RoundRectangle2D that has all
+ * of its data values stored with float-level precision.
+ */
+ public static class Float extends RoundRectangle2D {
+
+ /** The x coordinate of the rectangle's upper left corner. */
+ public float x;
+
+ /** The y coordinate of the rectangle's upper left corner. */
+ public float y;
+
+ /** The width of the rectangle. */
+ public float width;
+
+ /** The height of the rectangle. */
+ public float height;
+
+ /** The arcwidth of the rounded corners. */
+ public float arcwidth;
+
+ /** The archeight of the rounded corners. */
+ public float archeight;
+
+ /**
+ * Instantiates a new float-valued RoundRectangle2D with
+ * its data-values set to zero.
+ */
+ public Float() {
+ }
+
+ /**
+ * Instantiates a new float-valued RoundRectangle2D with
+ * the specified data values
+ *
+ * @param x the x coordinate of the rectangle's upper left corner
+ * @param y the y coordinate of the rectangle's upper left corner
+ * @param width the width of the rectangle
+ * @param height the height of the rectangle
+ * @param arcwidth the arcwidth of the rounded corners
+ * @param archeight the archeight of the rounded corners
+ */
+ public Float(float x, float y, float width, float height, float arcwidth, float archeight) {
+ setRoundRect(x, y, width, height, arcwidth, archeight);
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ @Override
+ public double getArcWidth() {
+ return arcwidth;
+ }
+
+ @Override
+ public double getArcHeight() {
+ return archeight;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return width <= 0.0f || height <= 0.0f;
+ }
+
+ /**
+ * Sets the data of the round rect.
+ *
+ * @param x the x coordinate of the rectangle's upper left corner
+ * @param y the y coordinate of the rectangle's upper left corner
+ * @param width the width of the rectangle
+ * @param height the height of the rectangle
+ * @param arcwidth the arcwidth of the rounded corners
+ * @param archeight the archeight of the rounded corners
+ */
+ public void setRoundRect(float x, float y, float width, float height, float arcwidth, float archeight) {
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ this.arcwidth = arcwidth;
+ this.archeight = archeight;
+ }
+
+ @Override
+ public void setRoundRect(double x, double y, double width, double height, double arcwidth, double archeight) {
+ this.x = (float)x;
+ this.y = (float)y;
+ this.width = (float)width;
+ this.height = (float)height;
+ this.arcwidth = (float)arcwidth;
+ this.archeight = (float)archeight;
+ }
+
+ @Override
+ public void setRoundRect(RoundRectangle2D rr) {
+ this.x = (float)rr.getX();
+ this.y = (float)rr.getY();
+ this.width = (float)rr.getWidth();
+ this.height = (float)rr.getHeight();
+ this.arcwidth = (float)rr.getArcWidth();
+ this.archeight = (float)rr.getArcHeight();
+ }
+
+ public Rectangle2D getBounds2D() {
+ return new Rectangle2D.Float(x, y, width, height);
+ }
+ }
+
+ /**
+ * The Class Double is the subclass of RoundRectangle2D that has all
+ * of its data values stored with double-level precision.
+ */
+ public static class Double extends RoundRectangle2D {
+
+ /** The x coordinate of the rectangle's upper left corner. */
+ public double x;
+
+ /** The y coordinate of the rectangle's upper left corner. */
+ public double y;
+
+ /** The width of the rectangle. */
+ public double width;
+
+ /** The height of the rectangle. */
+ public double height;
+
+ /** The arcwidth of the rounded corners. */
+ public double arcwidth;
+
+ /** The archeight of the rounded corners. */
+ public double archeight;
+
+ /**
+ * Instantiates a new double-valued RoundRectangle2D with
+ * its data-values set to zero.
+ */
+ public Double() {
+ }
+
+ /**
+ * Instantiates a new double-valued RoundRectangle2D with
+ * the specified data values.
+ *
+ * @param x the x coordinate of the rectangle's upper left corner
+ * @param y the y coordinate of the rectangle's upper left corner
+ * @param width the width of the rectangle
+ * @param height the height of the rectangle
+ * @param arcwidth the arcwidth of the rounded corners
+ * @param archeight the archeight of the rounded corners
+ */
+ public Double(double x, double y, double width, double height, double arcwidth, double archeight) {
+ setRoundRect(x, y, width, height, arcwidth, archeight);
+ }
+
+ @Override
+ public double getX() {
+ return x;
+ }
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+ @Override
+ public double getWidth() {
+ return width;
+ }
+
+ @Override
+ public double getHeight() {
+ return height;
+ }
+
+ @Override
+ public double getArcWidth() {
+ return arcwidth;
+ }
+
+ @Override
+ public double getArcHeight() {
+ return archeight;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return width <= 0.0 || height <= 0.0;
+ }
+
+ @Override
+ public void setRoundRect(double x, double y, double width, double height, double arcwidth, double archeight) {
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ this.arcwidth = arcwidth;
+ this.archeight = archeight;
+ }
+
+ @Override
+ public void setRoundRect(RoundRectangle2D rr) {
+ this.x = rr.getX();
+ this.y = rr.getY();
+ this.width = rr.getWidth();
+ this.height = rr.getHeight();
+ this.arcwidth = rr.getArcWidth();
+ this.archeight = rr.getArcHeight();
+ }
+
+ public Rectangle2D getBounds2D() {
+ return new Rectangle2D.Double(x, y, width, height);
+ }
+ }
+
+ /*
+ * RoundRectangle2D path iterator
+ */
+ /**
+ * The subclass of PathIterator to traverse a RoundRectangle2D.
+ */
+ class Iterator implements PathIterator {
+
+ /*
+ * Path for round corners generated the same way as Ellipse2D
+ */
+
+ /** The coefficient to calculate control points of Bezier curves. */
+ double u = 0.5 - 2.0 / 3.0 * (Math.sqrt(2.0) - 1.0);
+
+ /** The points coordinates calculation table. */
+ double points[][] = {
+ { 0.0, 0.5, 0.0, 0.0 }, // MOVETO
+ { 1.0, -0.5, 0.0, 0.0 }, // LINETO
+ { 1.0, -u, 0.0, 0.0, // CUBICTO
+ 1.0, 0.0, 0.0, u,
+ 1.0, 0.0, 0.0, 0.5 },
+ { 1.0, 0.0, 1.0, -0.5 }, // LINETO
+ { 1.0, 0.0, 1.0, -u, // CUBICTO
+ 1.0, -u, 1.0, 0.0,
+ 1.0, -0.5, 1.0, 0.0 },
+ { 0.0, 0.5, 1.0, 0.0 }, // LINETO
+ { 0.0, u, 1.0, 0.0, // CUBICTO
+ 0.0, 0.0, 1.0, -u,
+ 0.0, 0.0, 1.0, -0.5 },
+ { 0.0, 0.0, 0.0, 0.5 }, // LINETO
+ { 0.0, 0.0, 0.0, u, // CUBICTO
+ 0.0, u, 0.0, 0.0,
+ 0.0, 0.5, 0.0, 0.0 } };
+
+ /** The segment types correspond to points array. */
+ int types[] = {
+ SEG_MOVETO,
+ SEG_LINETO,
+ SEG_CUBICTO,
+ SEG_LINETO,
+ SEG_CUBICTO,
+ SEG_LINETO,
+ SEG_CUBICTO,
+ SEG_LINETO,
+ SEG_CUBICTO};
+
+ /** The x coordinate of left-upper corner of the round rectangle bounds. */
+ double x;
+
+ /** The y coordinate of left-upper corner of the round rectangle bounds. */
+ double y;
+
+ /** The width of the round rectangle bounds. */
+ double width;
+
+ /** The height of the round rectangle bounds. */
+ double height;
+
+ /** The width of arc corners of the round rectangle. */
+ double aw;
+
+ /** The height of arc corners of the round rectangle. */
+ double ah;
+
+ /** The path iterator transformation. */
+ AffineTransform t;
+
+ /** The current segmenet index. */
+ int index;
+
+ /**
+ * Constructs a new RoundRectangle2D.Iterator for given round rectangle and transformation.
+ *
+ * @param rr - the source RoundRectangle2D object
+ * @param at - the AffineTransform object to apply rectangle path
+ */
+ Iterator(RoundRectangle2D rr, AffineTransform at) {
+ this.x = rr.getX();
+ this.y = rr.getY();
+ this.width = rr.getWidth();
+ this.height = rr.getHeight();
+ this.aw = Math.min(width, rr.getArcWidth());
+ this.ah = Math.min(height, rr.getArcHeight());
+ this.t = at;
+ if (width < 0.0 || height < 0.0 || aw < 0.0 || ah < 0.0) {
+ index = points.length;
+ }
+ }
+
+ public int getWindingRule() {
+ return WIND_NON_ZERO;
+ }
+
+ public boolean isDone() {
+ return index > points.length;
+ }
+
+ public void next() {
+ index++;
+ }
+
+ public int currentSegment(double[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ if (index == points.length) {
+ return SEG_CLOSE;
+ }
+ int j = 0;
+ double p[] = points[index];
+ for (int i = 0; i < p.length; i += 4) {
+ coords[j++] = x + p[i + 0] * width + p[i + 1] * aw;
+ coords[j++] = y + p[i + 2] * height + p[i + 3] * ah;
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, j / 2);
+ }
+ return types[index];
+ }
+
+ public int currentSegment(float[] coords) {
+ if (isDone()) {
+ // awt.4B=Iterator out of bounds
+ throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+ }
+ if (index == points.length) {
+ return SEG_CLOSE;
+ }
+ int j = 0;
+ double p[] = points[index];
+ for (int i = 0; i < p.length; i += 4) {
+ coords[j++] = (float)(x + p[i + 0] * width + p[i + 1] * aw);
+ coords[j++] = (float)(y + p[i + 2] * height + p[i + 3] * ah);
+ }
+ if (t != null) {
+ t.transform(coords, 0, coords, 0, j / 2);
+ }
+ return types[index];
+ }
+
+ }
+
+ /**
+ * Instantiates a new RoundRectangle2D.
+ */
+ protected RoundRectangle2D() {
+ }
+
+ /**
+ * Gets the arc width.
+ *
+ * @return the arc width
+ */
+ public abstract double getArcWidth();
+
+ /**
+ * Gets the arc height.
+ *
+ * @return the arc height
+ */
+ public abstract double getArcHeight();
+
+ /**
+ * Sets the data of the RoundRectangle2D.
+ *
+ * @param x the x coordinate of the rectangle's upper left corner
+ * @param y the y coordinate of the rectangle's upper left corner
+ * @param width the width of the rectangle
+ * @param height the height of the rectangle
+ * @param arcWidth the arcwidth of the rounded corners
+ * @param arcHeight the archeight of the rounded corners
+ */
+ public abstract void setRoundRect(double x, double y, double width, double height,
+ double arcWidth, double arcHeight);
+
+ /**
+ * Sets the data of the RoundRectangle2D by copying the values
+ * from an existing RoundRectangle2D.
+ *
+ * @param rr the round rectangle to copy the data from
+ *
+ * @throws NullPointerException if rr is null
+ */
+ public void setRoundRect(RoundRectangle2D rr) {
+ setRoundRect(rr.getX(), rr.getY(), rr.getWidth(), rr.getHeight(), rr
+ .getArcWidth(), rr.getArcHeight());
+ }
+
+ @Override
+ public void setFrame(double x, double y, double width, double height) {
+ setRoundRect(x, y, width, height, getArcWidth(), getArcHeight());
+ }
+
+ public boolean contains(double px, double py) {
+ if (isEmpty()) {
+ return false;
+ }
+
+ double rx1 = getX();
+ double ry1 = getY();
+ double rx2 = rx1 + getWidth();
+ double ry2 = ry1 + getHeight();
+
+ if (px < rx1 || px >= rx2 || py < ry1 || py >= ry2) {
+ return false;
+ }
+
+ double aw = getArcWidth() / 2.0;
+ double ah = getArcHeight() / 2.0;
+
+ double cx, cy;
+
+ if (px < rx1 + aw) {
+ cx = rx1 + aw;
+ } else
+ if (px > rx2 - aw) {
+ cx = rx2 - aw;
+ } else {
+ return true;
+ }
+
+ if (py < ry1 + ah) {
+ cy = ry1 + ah;
+ } else
+ if (py > ry2 - ah) {
+ cy = ry2 - ah;
+ } else {
+ return true;
+ }
+
+ px = (px - cx) / aw;
+ py = (py - cy) / ah;
+ return px * px + py * py <= 1.0;
+ }
+
+ public boolean intersects(double rx, double ry, double rw, double rh) {
+ if (isEmpty() || rw <= 0.0 || rh <= 0.0) {
+ return false;
+ }
+
+ double x1 = getX();
+ double y1 = getY();
+ double x2 = x1 + getWidth();
+ double y2 = y1 + getHeight();
+
+ double rx1 = rx;
+ double ry1 = ry;
+ double rx2 = rx + rw;
+ double ry2 = ry + rh;
+
+ if (rx2 < x1 || x2 < rx1 || ry2 < y1 || y2 < ry1) {
+ return false;
+ }
+
+ double cx = (x1 + x2) / 2.0;
+ double cy = (y1 + y2) / 2.0;
+
+ double nx = cx < rx1 ? rx1 : (cx > rx2 ? rx2 : cx);
+ double ny = cy < ry1 ? ry1 : (cy > ry2 ? ry2 : cy);
+
+ return contains(nx, ny);
+ }
+
+ public boolean contains(double rx, double ry, double rw, double rh) {
+ if (isEmpty() || rw <= 0.0 || rh <= 0.0) {
+ return false;
+ }
+
+ double rx1 = rx;
+ double ry1 = ry;
+ double rx2 = rx + rw;
+ double ry2 = ry + rh;
+
+ return
+ contains(rx1, ry1) &&
+ contains(rx2, ry1) &&
+ contains(rx2, ry2) &&
+ contains(rx1, ry2);
+ }
+
+ public PathIterator getPathIterator(AffineTransform at) {
+ return new Iterator(this, at);
+ }
+
+}
+
diff --git a/awt/java/awt/im/InputContext.java b/awt/java/awt/im/InputContext.java
new file mode 100644
index 0000000..3468474
--- /dev/null
+++ b/awt/java/awt/im/InputContext.java
@@ -0,0 +1,77 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.im;
+
+import java.awt.AWTEvent;
+//???AWT: import java.awt.Component;
+import java.util.Locale;
+
+import org.apache.harmony.awt.im.InputMethodContext;
+
+public class InputContext {
+ protected InputContext() {
+ }
+
+ public static InputContext getInstance() {
+ return new InputMethodContext();
+ }
+
+ public void dispatchEvent(AWTEvent event) {
+ }
+
+ public void dispose() {
+ }
+
+ public void endComposition() {
+ }
+
+ public Object getInputMethodControlObject() {
+ return null;
+ }
+
+ public Locale getLocale() {
+ return null;
+ }
+
+ public boolean isCompositionEnabled() {
+ return false;
+ }
+
+ public void reconvert() {
+ }
+
+ //???AWT
+ /*
+ public void removeNotify(Component client) {
+ }
+ */
+
+ public boolean selectInputMethod(Locale locale) {
+ return false;
+ }
+
+ public void setCharacterSubsets(Character.Subset[] subsets) {
+ }
+
+ public void setCompositionEnabled(boolean enable) {
+ }
+}
+
diff --git a/awt/java/awt/im/InputMethodHighlight.java b/awt/java/awt/im/InputMethodHighlight.java
new file mode 100644
index 0000000..53bb20b
--- /dev/null
+++ b/awt/java/awt/im/InputMethodHighlight.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Dmitry A. Durnev
+ * @version $Revision$
+ */
+package java.awt.im;
+
+import java.util.Map;
+import java.awt.font.TextAttribute;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+public class InputMethodHighlight {
+
+ public static final int RAW_TEXT = 0;
+
+ public static final int CONVERTED_TEXT = 1;
+
+ public static final InputMethodHighlight
+ UNSELECTED_RAW_TEXT_HIGHLIGHT = new InputMethodHighlight(false, RAW_TEXT);
+
+ public static final InputMethodHighlight
+ SELECTED_RAW_TEXT_HIGHLIGHT = new InputMethodHighlight(true, RAW_TEXT);
+
+ public static final InputMethodHighlight
+ UNSELECTED_CONVERTED_TEXT_HIGHLIGHT =
+ new InputMethodHighlight(false, CONVERTED_TEXT);
+
+ public static final InputMethodHighlight
+ SELECTED_CONVERTED_TEXT_HIGHLIGHT =
+ new InputMethodHighlight(true, CONVERTED_TEXT);
+
+ private boolean selected;
+ private int state;
+ private int variation;
+ private Map<TextAttribute,?> style;
+
+ public InputMethodHighlight(boolean selected, int state, int variation) {
+ this(selected, state, variation, null);
+ }
+
+ public InputMethodHighlight(boolean selected, int state,
+ int variation, Map<java.awt.font.TextAttribute, ?> style) {
+ if ((state != RAW_TEXT) && (state != CONVERTED_TEXT)) {
+ // awt.20B=unknown input method highlight state
+ throw new IllegalArgumentException(Messages.getString("awt.20B")); //$NON-NLS-1$
+ }
+ this.selected = selected;
+ this.state = state;
+ this.variation = variation;
+ this.style = style;
+ }
+
+ public InputMethodHighlight(boolean selected, int state) {
+ this(selected, state, 0, null);
+ }
+
+ public int getState() {
+ return state;
+ }
+
+ public Map<java.awt.font.TextAttribute, ?> getStyle() {
+ return style;
+ }
+
+ public int getVariation() {
+ return variation;
+ }
+
+ public boolean isSelected() {
+ return selected;
+ }
+}
+
diff --git a/awt/java/awt/im/InputMethodRequests.java b/awt/java/awt/im/InputMethodRequests.java
new file mode 100644
index 0000000..bdd25e6
--- /dev/null
+++ b/awt/java/awt/im/InputMethodRequests.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.im;
+
+import java.awt.Rectangle;
+import java.awt.font.TextHitInfo;
+import java.text.AttributedCharacterIterator;
+
+public interface InputMethodRequests {
+
+ public AttributedCharacterIterator cancelLatestCommittedText(AttributedCharacterIterator.Attribute[] attributes);
+
+ public AttributedCharacterIterator getCommittedText(int beginIndex, int endIndex, AttributedCharacterIterator.Attribute[] attributes);
+
+ public int getCommittedTextLength();
+
+ public int getInsertPositionOffset();
+
+ public TextHitInfo getLocationOffset(int x, int y);
+
+ public AttributedCharacterIterator getSelectedText(AttributedCharacterIterator.Attribute[] attributes);
+
+ public Rectangle getTextLocation(TextHitInfo offset);
+}
+
diff --git a/awt/java/awt/im/InputSubset.java b/awt/java/awt/im/InputSubset.java
new file mode 100644
index 0000000..02a1049
--- /dev/null
+++ b/awt/java/awt/im/InputSubset.java
@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Dmitry A. Durnev
+ * @version $Revision$
+ */
+package java.awt.im;
+
+public final class InputSubset extends Character.Subset {
+
+ public static final InputSubset LATIN = new InputSubset("LATIN"); //$NON-NLS-1$
+
+ public static final InputSubset
+ LATIN_DIGITS = new InputSubset("LATIN_DIGITS"); //$NON-NLS-1$
+
+ public static final InputSubset
+ TRADITIONAL_HANZI = new InputSubset("TRADITIONAL_HANZI"); //$NON-NLS-1$
+
+ public static final InputSubset
+ SIMPLIFIED_HANZI = new InputSubset("SIMPLIFIED_HANZI"); //$NON-NLS-1$
+
+ public static final InputSubset KANJI = new InputSubset("KANJI"); //$NON-NLS-1$
+
+ public static final InputSubset HANJA = new InputSubset("HANJA"); //$NON-NLS-1$
+
+ public static final InputSubset
+ HALFWIDTH_KATAKANA = new InputSubset("HALFWIDTH_KATAKANA"); //$NON-NLS-1$
+
+ public static final InputSubset
+ FULLWIDTH_LATIN = new InputSubset("FULLWIDTH_LATIN"); //$NON-NLS-1$
+
+ public static final InputSubset
+ FULLWIDTH_DIGITS = new InputSubset("FULLWIDTH_DIGITS"); //$NON-NLS-1$
+
+ private InputSubset(String name) {
+ super(name);
+ }
+}
+
diff --git a/awt/java/awt/im/spi/InputMethod.java b/awt/java/awt/im/spi/InputMethod.java
new file mode 100644
index 0000000..2c98c46
--- /dev/null
+++ b/awt/java/awt/im/spi/InputMethod.java
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.im.spi;
+
+import java.awt.AWTEvent;
+import java.awt.Rectangle;
+import java.util.Locale;
+
+public interface InputMethod {
+
+ public void activate();
+
+ public void deactivate(boolean isTemporary);
+
+ public void dispatchEvent(AWTEvent event);
+
+ public void dispose();
+
+ public void endComposition();
+
+ public Object getControlObject();
+
+ public Locale getLocale();
+
+ public void hideWindows();
+
+ public boolean isCompositionEnabled();
+
+ public void notifyClientWindowChange(Rectangle bounds);
+
+ public void reconvert();
+
+ public void removeNotify();
+
+ public void setCharacterSubsets(Character.Subset[] subsets);
+
+ public void setCompositionEnabled(boolean enable);
+
+ public void setInputMethodContext(InputMethodContext context);
+
+ public boolean setLocale(Locale locale);
+}
+
diff --git a/awt/java/awt/im/spi/InputMethodContext.java b/awt/java/awt/im/spi/InputMethodContext.java
new file mode 100644
index 0000000..ca33e87
--- /dev/null
+++ b/awt/java/awt/im/spi/InputMethodContext.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.im.spi;
+
+//???AWT: import java.awt.Window;
+import java.awt.font.TextHitInfo;
+import java.awt.im.InputMethodRequests;
+import java.text.AttributedCharacterIterator;
+//???AWT: import javax.swing.JFrame;
+
+public interface InputMethodContext extends InputMethodRequests {
+
+// ???AWT: public JFrame createInputMethodJFrame(String title, boolean attachToInputContext);
+
+// ???AWT: public Window createInputMethodWindow(String title, boolean attachToInputContext);
+
+ public void dispatchInputMethodEvent(int id, AttributedCharacterIterator text, int committedCharacterCount, TextHitInfo caret, TextHitInfo visiblePosition);
+
+ public void enableClientWindowNotification(InputMethod inputMethod, boolean enable);
+
+}
+
diff --git a/awt/java/awt/im/spi/InputMethodDescriptor.java b/awt/java/awt/im/spi/InputMethodDescriptor.java
new file mode 100644
index 0000000..3068cac
--- /dev/null
+++ b/awt/java/awt/im/spi/InputMethodDescriptor.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.im.spi;
+
+import java.awt.AWTException;
+import java.awt.Image;
+import java.util.Locale;
+
+public interface InputMethodDescriptor {
+
+ public Locale[] getAvailableLocales() throws AWTException;
+
+ public InputMethod createInputMethod() throws Exception;
+
+ public String getInputMethodDisplayName(Locale inputLocale, Locale displayLanguage);
+
+ public Image getInputMethodIcon(Locale inputLocale);
+
+ public boolean hasDynamicLocaleList();
+
+}
+
diff --git a/awt/java/awt/image/AffineTransformOp.java b/awt/java/awt/image/AffineTransformOp.java
new file mode 100644
index 0000000..546837a
--- /dev/null
+++ b/awt/java/awt/image/AffineTransformOp.java
@@ -0,0 +1,617 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky, Denis M. Kishenko
+ * @version $Revision$
+ */
+
+package java.awt.image;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.awt.geom.Point2D;
+import java.awt.geom.NoninvertibleTransformException;
+import java.awt.*;
+import java.util.Arrays;
+
+import org.apache.harmony.awt.gl.AwtImageBackdoorAccessor;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The AffineTransform class translates coordinates from 2D coordinates
+ * in the source image or Raster to 2D coordinates in the destination
+ * image or Raster using Affine transformation. The number of bands in
+ * the source Raster should equal to the number of bands in the destination
+ * Raster.
+ */
+public class AffineTransformOp implements BufferedImageOp, RasterOp {
+
+ /**
+ * The Constant TYPE_NEAREST_NEIGHBOR indicates nearest-neighbor
+ * interpolation type.
+ */
+ public static final int TYPE_NEAREST_NEIGHBOR = 1;
+
+ /**
+ * The Constant TYPE_BILINEAR indicates bilinear interpolation type.
+ */
+ public static final int TYPE_BILINEAR = 2;
+
+ /** The Constant TYPE_BICUBIC indicates bicubic interpolation type. */
+ public static final int TYPE_BICUBIC = 3;
+
+ /** The i type. */
+ private int iType; // interpolation type
+
+ /** The at. */
+ private AffineTransform at;
+
+ /** The hints. */
+ private RenderingHints hints;
+
+ static {
+ // TODO - uncomment
+ //System.loadLibrary("imageops");
+ }
+
+ /**
+ * Instantiates a new AffineTransformOp with the specified
+ * AffineTransform and RenderingHints object which defines
+ * the interpolation type.
+ *
+ * @param xform the AffineTransform.
+ * @param hints the RenderingHints object which defines
+ * the interpolation type.
+ */
+ public AffineTransformOp(AffineTransform xform, RenderingHints hints) {
+ this(xform, TYPE_NEAREST_NEIGHBOR);
+ this.hints = hints;
+
+ if (hints != null) {
+ Object hint = hints.get(RenderingHints.KEY_INTERPOLATION);
+ if (hint != null) {
+ // Nearest neighbor is default
+ if (hint == RenderingHints.VALUE_INTERPOLATION_BILINEAR) {
+ this.iType = TYPE_BILINEAR;
+ } else if (hint == RenderingHints.VALUE_INTERPOLATION_BICUBIC) {
+ this.iType = TYPE_BICUBIC;
+ }
+ } else {
+ hint = hints.get(RenderingHints.KEY_RENDERING);
+ // Determine from rendering quality
+ if (hint == RenderingHints.VALUE_RENDER_QUALITY) {
+ this.iType = TYPE_BILINEAR;
+ // For speed use nearest neighbor
+ }
+ }
+ }
+ }
+
+ /**
+ * Instantiates a new AffineTransformOp with the specified
+ * AffineTransform and a specified interpolation type from the
+ * list of predefined interpolation types.
+ *
+ * @param xform the AffineTransform.
+ * @param interp the one of predefined interpolation types:
+ * TYPE_NEAREST_NEIGHBOR, TYPE_BILINEAR, or TYPE_BICUBIC.
+ */
+ public AffineTransformOp(AffineTransform xform, int interp) {
+ if (Math.abs(xform.getDeterminant()) <= Double.MIN_VALUE) {
+ // awt.24F=Unable to invert transform {0}
+ throw new ImagingOpException(Messages.getString("awt.24F", xform)); //$NON-NLS-1$
+ }
+
+ this.at = (AffineTransform) xform.clone();
+
+ if (interp != TYPE_NEAREST_NEIGHBOR && interp != TYPE_BILINEAR && interp != TYPE_BICUBIC) {
+ // awt.250=Unknown interpolation type: {0}
+ throw new IllegalArgumentException(Messages.getString("awt.250", interp)); //$NON-NLS-1$
+ }
+
+ this.iType = interp;
+ }
+
+ /**
+ * Gets the interpolation type.
+ *
+ * @return the interpolation type
+ */
+ public final int getInterpolationType() {
+ return iType;
+ }
+
+ public final RenderingHints getRenderingHints() {
+ if (hints == null) {
+ Object value = null;
+
+ switch (iType) {
+ case TYPE_NEAREST_NEIGHBOR:
+ value = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
+ break;
+ case TYPE_BILINEAR:
+ value = RenderingHints.VALUE_INTERPOLATION_BILINEAR;
+ break;
+ case TYPE_BICUBIC:
+ value = RenderingHints.VALUE_INTERPOLATION_BICUBIC;
+ break;
+ default:
+ value = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
+ }
+
+ hints = new RenderingHints(RenderingHints.KEY_INTERPOLATION, value);
+ }
+
+ return hints;
+ }
+
+ /**
+ * Gets the affine transform associated with this AffineTransformOp.
+ *
+ * @return the AffineTransform.
+ */
+ public final AffineTransform getTransform() {
+ return (AffineTransform) at.clone();
+ }
+
+ public final Point2D getPoint2D(Point2D srcPt, Point2D dstPt) {
+ return at.transform(srcPt, dstPt);
+ }
+
+ public final Rectangle2D getBounds2D(BufferedImage src) {
+ return getBounds2D(src.getRaster());
+ }
+
+ public final Rectangle2D getBounds2D(Raster src) {
+ // We position source raster to (0,0) even if it is translated child raster.
+ // This means that we need only width and height of the src
+ int width = src.getWidth();
+ int height = src.getHeight();
+
+ float[] corners = {
+ 0, 0,
+ width, 0,
+ width, height,
+ 0, height
+ };
+
+ at.transform(corners, 0, corners, 0, 4);
+
+ Rectangle2D.Float bounds = new Rectangle2D.Float(corners[0], corners[1], 0 , 0);
+ bounds.add(corners[2], corners[3]);
+ bounds.add(corners[4], corners[5]);
+ bounds.add(corners[6], corners[7]);
+
+ return bounds;
+ }
+
+ public BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel destCM) {
+ Rectangle2D newBounds = getBounds2D(src);
+
+ // Destination image should include (0,0) + positive part
+ // of the area bounded by newBounds (in source coordinate system).
+ double dstWidth = newBounds.getX() + newBounds.getWidth();
+ double dstHeight = newBounds.getY() + newBounds.getHeight();
+
+ if (dstWidth <= 0 || dstHeight <= 0) {
+ // awt.251=Transformed width ({0}) and height ({1}) should be greater than 0
+ throw new RasterFormatException(
+ Messages.getString("awt.251", dstWidth, dstHeight)); //$NON-NLS-1$
+ }
+
+ if (destCM != null) {
+ return new BufferedImage(destCM,
+ destCM.createCompatibleWritableRaster((int)dstWidth, (int)dstHeight),
+ destCM.isAlphaPremultiplied(),
+ null
+ );
+ }
+
+ ColorModel cm = src.getColorModel();
+
+ // Interpolation other than NN doesn't make any sense for index color
+ if (iType != TYPE_NEAREST_NEIGHBOR && cm instanceof IndexColorModel) {
+ return new BufferedImage((int)dstWidth, (int)dstHeight, BufferedImage.TYPE_INT_ARGB);
+ }
+
+ // OK, we can get source color model
+ return new BufferedImage(cm,
+ src.getRaster().createCompatibleWritableRaster((int)dstWidth, (int)dstHeight),
+ cm.isAlphaPremultiplied(),
+ null
+ );
+ }
+
+ public WritableRaster createCompatibleDestRaster (Raster src) {
+ // Here approach is other then in createCompatibleDestImage -
+ // destination should include only
+ // transformed image, but not (0,0) in source coordinate system
+
+ Rectangle2D newBounds = getBounds2D(src);
+ return src.createCompatibleWritableRaster(
+ (int) newBounds.getX(), (int) newBounds.getY(),
+ (int) newBounds.getWidth(), (int)newBounds.getHeight()
+ );
+ }
+
+ public final BufferedImage filter(BufferedImage src, BufferedImage dst) {
+ if (src == dst) {
+ // awt.252=Source can't be same as the destination
+ throw new IllegalArgumentException(Messages.getString("awt.252")); //$NON-NLS-1$
+ }
+
+ ColorModel srcCM = src.getColorModel();
+ BufferedImage finalDst = null;
+
+ if (
+ srcCM instanceof IndexColorModel &&
+ (iType != TYPE_NEAREST_NEIGHBOR || srcCM.getPixelSize() % 8 != 0)
+ ) {
+ src = ((IndexColorModel)srcCM).convertToIntDiscrete(src.getRaster(), true);
+ srcCM = src.getColorModel();
+ }
+
+ if (dst == null) {
+ dst = createCompatibleDestImage(src, srcCM);
+ } else {
+ if (!srcCM.equals(dst.getColorModel())) {
+ // Treat BufferedImage.TYPE_INT_RGB and BufferedImage.TYPE_INT_ARGB as same
+ if (
+ !(
+ (src.getType() == BufferedImage.TYPE_INT_RGB ||
+ src.getType() == BufferedImage.TYPE_INT_ARGB) &&
+ (dst.getType() == BufferedImage.TYPE_INT_RGB ||
+ dst.getType() == BufferedImage.TYPE_INT_ARGB)
+ )
+ ) {
+ finalDst = dst;
+ dst = createCompatibleDestImage(src, srcCM);
+ }
+ }
+ }
+
+ // Skip alpha channel for TYPE_INT_RGB images
+ if (slowFilter(src.getRaster(), dst.getRaster()) != 0) {
+ // awt.21F=Unable to transform source
+ throw new ImagingOpException (Messages.getString("awt.21F")); //$NON-NLS-1$
+ // TODO - uncomment
+ //if (ippFilter(src.getRaster(), dst.getRaster(), src.getType()) != 0)
+ //throw new ImagingOpException ("Unable to transform source");
+ }
+
+ if (finalDst != null) {
+ Graphics2D g = finalDst.createGraphics();
+ g.setComposite(AlphaComposite.Src);
+ g.drawImage(dst, 0, 0, null);
+ } else {
+ finalDst = dst;
+ }
+
+ return finalDst;
+ }
+
+ public final WritableRaster filter(Raster src, WritableRaster dst) {
+ if (src == dst) {
+ // awt.252=Source can't be same as the destination
+ throw new IllegalArgumentException(Messages.getString("awt.252")); //$NON-NLS-1$
+ }
+
+ if (dst == null) {
+ dst = createCompatibleDestRaster(src);
+ } else if (src.getNumBands() != dst.getNumBands()) {
+ // awt.253=Different number of bands in source and destination
+ throw new IllegalArgumentException(Messages.getString("awt.253")); //$NON-NLS-1$
+ }
+
+ if (slowFilter(src, dst) != 0) {
+ // awt.21F=Unable to transform source
+ throw new ImagingOpException(Messages.getString("awt.21F")); //$NON-NLS-1$
+ // TODO - uncomment
+ //if (ippFilter(src, dst, BufferedImage.TYPE_CUSTOM) != 0)
+ // throw new ImagingOpException("Unable to transform source");
+ }
+
+ return dst;
+ }
+
+ // TODO remove when method is used
+ /**
+ * Ipp filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ * @param imageType the image type
+ *
+ * @return the int
+ */
+ @SuppressWarnings("unused")
+ private int ippFilter(Raster src, WritableRaster dst, int imageType) {
+ int srcStride, dstStride;
+ boolean skipChannel = false;
+ int channels;
+ int offsets[] = null;
+
+ switch (imageType) {
+ case BufferedImage.TYPE_INT_RGB:
+ case BufferedImage.TYPE_INT_BGR: {
+ channels = 4;
+ srcStride = src.getWidth()*4;
+ dstStride = dst.getWidth()*4;
+ skipChannel = true;
+ break;
+ }
+
+ case BufferedImage.TYPE_INT_ARGB:
+ case BufferedImage.TYPE_INT_ARGB_PRE:
+ case BufferedImage.TYPE_4BYTE_ABGR:
+ case BufferedImage.TYPE_4BYTE_ABGR_PRE: {
+ channels = 4;
+ srcStride = src.getWidth()*4;
+ dstStride = dst.getWidth()*4;
+ break;
+ }
+
+ case BufferedImage.TYPE_BYTE_GRAY:
+ case BufferedImage.TYPE_BYTE_INDEXED: {
+ channels = 1;
+ srcStride = src.getWidth();
+ dstStride = dst.getWidth();
+ break;
+ }
+
+ case BufferedImage.TYPE_3BYTE_BGR: {
+ channels = 3;
+ srcStride = src.getWidth()*3;
+ dstStride = dst.getWidth()*3;
+ break;
+ }
+
+ case BufferedImage.TYPE_USHORT_GRAY: // TODO - could be done in native code?
+ case BufferedImage.TYPE_USHORT_565_RGB:
+ case BufferedImage.TYPE_USHORT_555_RGB:
+ case BufferedImage.TYPE_BYTE_BINARY: {
+ return slowFilter(src, dst);
+ }
+
+ default: {
+ SampleModel srcSM = src.getSampleModel();
+ SampleModel dstSM = dst.getSampleModel();
+
+ if (
+ srcSM instanceof PixelInterleavedSampleModel &&
+ dstSM instanceof PixelInterleavedSampleModel
+ ) {
+ // Check PixelInterleavedSampleModel
+ if (
+ srcSM.getDataType() != DataBuffer.TYPE_BYTE ||
+ dstSM.getDataType() != DataBuffer.TYPE_BYTE
+ ) {
+ return slowFilter(src, dst);
+ }
+
+ channels = srcSM.getNumBands(); // Have IPP functions for 1, 3 and 4 channels
+ if (channels != 1 && channels != 3 && channels != 4) {
+ return slowFilter(src, dst);
+ }
+
+ int dataTypeSize = DataBuffer.getDataTypeSize(srcSM.getDataType()) / 8;
+
+ srcStride = ((ComponentSampleModel) srcSM).getScanlineStride() * dataTypeSize;
+ dstStride = ((ComponentSampleModel) dstSM).getScanlineStride() * dataTypeSize;
+ } else if (
+ srcSM instanceof SinglePixelPackedSampleModel &&
+ dstSM instanceof SinglePixelPackedSampleModel
+ ) {
+ // Check SinglePixelPackedSampleModel
+ SinglePixelPackedSampleModel sppsm1 = (SinglePixelPackedSampleModel) srcSM;
+ SinglePixelPackedSampleModel sppsm2 = (SinglePixelPackedSampleModel) dstSM;
+
+ // No IPP function for this type
+ if (sppsm1.getDataType() == DataBuffer.TYPE_USHORT) {
+ return slowFilter(src, dst);
+ }
+
+ channels = sppsm1.getNumBands();
+ // Have IPP functions for 1, 3 and 4 channels
+ if (channels != 1 && channels != 3 && channels != 4) {
+ return slowFilter(src, dst);
+ }
+
+ // Check compatibility of sample models
+ if (
+ sppsm1.getDataType() != sppsm2.getDataType() ||
+ !Arrays.equals(sppsm1.getBitOffsets(), sppsm2.getBitOffsets()) ||
+ !Arrays.equals(sppsm1.getBitMasks(), sppsm2.getBitMasks())
+ ) {
+ return slowFilter(src, dst);
+ }
+
+ for (int i=0; i<channels; i++) {
+ if (sppsm1.getSampleSize(i) != 8) {
+ return slowFilter(src, dst);
+ }
+ }
+
+ if (channels == 3) {
+ channels = 4;
+ }
+
+ int dataTypeSize = DataBuffer.getDataTypeSize(sppsm1.getDataType()) / 8;
+
+ srcStride = sppsm1.getScanlineStride() * dataTypeSize;
+ dstStride = sppsm2.getScanlineStride() * dataTypeSize;
+ } else {
+ return slowFilter(src, dst);
+ }
+
+ // Fill offsets if there's a child raster
+ if (src.getParent() != null || dst.getParent() != null) {
+ if (
+ src.getSampleModelTranslateX() != 0 ||
+ src.getSampleModelTranslateY() != 0 ||
+ dst.getSampleModelTranslateX() != 0 ||
+ dst.getSampleModelTranslateY() != 0
+ ) {
+ offsets = new int[4];
+ offsets[0] = -src.getSampleModelTranslateX() + src.getMinX();
+ offsets[1] = -src.getSampleModelTranslateY() + src.getMinY();
+ offsets[2] = -dst.getSampleModelTranslateX() + dst.getMinX();
+ offsets[3] = -dst.getSampleModelTranslateY() + dst.getMinY();
+ }
+ }
+ }
+ }
+
+ double m00 = at.getScaleX();
+ double m01 = at.getShearX();
+ double m02 = at.getTranslateX();
+ double m10 = at.getShearY();
+ double m11 = at.getScaleY();
+ double m12 = at.getTranslateY();
+
+ Object srcData, dstData;
+ AwtImageBackdoorAccessor dbAccess = AwtImageBackdoorAccessor.getInstance();
+ try {
+ srcData = dbAccess.getData(src.getDataBuffer());
+ dstData = dbAccess.getData(dst.getDataBuffer());
+ } catch (IllegalArgumentException e) {
+ return -1; // Unknown data buffer type
+ }
+
+ return ippAffineTransform(
+ m00, m01, m02, m10, m11, m12,
+ srcData, src.getWidth(), src.getHeight(), srcStride,
+ dstData, dst.getWidth(), dst.getHeight(), dstStride,
+ iType, channels, skipChannel, offsets);
+ }
+
+ /**
+ * Slow filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ *
+ * @return the int
+ */
+ private int slowFilter(Raster src, WritableRaster dst) {
+ // TODO: make correct interpolation
+ // TODO: what if there are different data types?
+
+ Rectangle srcBounds = src.getBounds();
+ Rectangle dstBounds = dst.getBounds();
+ Rectangle normDstBounds = new Rectangle(0, 0, dstBounds.width, dstBounds.height);
+ Rectangle bounds = getBounds2D(src).getBounds().intersection(normDstBounds);
+
+ AffineTransform inv = null;
+ try {
+ inv = at.createInverse();
+ } catch (NoninvertibleTransformException e) {
+ return -1;
+ }
+
+ double[] m = new double[6];
+ inv.getMatrix(m);
+
+ int minSrcX = srcBounds.x;
+ int minSrcY = srcBounds.y;
+ int maxSrcX = srcBounds.x + srcBounds.width;
+ int maxSrcY = srcBounds.y + srcBounds.height;
+
+ int minX = bounds.x + dstBounds.x;
+ int minY = bounds.y + dstBounds.y;
+ int maxX = minX + bounds.width;
+ int maxY = minY + bounds.height;
+
+ int hx = (int)(m[0] * 256);
+ int hy = (int)(m[1] * 256);
+ int vx = (int)(m[2] * 256);
+ int vy = (int)(m[3] * 256);
+ int sx = (int)(m[4] * 256) + hx * bounds.x + vx * bounds.y + (srcBounds.x) * 256;
+ int sy = (int)(m[5] * 256) + hy * bounds.x + vy * bounds.y + (srcBounds.y) * 256;
+
+ vx -= hx * bounds.width;
+ vy -= hy * bounds.width;
+
+ if (src.getTransferType() == dst.getTransferType()) {
+ for (int y = minY; y < maxY; y++) {
+ for (int x = minX; x < maxX; x++) {
+ int px = sx >> 8;
+ int py = sy >> 8;
+ if (px >= minSrcX && py >= minSrcY && px < maxSrcX && py < maxSrcY) {
+ Object val = src.getDataElements(px , py , null);
+ dst.setDataElements(x, y, val);
+ }
+ sx += hx;
+ sy += hy;
+ }
+ sx += vx;
+ sy += vy;
+ }
+ } else {
+ float pixel[] = null;
+ for (int y = minY; y < maxY; y++) {
+ for (int x = minX; x < maxX; x++) {
+ int px = sx >> 8;
+ int py = sy >> 8;
+ if (px >= minSrcX && py >= minSrcY && px < maxSrcX && py < maxSrcY) {
+ pixel = src.getPixel(px, py, pixel);
+ dst.setPixel(x, y, pixel);
+ }
+ sx += hx;
+ sy += hy;
+ }
+ sx += vx;
+ sy += vy;
+ }
+ }
+
+ return 0;
+ }
+
+ /**
+ * Ipp affine transform.
+ *
+ * @param m00 the m00
+ * @param m01 the m01
+ * @param m02 the m02
+ * @param m10 the m10
+ * @param m11 the m11
+ * @param m12 the m12
+ * @param src the src
+ * @param srcWidth the src width
+ * @param srcHeight the src height
+ * @param srcStride the src stride
+ * @param dst the dst
+ * @param dstWidth the dst width
+ * @param dstHeight the dst height
+ * @param dstStride the dst stride
+ * @param iType the i type
+ * @param channels the channels
+ * @param skipChannel the skip channel
+ * @param offsets the offsets
+ *
+ * @return the int
+ */
+ private native int ippAffineTransform(
+ double m00, double m01,
+ double m02, double m10,
+ double m11, double m12,
+ Object src, int srcWidth, int srcHeight, int srcStride,
+ Object dst, int dstWidth, int dstHeight, int dstStride,
+ int iType, int channels, boolean skipChannel,
+ int offsets[]);
+}
\ No newline at end of file
diff --git a/awt/java/awt/image/AreaAveragingScaleFilter.java b/awt/java/awt/image/AreaAveragingScaleFilter.java
new file mode 100644
index 0000000..f4933db
--- /dev/null
+++ b/awt/java/awt/image/AreaAveragingScaleFilter.java
@@ -0,0 +1,253 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.util.Arrays;
+
+
+/**
+ * The AreaAveragingScaleFilter class scales the source image using
+ * area averaging algorithm. This algorithm provides a source image
+ * with a new image containing the resampled image.
+ */
+public class AreaAveragingScaleFilter extends ReplicateScaleFilter {
+
+ /** The Constant rgbCM. */
+ private static final ColorModel rgbCM = ColorModel.getRGBdefault();
+
+ /** The Constant averagingFlags. */
+ private static final int averagingFlags = (ImageConsumer.TOPDOWNLEFTRIGHT |
+ ImageConsumer.COMPLETESCANLINES);
+
+ /** The reset. */
+ private boolean reset = true; // Flag for used superclass filter
+
+ /** The inited. */
+ private boolean inited = false; // All data inited
+
+ /** The sum_r. */
+ private int sum_r[]; // Array for average Red samples
+
+ /** The sum_g. */
+ private int sum_g[]; // Array for average Green samples
+
+ /** The sum_b. */
+ private int sum_b[]; // Array for average Blue samples
+
+ /** The sum_a. */
+ private int sum_a[]; // Array for average Alpha samples
+
+ /** The buff. */
+ private int buff[]; // Stride buffer
+
+ /** The avg factor. */
+ private int avgFactor; // Global averaging factor
+
+ /** The cached dy. */
+ private int cachedDY; // Cached number of the destination scanline
+
+ /** The cached dv rest. */
+ private int cachedDVRest; // Cached value of rest src scanlines for sum
+ // pixel samples
+ // Because data if transfering by whole scanlines
+ // we are caching only Y coordinate values
+
+ /**
+ * Instantiates a new AreaAveragingScaleFilter object which scales
+ * a source image with the specified width and height.
+ *
+ * @param width the scaled width of the image.
+ * @param height the scaled height of the image.
+ */
+ public AreaAveragingScaleFilter(int width, int height) {
+ super(width, height);
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h, ColorModel model, int[] pixels, int off, int scansize) {
+ if(reset) {
+ super.setPixels(x, y, w, h, model, pixels, off, scansize);
+ } else {
+ setFilteredPixels(x, y, w, h, model, pixels, off, scansize);
+ }
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h, ColorModel model, byte[] pixels, int off, int scansize) {
+ if(reset) {
+ super.setPixels(x, y, w, h, model, pixels, off, scansize);
+ } else {
+ setFilteredPixels(x, y, w, h, model, pixels, off, scansize);
+ }
+ }
+
+ @Override
+ public void setHints(int hints) {
+ super.setHints(hints);
+ reset = ((hints & averagingFlags) != averagingFlags);
+ }
+
+ /**
+ * This method implements the Area Averaging Scale filter.
+ * The description of algorithm is presented in Java API Specification.
+ *
+ * Arrays sum_r, sum_g, sum_b, sum_a have length equals width of destination
+ * image. In each array's element is accumulating pixel's component values,
+ * proportional to the area which source pixels will occupy in destination
+ * image. Then that values will divide by Global averaging
+ * factor (area of the destination image) for receiving
+ * average values of destination pixels.
+ *
+ * @param x - Src pixels X coordinate
+ * @param y - Src pixels Y coordinate
+ * @param w - width of the area of Src pixels
+ * @param h - height of the area of Src pixels
+ * @param model - Color Model of Src pixels
+ * @param pixels - array of Src pixels
+ * @param off - offset into the Src pixels array
+ * @param scansize - length of scanline in the pixels array
+ */
+ private void setFilteredPixels(int x, int y, int w, int h, ColorModel model, Object pixels, int off, int scansize){
+ if(!inited){
+ initialize();
+ }
+
+ int srcX, srcY, dx, dy;
+ int svRest, dvRest, shRest, dhRest, vDif, hDif;
+
+ if(y == 0){
+ dy = 0;
+ dvRest = srcHeight;
+ }else{
+ dy = cachedDY;
+ dvRest = cachedDVRest;
+ }
+
+ srcY = y;
+ svRest = destHeight;
+
+ int srcOff = off;
+ while (srcY < y + h) {
+ if (svRest < dvRest) {
+ vDif = svRest;
+ } else {
+ vDif = dvRest;
+ }
+
+ srcX = 0;
+ dx = 0;
+ shRest = destWidth;
+ dhRest = srcWidth;
+ while (srcX < w) {
+ if (shRest < dhRest) {
+ hDif = shRest;
+ } else {
+ hDif = dhRest;
+ }
+ int avg = hDif * vDif; // calculation of contribution factor
+
+ int rgb, pix;
+ if (pixels instanceof int[]) {
+ pix = ((int[]) pixels)[srcOff + srcX];
+ } else {
+ pix = ((byte[]) pixels)[srcOff + srcX] & 0xff;
+ }
+
+ rgb = model.getRGB(pix);
+ int a = rgb >>> 24;
+ int r = (rgb >> 16) & 0xff;
+ int g = (rgb >> 8) & 0xff;
+ int b = rgb & 0xff;
+
+ // accumulating pixel's component values
+ sum_a[dx] += a * avg;
+ sum_r[dx] += r * avg;
+ sum_g[dx] += g * avg;
+ sum_b[dx] += b * avg;
+
+ shRest -= hDif;
+ dhRest -= hDif;
+
+ if (shRest == 0) {
+ srcX++;
+ shRest = destWidth;
+ }
+
+ if (dhRest == 0) {
+ dx++;
+ dhRest = srcWidth;
+ }
+ }
+
+ svRest -= vDif;
+ dvRest -= vDif;
+
+ if (svRest == 0) {
+ svRest = destHeight;
+ srcY++;
+ srcOff += scansize;
+ }
+
+ if (dvRest == 0) {
+ // averaging destination pixel's values
+ for(int i = 0; i < destWidth; i++){
+ int a = (sum_a[i] / avgFactor) & 0xff;
+ int r = (sum_r[i] / avgFactor) & 0xff;
+ int g = (sum_g[i] / avgFactor) & 0xff;
+ int b = (sum_b[i] / avgFactor) & 0xff;
+ int frgb = (a << 24) | (r << 16) | (g << 8) | b;
+ buff[i] = frgb;
+ }
+ consumer.setPixels(0, dy, destWidth, 1, rgbCM, buff, 0,
+ destWidth);
+ dy++;
+ dvRest = srcHeight;
+ Arrays.fill(sum_a, 0);
+ Arrays.fill(sum_r, 0);
+ Arrays.fill(sum_g, 0);
+ Arrays.fill(sum_b, 0);
+ }
+
+ }
+
+ cachedDY = dy;
+ cachedDVRest = dvRest;
+
+ }
+
+ /**
+ * Initialization of the auxiliary data.
+ */
+ private void initialize(){
+
+ sum_a = new int[destWidth];
+ sum_r = new int[destWidth];
+ sum_g = new int[destWidth];
+ sum_b = new int[destWidth];
+
+ buff = new int[destWidth];
+ outpixbuf = buff;
+ avgFactor = srcWidth * srcHeight;
+
+ inited = true;
+ }
+}
+
diff --git a/awt/java/awt/image/AwtImageBackdoorAccessorImpl.java b/awt/java/awt/image/AwtImageBackdoorAccessorImpl.java
new file mode 100644
index 0000000..ce85ddd
--- /dev/null
+++ b/awt/java/awt/image/AwtImageBackdoorAccessorImpl.java
@@ -0,0 +1,153 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ * Created on 23.11.2005
+ *
+ */
+package java.awt.image;
+
+import java.awt.Image;
+import java.awt.image.DataBuffer;
+import java.awt.image.DataBufferByte;
+import java.awt.image.DataBufferDouble;
+import java.awt.image.DataBufferFloat;
+import java.awt.image.DataBufferInt;
+import java.awt.image.DataBufferShort;
+import java.awt.image.DataBufferUShort;
+
+import org.apache.harmony.awt.gl.AwtImageBackdoorAccessor;
+import org.apache.harmony.awt.gl.GLVolatileImage;
+import org.apache.harmony.awt.gl.Surface;
+import org.apache.harmony.awt.gl.image.DataBufferListener;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * This class not part of public API. It useful for receiving package private
+ * data from other packages.
+ */
+class AwtImageBackdoorAccessorImpl extends AwtImageBackdoorAccessor {
+
+ static void init(){
+ inst = new AwtImageBackdoorAccessorImpl();
+ }
+
+ @Override
+ public Surface getImageSurface(Image image) {
+ if (image instanceof BufferedImage){
+ return ((BufferedImage)image).getImageSurface();
+ } else if (image instanceof GLVolatileImage){
+ return ((GLVolatileImage)image).getImageSurface();
+ }
+ return null;
+ }
+
+ @Override
+ public boolean isGrayPallete(IndexColorModel icm){
+ return icm.isGrayPallete();
+ }
+
+ @Override
+ public Object getData(DataBuffer db) {
+ if (db instanceof DataBufferByte){
+ return ((DataBufferByte)db).getData();
+ } else if (db instanceof DataBufferUShort){
+ return ((DataBufferUShort)db).getData();
+ } else if (db instanceof DataBufferShort){
+ return ((DataBufferShort)db).getData();
+ } else if (db instanceof DataBufferInt){
+ return ((DataBufferInt)db).getData();
+ } else if (db instanceof DataBufferFloat){
+ return ((DataBufferFloat)db).getData();
+ } else if (db instanceof DataBufferDouble){
+ return ((DataBufferDouble)db).getData();
+ } else {
+ // awt.235=Wrong Data Buffer type : {0}
+ throw new IllegalArgumentException(Messages.getString("awt.235", //$NON-NLS-1$
+ db.getClass()));
+ }
+ }
+
+ @Override
+ public int[] getDataInt(DataBuffer db) {
+ if (db instanceof DataBufferInt){
+ return ((DataBufferInt)db).getData();
+ }
+ return null;
+ }
+
+ @Override
+ public byte[] getDataByte(DataBuffer db) {
+ if (db instanceof DataBufferByte){
+ return ((DataBufferByte)db).getData();
+ }
+ return null;
+ }
+
+ @Override
+ public short[] getDataShort(DataBuffer db) {
+ if (db instanceof DataBufferShort){
+ return ((DataBufferShort)db).getData();
+ }
+ return null;
+ }
+
+ @Override
+ public short[] getDataUShort(DataBuffer db) {
+ if (db instanceof DataBufferUShort){
+ return ((DataBufferUShort)db).getData();
+ }
+ return null;
+ }
+
+ @Override
+ public double[] getDataDouble(DataBuffer db) {
+ if (db instanceof DataBufferDouble){
+ return ((DataBufferDouble)db).getData();
+ }
+ return null;
+ }
+
+ @Override
+ public float[] getDataFloat(DataBuffer db) {
+ if (db instanceof DataBufferFloat){
+ return ((DataBufferFloat)db).getData();
+ }
+ return null;
+ }
+
+ @Override
+ public void addDataBufferListener(DataBuffer db, DataBufferListener listener) {
+ db.addDataBufferListener(listener);
+ }
+
+ @Override
+ public void removeDataBufferListener(DataBuffer db) {
+ db.removeDataBufferListener();
+ }
+
+ @Override
+ public void validate(DataBuffer db) {
+ db.validate();
+ }
+
+ @Override
+ public void releaseData(DataBuffer db) {
+ db.releaseData();
+ }
+}
diff --git a/awt/java/awt/image/BandCombineOp.java b/awt/java/awt/image/BandCombineOp.java
new file mode 100644
index 0000000..cd77a21
--- /dev/null
+++ b/awt/java/awt/image/BandCombineOp.java
@@ -0,0 +1,610 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ *
+ * @date: Sep 20, 2005
+ */
+
+package java.awt.image;
+
+import java.awt.*;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.util.Arrays;
+
+import org.apache.harmony.awt.gl.AwtImageBackdoorAccessor;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The BandCombineOp class translates coordinates from
+ * coordinates in the source Raster to coordinates in
+ * the destination Raster by an arbitrary linear combination
+ * of the bands in a source Raster, using a specified matrix.
+ * The number of bands in the matrix should equal to
+ * the number of bands in the source Raster plus 1.
+ */
+public class BandCombineOp implements RasterOp {
+
+ /** The Constant offsets3c. */
+ static final int offsets3c[] = {16, 8, 0};
+
+ /** The Constant offsets4ac. */
+ static final int offsets4ac[] = {16, 8, 0, 24};
+
+ /** The Constant masks3c. */
+ static final int masks3c[] = {0xFF0000, 0xFF00, 0xFF};
+
+ /** The Constant masks4ac. */
+ static final int masks4ac[] = {0xFF0000, 0xFF00, 0xFF, 0xFF000000};
+
+ /** The Constant piOffsets. */
+ private static final int piOffsets[] = {0, 1, 2};
+
+ /** The Constant piInvOffsets. */
+ private static final int piInvOffsets[] = {2, 1, 0};
+
+ /** The Constant TYPE_BYTE3C. */
+ private static final int TYPE_BYTE3C = 0;
+
+ /** The Constant TYPE_BYTE4AC. */
+ private static final int TYPE_BYTE4AC = 1;
+
+ /** The Constant TYPE_USHORT3C. */
+ private static final int TYPE_USHORT3C = 2;
+
+ /** The Constant TYPE_SHORT3C. */
+ private static final int TYPE_SHORT3C = 3;
+
+ /** The mx width. */
+ private int mxWidth;
+
+ /** The mx height. */
+ private int mxHeight;
+
+ /** The matrix. */
+ private float matrix[][];
+
+ /** The r hints. */
+ private RenderingHints rHints;
+
+ static {
+ // XXX - todo
+ //System.loadLibrary("imageops");
+ }
+
+ /**
+ * Instantiates a new BandCombineOp object with the specified
+ * matrix.
+ *
+ * @param matrix the specified matrix for band combining.
+ * @param hints the RenderingHints.
+ */
+ public BandCombineOp(float matrix[][], RenderingHints hints) {
+ this.mxHeight = matrix.length;
+ this.mxWidth = matrix[0].length;
+ this.matrix = new float[mxHeight][mxWidth];
+
+ for (int i=0; i<mxHeight; i++){
+ System.arraycopy(matrix[i], 0, this.matrix[i], 0, mxWidth);
+ }
+
+ this.rHints = hints;
+ }
+
+ public final RenderingHints getRenderingHints(){
+ return this.rHints;
+ }
+
+ /**
+ * Gets the matrix associated with this BandCombineOp object.
+ *
+ * @return the matrix associated with this BandCombineOp object.
+ */
+ public final float[][] getMatrix() {
+ float res[][] = new float[mxHeight][mxWidth];
+
+ for (int i=0; i<mxHeight; i++) {
+ System.arraycopy(matrix[i], 0, res[i], 0, mxWidth);
+ }
+
+ return res;
+ }
+
+ public final Point2D getPoint2D (Point2D srcPoint, Point2D dstPoint) {
+ if (dstPoint == null) {
+ dstPoint = new Point2D.Float();
+ }
+
+ dstPoint.setLocation(srcPoint);
+ return dstPoint;
+ }
+
+ public final Rectangle2D getBounds2D(Raster src){
+ return src.getBounds();
+ }
+
+ public WritableRaster createCompatibleDestRaster (Raster src) {
+ int numBands = src.getNumBands();
+ if (mxWidth != numBands && mxWidth != (numBands+1) || numBands != mxHeight) {
+ // awt.254=Number of bands in the source raster ({0}) is
+ // incompatible with the matrix [{1}x{2}]
+ throw new IllegalArgumentException(Messages.getString("awt.254", //$NON-NLS-1$
+ new Object[]{numBands, mxWidth, mxHeight}));
+ }
+
+ return src.createCompatibleWritableRaster(src.getWidth(), src.getHeight());
+ }
+
+ public WritableRaster filter(Raster src, WritableRaster dst) {
+ int numBands = src.getNumBands();
+
+ if (mxWidth != numBands && mxWidth != (numBands+1)) {
+ // awt.254=Number of bands in the source raster ({0}) is
+ // incompatible with the matrix [{1}x{2}]
+ throw new IllegalArgumentException(
+ Messages.getString("awt.254", //$NON-NLS-1$
+ new Object[]{numBands, mxWidth, mxHeight}));
+ }
+
+ if (dst == null) {
+ dst = createCompatibleDestRaster(src);
+ } else if (dst.getNumBands() != mxHeight) {
+ // awt.255=Number of bands in the destination raster ({0}) is incompatible with the matrix [{1}x{2}]
+ throw new IllegalArgumentException(Messages.getString("awt.255", //$NON-NLS-1$
+ new Object[]{dst.getNumBands(), mxWidth, mxHeight}));
+ }
+
+ // XXX - todo
+ //if (ippFilter(src, dst) != 0)
+ if (verySlowFilter(src, dst) != 0) {
+ // awt.21F=Unable to transform source
+ throw new ImagingOpException (Messages.getString("awt.21F")); //$NON-NLS-1$
+ }
+
+ return dst;
+ }
+
+ /**
+ * The Class SampleModelInfo.
+ */
+ private static final class SampleModelInfo {
+
+ /** The channels. */
+ int channels;
+
+ /** The channels order. */
+ int channelsOrder[];
+
+ /** The stride. */
+ int stride;
+ }
+
+ /**
+ * Check sample model.
+ *
+ * @param sm the sm
+ *
+ * @return the sample model info
+ */
+ private final SampleModelInfo checkSampleModel(SampleModel sm) {
+ SampleModelInfo ret = new SampleModelInfo();
+
+ if (sm instanceof PixelInterleavedSampleModel) {
+ // Check PixelInterleavedSampleModel
+ if (sm.getDataType() != DataBuffer.TYPE_BYTE) {
+ return null;
+ }
+
+ ret.channels = sm.getNumBands();
+ ret.stride = ((ComponentSampleModel) sm).getScanlineStride();
+ ret.channelsOrder = ((ComponentSampleModel) sm).getBandOffsets();
+
+ } else if (sm instanceof SinglePixelPackedSampleModel) {
+ // Check SinglePixelPackedSampleModel
+ SinglePixelPackedSampleModel sppsm1 = (SinglePixelPackedSampleModel) sm;
+
+ ret.channels = sppsm1.getNumBands();
+ if (sppsm1.getDataType() != DataBuffer.TYPE_INT) {
+ return null;
+ }
+
+ // Check sample models
+ for (int i=0; i<ret.channels; i++) {
+ if (sppsm1.getSampleSize(i) != 8) {
+ return null;
+ }
+ }
+
+ ret.channelsOrder = new int[ret.channels];
+ int bitOffsets[] = sppsm1.getBitOffsets();
+ for (int i=0; i<ret.channels; i++) {
+ if (bitOffsets[i] % 8 != 0) {
+ return null;
+ }
+
+ ret.channelsOrder[i] = bitOffsets[i] / 8;
+ }
+
+ ret.channels = 4;
+ ret.stride = sppsm1.getScanlineStride() * 4;
+ } else {
+ return null;
+ }
+
+ return ret;
+ }
+
+ /**
+ * Slow filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ *
+ * @return the int
+ */
+ private final int slowFilter(Raster src, WritableRaster dst) {
+ int res = 0;
+
+ SampleModelInfo srcInfo, dstInfo;
+ int offsets[] = null;
+
+ srcInfo = checkSampleModel(src.getSampleModel());
+ dstInfo = checkSampleModel(dst.getSampleModel());
+ if (srcInfo == null || dstInfo == null) {
+ return verySlowFilter(src, dst);
+ }
+
+ // Fill offsets if there's a child raster
+ if (src.getParent() != null || dst.getParent() != null) {
+ if (src.getSampleModelTranslateX() != 0 || src.getSampleModelTranslateY() != 0 ||
+ dst.getSampleModelTranslateX() != 0 || dst.getSampleModelTranslateY() != 0) {
+ offsets = new int[4];
+ offsets[0] = -src.getSampleModelTranslateX() + src.getMinX();
+ offsets[1] = -src.getSampleModelTranslateY() + src.getMinY();
+ offsets[2] = -dst.getSampleModelTranslateX() + dst.getMinX();
+ offsets[3] = -dst.getSampleModelTranslateY() + dst.getMinY();
+ }
+ }
+
+ int rmxWidth = (srcInfo.channels+1); // width of the reordered matrix
+ float reorderedMatrix[] = new float[rmxWidth*dstInfo.channels];
+ for (int j=0; j<dstInfo.channels; j++) {
+ if (j >= dstInfo.channelsOrder.length) {
+ continue;
+ }
+
+ for (int i=0; i<srcInfo.channels; i++) {
+ if (i >= srcInfo.channelsOrder.length) {
+ break;
+ }
+
+ reorderedMatrix[dstInfo.channelsOrder[j]*rmxWidth + srcInfo.channelsOrder[i]] =
+ matrix[j][i];
+ }
+ if (mxWidth == rmxWidth) {
+ reorderedMatrix[(dstInfo.channelsOrder[j]+1)*rmxWidth - 1] = matrix[j][mxWidth-1];
+ }
+ }
+
+ Object srcData, dstData;
+ AwtImageBackdoorAccessor dbAccess = AwtImageBackdoorAccessor.getInstance();
+ try {
+ srcData = dbAccess.getData(src.getDataBuffer());
+ dstData = dbAccess.getData(dst.getDataBuffer());
+ } catch (IllegalArgumentException e) {
+ return -1; // Unknown data buffer type
+ }
+
+ simpleCombineBands(
+ srcData, src.getWidth(), src.getHeight(), srcInfo.stride, srcInfo.channels,
+ dstData, dstInfo.stride, dstInfo.channels,
+ reorderedMatrix, offsets
+ );
+
+ return res;
+ }
+
+ /**
+ * Very slow filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ *
+ * @return the int
+ */
+ private int verySlowFilter(Raster src, WritableRaster dst) {
+ int numBands = src.getNumBands();
+
+ int srcMinX = src.getMinX();
+ int srcY = src.getMinY();
+
+ int dstMinX = dst.getMinX();
+ int dstY = dst.getMinY();
+
+ int dX = src.getWidth();//< dst.getWidth() ? src.getWidth() : dst.getWidth();
+ int dY = src.getHeight();//< dst.getHeight() ? src.getHeight() : dst.getHeight();
+
+ float sample;
+ int srcPixels[] = new int[numBands*dX*dY];
+ int dstPixels[] = new int[mxHeight*dX*dY];
+
+ srcPixels = src.getPixels(srcMinX, srcY, dX, dY, srcPixels);
+
+ if (numBands == mxWidth) {
+ for (int i=0, j=0; i<srcPixels.length; i+=numBands) {
+ for (int dstB = 0; dstB < mxHeight; dstB++) {
+ sample = 0f;
+ for (int srcB = 0; srcB < numBands; srcB++) {
+ sample += matrix[dstB][srcB] * srcPixels[i+srcB];
+ }
+ dstPixels[j++] = (int) sample;
+ }
+ }
+ } else {
+ for (int i=0, j=0; i<srcPixels.length; i+=numBands) {
+ for (int dstB = 0; dstB < mxHeight; dstB++) {
+ sample = 0f;
+ for (int srcB = 0; srcB < numBands; srcB++) {
+ sample += matrix[dstB][srcB] * srcPixels[i+srcB];
+ }
+ dstPixels[j++] = (int) (sample + matrix[dstB][numBands]);
+ }
+ }
+ }
+
+ dst.setPixels(dstMinX, dstY, dX, dY, dstPixels);
+
+ return 0;
+ }
+
+ //TODO remove when method is used
+ /**
+ * Ipp filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ *
+ * @return the int
+ */
+ @SuppressWarnings("unused")
+ private int ippFilter(Raster src, WritableRaster dst) {
+ boolean invertChannels;
+ boolean inPlace = (src == dst);
+ int type;
+ int srcStride, dstStride;
+ int offsets[] = null;
+
+ int srcBands = src.getNumBands();
+ int dstBands = dst.getNumBands();
+
+ if (
+ dstBands != 3 ||
+ (srcBands != 3 &&
+ !(srcBands == 4 &&
+ matrix[0][3] == 0 &&
+ matrix[1][3] == 0 &&
+ matrix[2][3] == 0)
+ )
+ ) {
+ return slowFilter(src, dst);
+ }
+
+ SampleModel srcSM = src.getSampleModel();
+ SampleModel dstSM = dst.getSampleModel();
+
+ if (
+ srcSM instanceof SinglePixelPackedSampleModel &&
+ dstSM instanceof SinglePixelPackedSampleModel
+ ) {
+ // Check SinglePixelPackedSampleModel
+ SinglePixelPackedSampleModel sppsm1 = (SinglePixelPackedSampleModel) srcSM;
+ SinglePixelPackedSampleModel sppsm2 = (SinglePixelPackedSampleModel) dstSM;
+
+ if (
+ sppsm1.getDataType() != DataBuffer.TYPE_INT ||
+ sppsm2.getDataType() != DataBuffer.TYPE_INT
+ ) {
+ return slowFilter(src, dst);
+ }
+
+ // Check sample models
+ if (
+ !Arrays.equals(sppsm2.getBitOffsets(), offsets3c) ||
+ !Arrays.equals(sppsm2.getBitMasks(), masks3c)
+ ) {
+ return slowFilter(src, dst);
+ }
+
+ if (srcBands == 3) {
+ if (
+ !Arrays.equals(sppsm1.getBitOffsets(), offsets3c) ||
+ !Arrays.equals(sppsm1.getBitMasks(), masks3c)
+ ) {
+ return slowFilter(src, dst);
+ }
+ } else if (srcBands == 4) {
+ if (
+ !Arrays.equals(sppsm1.getBitOffsets(), offsets4ac) ||
+ !Arrays.equals(sppsm1.getBitMasks(), masks4ac)
+ ) {
+ return slowFilter(src, dst);
+ }
+ }
+
+ type = TYPE_BYTE4AC;
+ invertChannels = true;
+
+ srcStride = sppsm1.getScanlineStride() * 4;
+ dstStride = sppsm2.getScanlineStride() * 4;
+ } else if (
+ srcSM instanceof PixelInterleavedSampleModel &&
+ dstSM instanceof PixelInterleavedSampleModel
+ ) {
+ if (srcBands != 3) {
+ return slowFilter(src, dst);
+ }
+
+ int srcDataType = srcSM.getDataType();
+
+ switch (srcDataType) {
+ case DataBuffer.TYPE_BYTE:
+ type = TYPE_BYTE3C;
+ break;
+ case DataBuffer.TYPE_USHORT:
+ type = TYPE_USHORT3C;
+ break;
+ case DataBuffer.TYPE_SHORT:
+ type = TYPE_SHORT3C;
+ break;
+ default:
+ return slowFilter(src, dst);
+ }
+
+ // Check PixelInterleavedSampleModel
+ PixelInterleavedSampleModel pism1 = (PixelInterleavedSampleModel) srcSM;
+ PixelInterleavedSampleModel pism2 = (PixelInterleavedSampleModel) dstSM;
+
+ if (
+ srcDataType != pism2.getDataType() ||
+ pism1.getPixelStride() != 3 ||
+ pism2.getPixelStride() != 3 ||
+ !Arrays.equals(pism1.getBandOffsets(), pism2.getBandOffsets())
+ ) {
+ return slowFilter(src, dst);
+ }
+
+ if (Arrays.equals(pism1.getBandOffsets(), piInvOffsets)) {
+ invertChannels = true;
+ } else if (Arrays.equals(pism1.getBandOffsets(), piOffsets)) {
+ invertChannels = false;
+ } else {
+ return slowFilter(src, dst);
+ }
+
+ int dataTypeSize = DataBuffer.getDataTypeSize(srcDataType) / 8;
+
+ srcStride = pism1.getScanlineStride() * dataTypeSize;
+ dstStride = pism2.getScanlineStride() * dataTypeSize;
+ } else { // XXX - todo - IPP allows support for planar data also
+ return slowFilter(src, dst);
+ }
+
+ // Fill offsets if there's a child raster
+ if (src.getParent() != null || dst.getParent() != null) {
+ if (src.getSampleModelTranslateX() != 0 || src.getSampleModelTranslateY() != 0 ||
+ dst.getSampleModelTranslateX() != 0 || dst.getSampleModelTranslateY() != 0) {
+ offsets = new int[4];
+ offsets[0] = -src.getSampleModelTranslateX() + src.getMinX();
+ offsets[1] = -src.getSampleModelTranslateY() + src.getMinY();
+ offsets[2] = -dst.getSampleModelTranslateX() + dst.getMinX();
+ offsets[3] = -dst.getSampleModelTranslateY() + dst.getMinY();
+ }
+ }
+
+ Object srcData, dstData;
+ AwtImageBackdoorAccessor dbAccess = AwtImageBackdoorAccessor.getInstance();
+ try {
+ srcData = dbAccess.getData(src.getDataBuffer());
+ dstData = dbAccess.getData(dst.getDataBuffer());
+ } catch (IllegalArgumentException e) {
+ return -1; // Unknown data buffer type
+ }
+
+ float ippMatrix[] = new float[12];
+
+ if (invertChannels) {
+ // IPP treats big endian integers like BGR, so we have to
+ // swap columns 1 and 3 and rows 1 and 3
+ for (int i = 0; i < mxHeight; i++) {
+ ippMatrix[i*4] = matrix[2-i][2];
+ ippMatrix[i*4+1] = matrix[2-i][1];
+ ippMatrix[i*4+2] = matrix[2-i][0];
+
+ if (mxWidth == 4) {
+ ippMatrix[i*4+3] = matrix[2-i][3];
+ } else if (mxWidth == 5) {
+ ippMatrix[i*4+3] = matrix[2-i][4];
+ }
+ }
+ } else {
+ for (int i = 0; i < mxHeight; i++) {
+ ippMatrix[i*4] = matrix[i][0];
+ ippMatrix[i*4+1] = matrix[i][1];
+ ippMatrix[i*4+2] = matrix[i][2];
+
+ if (mxWidth == 4) {
+ ippMatrix[i*4+3] = matrix[i][3];
+ } else if (mxWidth == 5) {
+ ippMatrix[i*4+3] = matrix[i][4];
+ }
+ }
+ }
+
+ return ippColorTwist(
+ srcData, src.getWidth(), src.getHeight(), srcStride,
+ dstData, dst.getWidth(), dst.getHeight(), dstStride,
+ ippMatrix, type, offsets, inPlace);
+ }
+
+ /**
+ * Ipp color twist.
+ *
+ * @param srcData the src data
+ * @param srcWidth the src width
+ * @param srcHeight the src height
+ * @param srcStride the src stride
+ * @param dstData the dst data
+ * @param dstWidth the dst width
+ * @param dstHeight the dst height
+ * @param dstStride the dst stride
+ * @param ippMatrix the ipp matrix
+ * @param type the type
+ * @param offsets the offsets
+ * @param inPlace the in place
+ *
+ * @return the int
+ */
+ private final native int ippColorTwist(
+ Object srcData, int srcWidth, int srcHeight, int srcStride,
+ Object dstData, int dstWidth, int dstHeight, int dstStride,
+ float ippMatrix[], int type, int offsets[], boolean inPlace
+ );
+
+ /**
+ * Simple combine bands.
+ *
+ * @param srcData the src data
+ * @param srcWidth the src width
+ * @param srcHeight the src height
+ * @param srcStride the src stride
+ * @param srcChannels the src channels
+ * @param dstData the dst data
+ * @param dstStride the dst stride
+ * @param dstChannels the dst channels
+ * @param m the m
+ * @param offsets the offsets
+ *
+ * @return the int
+ */
+ private final native int simpleCombineBands(
+ Object srcData, int srcWidth, int srcHeight, int srcStride, int srcChannels,
+ Object dstData, int dstStride, int dstChannels,
+ float m[], int offsets[]
+ );
+}
diff --git a/awt/java/awt/image/BandedSampleModel.java b/awt/java/awt/image/BandedSampleModel.java
new file mode 100644
index 0000000..392e44c
--- /dev/null
+++ b/awt/java/awt/image/BandedSampleModel.java
@@ -0,0 +1,426 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The BandedSampleModel class provides samples of pixels in an image
+ * which is stored in a band interleaved method. Each pixel's sample
+ * takes one data element of the DataBuffer. The pixel stride for a
+ * BandedSampleModel is one.
+ */
+public final class BandedSampleModel extends ComponentSampleModel {
+
+ /**
+ * Creates the indices.
+ *
+ * @param numBands the num bands
+ *
+ * @return the int[]
+ */
+ private static int[] createIndices(int numBands) {
+ int indices[] = new int[numBands];
+ for (int i = 0; i < numBands; i++) {
+ indices[i] = i;
+ }
+ return indices;
+ }
+
+ /**
+ * Creates the offsets.
+ *
+ * @param numBands the num bands
+ *
+ * @return the int[]
+ */
+ private static int[] createOffsets(int numBands) {
+ int offsets[] = new int[numBands];
+ for (int i = 0; i < numBands; i++) {
+ offsets[i] = 0;
+ }
+ return offsets;
+ }
+
+ /**
+ * Instantiates a new BandedSampleModel object with the specified
+ * data type of samples, the width, height and bands number
+ * of image data.
+ *
+ * @param dataType the data type of samples.
+ * @param w the width of image data.
+ * @param h the height of image data.
+ * @param numBands the number of bands.
+ */
+ public BandedSampleModel(int dataType, int w, int h, int numBands) {
+ this(dataType, w, h, w, BandedSampleModel.createIndices(numBands),
+ BandedSampleModel.createOffsets(numBands));
+ }
+
+ /**
+ * Instantiates a new BandedSampleModel object with the specified
+ * data type of samples, the width, height and bands number
+ * of image data.
+ *
+ * @param dataType the data type of samples.
+ * @param w the width of image data.
+ * @param h the height of image data.
+ * @param scanlineStride the scanline stride of the of the image data.
+ * @param bankIndices the array of the bank indecies.
+ * @param bandOffsets the array of the band offsets.
+ */
+ public BandedSampleModel(int dataType, int w, int h, int scanlineStride,
+ int bankIndices[], int bandOffsets[]) {
+ super(dataType, w, h, 1, scanlineStride, bankIndices, bandOffsets);
+ }
+
+ @Override
+ public SampleModel createCompatibleSampleModel(int w, int h) {
+ return new BandedSampleModel(dataType, w, h, w, bankIndices,
+ bandOffsets);
+ }
+
+ @Override
+ public DataBuffer createDataBuffer() {
+ DataBuffer data = null;
+ int size = scanlineStride * height;
+
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ data = new DataBufferByte(size, numBanks);
+ break;
+ case DataBuffer.TYPE_SHORT:
+ case DataBuffer.TYPE_USHORT:
+ data = new DataBufferShort(size, numBanks);
+ break;
+ case DataBuffer.TYPE_INT:
+ data = new DataBufferInt(size, numBanks);
+ break;
+ case DataBuffer.TYPE_FLOAT:
+ data = new DataBufferFloat(size, numBanks);
+ break;
+ case DataBuffer.TYPE_DOUBLE:
+ data = new DataBufferDouble(size, numBanks);
+ break;
+ }
+
+ return data;
+
+ }
+
+ @Override
+ public SampleModel createSubsetSampleModel(int[] bands) {
+ if (bands.length > numBands) {
+ // awt.64=The number of the bands in the subset is greater than the number of bands in the sample model
+ throw new RasterFormatException(Messages.getString("awt.64")); //$NON-NLS-1$
+ }
+
+ int indices[] = new int[bands.length];
+ int offsets[] = new int[bands.length];
+
+ for (int i = 0; i < bands.length; i++) {
+ indices[i] = bankIndices[bands[i]];
+ offsets[i] = bandOffsets[bands[i]];
+ }
+
+ return new BandedSampleModel(dataType, width, height, scanlineStride,
+ indices, offsets);
+ }
+
+ @Override
+ public Object getDataElements(int x, int y, Object obj, DataBuffer data) {
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE: {
+ byte bdata[];
+
+ if (obj == null) {
+ bdata = new byte[numBands];
+ } else {
+ bdata = (byte[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ bdata[i] = (byte) getSample(x, y, i, data);
+ }
+
+ obj = bdata;
+ break;
+ }
+ case DataBuffer.TYPE_SHORT:
+ case DataBuffer.TYPE_USHORT: {
+ short sdata[];
+
+ if (obj == null) {
+ sdata = new short[numBands];
+ } else {
+ sdata = (short[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ sdata[i] = (short) getSample(x, y, i, data);
+ }
+
+ obj = sdata;
+ break;
+ }
+ case DataBuffer.TYPE_INT: {
+ int idata[];
+
+ if (obj == null) {
+ idata = new int[numBands];
+ } else {
+ idata = (int[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ idata[i] = getSample(x, y, i, data);
+ }
+
+ obj = idata;
+ break;
+ }
+ case DataBuffer.TYPE_FLOAT: {
+ float fdata[];
+
+ if (obj == null) {
+ fdata = new float[numBands];
+ } else {
+ fdata = (float[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ fdata[i] = getSampleFloat(x, y, i, data);
+ }
+
+ obj = fdata;
+ break;
+ }
+ case DataBuffer.TYPE_DOUBLE: {
+ double ddata[];
+
+ if (obj == null) {
+ ddata = new double[numBands];
+ } else {
+ ddata = (double[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ ddata[i] = getSampleDouble(x, y, i, data);
+ }
+
+ obj = ddata;
+ break;
+ }
+ }
+
+ return obj;
+ }
+
+ @Override
+ public int[] getPixel(int x, int y, int iArray[], DataBuffer data) {
+ int pixel[];
+ if (iArray == null) {
+ pixel = new int[numBands];
+ } else {
+ pixel = iArray;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ pixel[i] = getSample(x, y, i, data);
+ }
+
+ return pixel;
+ }
+
+ @Override
+ public int getSample(int x, int y, int b, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ return data.getElem(bankIndices[b], y * scanlineStride + x +
+ bandOffsets[b]);
+ }
+
+ @Override
+ public double getSampleDouble(int x, int y, int b, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ return data.getElemDouble(bankIndices[b], y * scanlineStride + x +
+ bandOffsets[b]);
+ }
+
+ @Override
+ public float getSampleFloat(int x, int y, int b, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ return data.getElemFloat(bankIndices[b], y * scanlineStride + x +
+ bandOffsets[b]);
+ }
+
+ @Override
+ public int[] getSamples(int x, int y, int w, int h, int b, int iArray[],
+ DataBuffer data) {
+ int samples[];
+ int idx = 0;
+
+ if (iArray == null) {
+ samples = new int[w * h];
+ } else {
+ samples = iArray;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ samples[idx++] = getSample(j, i, b, data);
+ }
+ }
+
+ return samples;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = super.hashCode();
+ int tmp = hash >>> 8;
+ hash <<= 8;
+ hash |= tmp;
+
+ return hash ^ 0x55;
+ }
+
+ @Override
+ public void setDataElements(int x, int y, Object obj, DataBuffer data) {
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ byte bdata[] = (byte[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, bdata[i] & 0xff, data);
+ }
+ break;
+
+ case DataBuffer.TYPE_SHORT:
+ case DataBuffer.TYPE_USHORT:
+ short sdata[] = (short[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, sdata[i] & 0xffff, data);
+ }
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int idata[] = (int[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, idata[i], data);
+ }
+ break;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fdata[] = (float[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, fdata[i], data);
+ }
+ break;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double ddata[] = (double[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, ddata[i], data);
+ }
+ break;
+ }
+ }
+
+ @Override
+ public void setPixel(int x, int y, int iArray[], DataBuffer data) {
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, iArray[i], data);
+ }
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h, int iArray[],
+ DataBuffer data) {
+ int idx = 0;
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numBands; n++) {
+ setSample(j, i, n, iArray[idx++], data);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void setSample(int x, int y, int b, double s, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ data.setElemDouble(bankIndices[b], y * scanlineStride + x +
+ bandOffsets[b], s);
+ }
+
+ @Override
+ public void setSample(int x, int y, int b, float s, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ data.setElemFloat(bankIndices[b], y * scanlineStride + x +
+ bandOffsets[b], s);
+ }
+
+ @Override
+ public void setSample(int x, int y, int b, int s, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ data.setElem(bankIndices[b], y * scanlineStride + x +
+ bandOffsets[b], s);
+ }
+
+ @Override
+ public void setSamples(int x, int y, int w, int h, int b, int iArray[],
+ DataBuffer data) {
+ int idx = 0;
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ setSample(j, i, b, iArray[idx++], data);
+ }
+ }
+
+ }
+
+}
+
diff --git a/awt/java/awt/image/BufferStrategy.java b/awt/java/awt/image/BufferStrategy.java
new file mode 100644
index 0000000..e0508f0
--- /dev/null
+++ b/awt/java/awt/image/BufferStrategy.java
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.BufferCapabilities;
+import java.awt.Graphics;
+
+/**
+ * The BufferStrategy abstract class provides an opportunity
+ * to organize the buffers for a Canvas or Window. The BufferStrategy
+ * implementation depends on hardware and software limitations.
+ * These limitations are detectible through the capabilities
+ * object which can be obtained by the GraphicsConfiguration of the Canvas
+ * or Window.
+ */
+public abstract class BufferStrategy {
+
+ /**
+ * Returns true if the drawing buffer was lost since the last call
+ * of getDrawGraphics.
+ *
+ * @return true if the drawing buffer was lost since the last call
+ * of getDrawGraphics, false otherwise.
+ */
+ public abstract boolean contentsLost();
+
+ /**
+ * Returns true if the drawing buffer is restored from a lost state.
+ *
+ * @return true if the drawing buffer is restored from a lost state,
+ * false otherwise.
+ */
+ public abstract boolean contentsRestored();
+
+ /**
+ * Gets the BufferCapabilities of BufferStrategy.
+ *
+ * @return the BufferCapabilities of BufferStrategy.
+ */
+ public abstract BufferCapabilities getCapabilities();
+
+ /**
+ * Gets the Graphics object to use to draw to the buffer.
+ *
+ * @return the Graphics object to use to draw to the buffer.
+ */
+ public abstract Graphics getDrawGraphics();
+
+ /**
+ * Shows the next available buffer.
+ */
+ public abstract void show();
+
+}
diff --git a/awt/java/awt/image/BufferedImage.java b/awt/java/awt/image/BufferedImage.java
new file mode 100644
index 0000000..d305d66
--- /dev/null
+++ b/awt/java/awt/image/BufferedImage.java
@@ -0,0 +1,931 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import com.android.internal.awt.AndroidGraphics2D;
+
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.GraphicsEnvironment;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.Transparency;
+import java.awt.color.ColorSpace;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
+import org.apache.harmony.awt.gl.ImageSurface;
+import org.apache.harmony.awt.gl.Surface;
+import org.apache.harmony.awt.gl.image.BufferedImageSource;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+
+/**
+ * The BufferedImage class describes an Image which contains a buffer
+ * of image data and includes a ColorModel and a Raster for this data.
+ * This class provides methods for obtaining and setting the Raster
+ * and for manipulating the ColorModel parameters.
+ */
+public class BufferedImage extends
+Image implements WritableRenderedImage, Transparency{
+
+ /**
+ * The Constant TYPE_CUSTOM indicates that Image type
+ * is unknown.
+ */
+ public static final int TYPE_CUSTOM = 0;
+
+ /**
+ * The Constant TYPE_INT_RGB indicates an image with
+ * 8 bit RGB color components, it has a DirectColorModel
+ * without alpha.
+ */
+ public static final int TYPE_INT_RGB = 1;
+
+ /**
+ * The Constant TYPE_INT_ARGB indicates an image with
+ * 8 bit RGBA color components, it has a DirectColorModel
+ * with alpha.
+ */
+ public static final int TYPE_INT_ARGB = 2;
+
+ /**
+ * The Constant TYPE_INT_ARGB_PRE indicates an image with
+ * 8 bit RGBA color components, it has a DirectColorModel
+ * with alpha, and image data is premultiplied by alpha.
+ */
+ public static final int TYPE_INT_ARGB_PRE = 3;
+
+ /**
+ * The Constant TYPE_INT_BGR indicates an image with
+ * 8 bit RGB color components, BGR color model
+ * (with the colors Blue, Green, and Red). There is no
+ * alpha. The image has a DirectColorModel.
+ */
+ public static final int TYPE_INT_BGR = 4;
+
+ /**
+ * The Constant TYPE_3BYTE_BGR indicates an image with
+ * 8 bit RGB color components, BGR color model
+ * (with the colors Blue, Green, and Red stored in 3 bytes).
+ * There is no alpha. The image has a ComponentColorModel.
+ */
+ public static final int TYPE_3BYTE_BGR = 5;
+
+ /**
+ * The Constant TYPE_4BYTE_ABGR indicates an image with
+ * 8 bit RGBA color components stored in 3 bytes and 1 byte of alpha.
+ * It has a ComponentColorModel with alpha.
+ */
+ public static final int TYPE_4BYTE_ABGR = 6;
+
+ /**
+ * The Constant TYPE_4BYTE_ABGR_PRE indicates an image with
+ * 8 bit RGBA color components stored in 3 bytes and 1 byte
+ * for alpha. The image has a ComponentColorModel with alpha.
+ * The color data is premultiplied with alpha.
+ */
+ public static final int TYPE_4BYTE_ABGR_PRE = 7;
+
+ /**
+ * The Constant TYPE_USHORT_565_RGB indicates an image with
+ * 565 RGB color components (5-bits red, 6-bits green, 5-bits blue)
+ * with no alpha. This image has a DirectColorModel.
+ */
+ public static final int TYPE_USHORT_565_RGB = 8;
+
+ /**
+ * The Constant TYPE_USHORT_555_RGB indicates an image with
+ * 555 RGB color components (5-bits red, 5-bits green, 5-bits blue)
+ * with no alpha. This image has a DirectColorModel.
+ */
+ public static final int TYPE_USHORT_555_RGB = 9;
+
+ /**
+ * The Constant TYPE_BYTE_GRAY indicates a unsigned byte
+ * image. This image has a ComponentColorModel with
+ * a CS_GRAY ColorSpace.
+ */
+ public static final int TYPE_BYTE_GRAY = 10;
+
+ /**
+ * The Constant TYPE_USHORT_GRAY indicates an unsigned short
+ * image. This image has a ComponentColorModel with a CS_GRAY
+ * ColorSpace.
+ */
+ public static final int TYPE_USHORT_GRAY = 11;
+
+ /**
+ * The Constant TYPE_BYTE_BINARY indicates an opaque byte-packed
+ * 1, 2 or 4 bit image. The image has an IndexColorModel without
+ * alpha.
+ */
+ public static final int TYPE_BYTE_BINARY = 12;
+
+ /**
+ * The Constant TYPE_BYTE_INDEXED indicates an indexed byte image.
+ */
+ public static final int TYPE_BYTE_INDEXED = 13;
+
+ /** The Constant ALPHA_MASK. */
+ private static final int ALPHA_MASK = 0xff000000;
+
+ /** The Constant RED_MASK. */
+ private static final int RED_MASK = 0x00ff0000;
+
+ /** The Constant GREEN_MASK. */
+ private static final int GREEN_MASK = 0x0000ff00;
+
+ /** The Constant BLUE_MASK. */
+ private static final int BLUE_MASK = 0x000000ff;
+
+ /** The Constant RED_BGR_MASK. */
+ private static final int RED_BGR_MASK = 0x000000ff;
+
+ /** The Constant GREEN_BGR_MASK. */
+ private static final int GREEN_BGR_MASK = 0x0000ff00;
+
+ /** The Constant BLUE_BGR_MASK. */
+ private static final int BLUE_BGR_MASK = 0x00ff0000;
+
+ /** The Constant RED_565_MASK. */
+ private static final int RED_565_MASK = 0xf800;
+
+ /** The Constant GREEN_565_MASK. */
+ private static final int GREEN_565_MASK = 0x07e0;
+
+ /** The Constant BLUE_565_MASK. */
+ private static final int BLUE_565_MASK = 0x001f;
+
+ /** The Constant RED_555_MASK. */
+ private static final int RED_555_MASK = 0x7c00;
+
+ /** The Constant GREEN_555_MASK. */
+ private static final int GREEN_555_MASK = 0x03e0;
+
+ /** The Constant BLUE_555_MASK. */
+ private static final int BLUE_555_MASK = 0x001f;
+
+ /** The cm. */
+ private ColorModel cm;
+
+ /** The raster. */
+ private final WritableRaster raster;
+
+ /** The image type. */
+ private final int imageType;
+
+ /** The properties. */
+ private Hashtable<?, ?> properties;
+
+ // Surface of the Buffered Image - used for blitting one Buffered Image
+ // on the other one or on the Component
+ /** The image surf. */
+ private final ImageSurface imageSurf;
+
+ /**
+ * Instantiates a new BufferedImage with the specified ColorModel,
+ * and WritableRaster objects. The Raster data can be
+ * be divided or multiplied by alpha. It depends on the
+ * alphaPremultiplied state in the ColorModel.
+ *
+ * @param cm the ColorModel of the new image.
+ * @param raster the WritableRaster of the new image.
+ * @param isRasterPremultiplied if true the data of the specified
+ * Raster is premultiplied by alpha.
+ * @param properties the properties of new Image.
+ */
+ public BufferedImage(ColorModel cm, WritableRaster raster,
+ boolean isRasterPremultiplied, Hashtable<?, ?> properties) {
+ if (!cm.isCompatibleRaster(raster)) {
+ // awt.4D=The raster is incompatible with this ColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.4D")); //$NON-NLS-1$
+ }
+
+ if (raster.getMinX() != 0 || raster.getMinY() != 0) {
+ // awt.228=minX or minY of this raster not equal to zero
+ throw new IllegalArgumentException(Messages.getString("awt.228")); //$NON-NLS-1$
+ }
+
+ this.cm = cm;
+ this.raster = raster;
+ this.properties = properties;
+
+ coerceData(isRasterPremultiplied);
+
+ imageType = Surface.getType(cm, raster);
+
+ imageSurf = createImageSurface(imageType);
+ }
+
+ /**
+ * Instantiates a new BufferedImage with the specified width, height
+ * predefined image type (TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED)
+ * and the specified IndexColorModel.
+ *
+ * @param width the width of new image.
+ * @param height the height of new image.
+ * @param imageType the predefined image type.
+ * @param cm the specified IndexColorModel.
+ */
+ public BufferedImage(int width, int height, int imageType,
+ IndexColorModel cm) {
+ switch (imageType) {
+ case TYPE_BYTE_BINARY:
+ if (cm.hasAlpha()) {
+ // awt.227=This image type can't have alpha
+ throw new IllegalArgumentException(Messages.getString("awt.227")); //$NON-NLS-1$
+ }
+ int pixel_bits = 0;
+ int mapSize = cm.getMapSize();
+ if (mapSize <= 2) {
+ pixel_bits = 1;
+ } else if (mapSize <= 4) {
+ pixel_bits = 2;
+ } else if (mapSize <= 16) {
+ pixel_bits = 4;
+ } else {
+ // awt.221=The imageType is TYPE_BYTE_BINARY and the color map has more than 16 entries
+ throw new IllegalArgumentException(Messages.getString("awt.221")); //$NON-NLS-1$
+ }
+
+ raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, width,
+ height, 1, pixel_bits, null);
+ break;
+
+ case TYPE_BYTE_INDEXED:
+ raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
+ width, height, 1, null);
+ break;
+
+ default:
+ // awt.222=The imageType is not TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED
+ throw new IllegalArgumentException(Messages.getString("awt.222")); //$NON-NLS-1$
+
+ }
+
+ if (!cm.isCompatibleRaster(raster)) {
+ // awt.223=The imageType is not compatible with ColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.223")); //$NON-NLS-1$
+ }
+
+ this.cm = cm;
+ this.imageType = imageType;
+ imageSurf = createImageSurface(imageType);
+
+ }
+
+ /**
+ * Instantiates a new BufferedImage with the specified width, height
+ * and predefined image type.
+ *
+ * @param width the width of new image.
+ * @param height the height of new image.
+ * @param imageType the predefined image type.
+ */
+ public BufferedImage(int width, int height, int imageType) {
+
+ switch (imageType) {
+ case TYPE_INT_RGB:
+ cm = new DirectColorModel(24, RED_MASK, GREEN_MASK, BLUE_MASK);
+ raster = cm.createCompatibleWritableRaster(width, height);
+ break;
+
+ case TYPE_INT_ARGB:
+ cm = ColorModel.getRGBdefault();
+ raster = cm.createCompatibleWritableRaster(width, height);
+ break;
+
+ case TYPE_INT_ARGB_PRE:
+ cm = new DirectColorModel(
+ ColorSpace.getInstance(ColorSpace.CS_sRGB),
+ 32,
+ RED_MASK,
+ GREEN_MASK,
+ BLUE_MASK,
+ ALPHA_MASK,
+ true,
+ DataBuffer.TYPE_INT);
+
+ raster = cm.createCompatibleWritableRaster(width, height);
+ break;
+
+ case TYPE_INT_BGR:
+ cm = new DirectColorModel(24,
+ RED_BGR_MASK,
+ GREEN_BGR_MASK,
+ BLUE_BGR_MASK);
+
+ raster = cm.createCompatibleWritableRaster(width, height);
+ break;
+
+ case TYPE_3BYTE_BGR: {
+ int bits[] = { 8, 8, 8 };
+ int bandOffsets[] = { 2, 1, 0 };
+ cm = new ComponentColorModel(
+ ColorSpace.getInstance(ColorSpace.CS_sRGB),
+ bits,
+ false,
+ false,
+ Transparency.OPAQUE,
+ DataBuffer.TYPE_BYTE);
+
+ raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
+ width, height, width * 3, 3, bandOffsets, null);
+ }
+ break;
+
+ case TYPE_4BYTE_ABGR: {
+ int bits[] = { 8, 8, 8, 8 };
+ int bandOffsets[] = { 3, 2, 1, 0 };
+ cm = new ComponentColorModel(
+ ColorSpace.getInstance(ColorSpace.CS_sRGB),
+ bits,
+ true,
+ false,
+ Transparency.TRANSLUCENT,
+ DataBuffer.TYPE_BYTE);
+
+ raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
+ width, height, width * 4, 4, bandOffsets, null);
+ }
+ break;
+
+ case TYPE_4BYTE_ABGR_PRE: {
+ int bits[] = { 8, 8, 8, 8 };
+ int bandOffsets[] = { 3, 2, 1, 0 };
+ cm = new ComponentColorModel(
+ ColorSpace.getInstance(ColorSpace.CS_sRGB),
+ bits,
+ true,
+ true,
+ Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);
+
+ raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
+ width, height, width * 4, 4, bandOffsets, null);
+ }
+ break;
+
+ case TYPE_USHORT_565_RGB:
+ cm = new DirectColorModel(
+ ColorSpace.getInstance(ColorSpace.CS_sRGB),
+ 16,
+ RED_565_MASK,
+ GREEN_565_MASK,
+ BLUE_565_MASK,
+ 0,
+ false,
+ DataBuffer.TYPE_USHORT);
+
+ raster = cm.createCompatibleWritableRaster(width, height);
+ break;
+
+ case TYPE_USHORT_555_RGB:
+ cm = new DirectColorModel(
+ ColorSpace.getInstance(ColorSpace.CS_sRGB),
+ 15,
+ RED_555_MASK,
+ GREEN_555_MASK,
+ BLUE_555_MASK,
+ 0,
+ false,
+ DataBuffer.TYPE_USHORT);
+
+ raster = cm.createCompatibleWritableRaster(width, height);
+ break;
+
+ case TYPE_BYTE_GRAY: {
+ int bits[] = { 8 };
+ cm = new ComponentColorModel(
+ ColorSpace.getInstance(ColorSpace.CS_GRAY),
+ bits,
+ false,
+ false,
+ Transparency.OPAQUE,
+ DataBuffer.TYPE_BYTE);
+
+ raster = cm.createCompatibleWritableRaster(width, height);
+ }
+ break;
+
+ case TYPE_USHORT_GRAY: {
+ int bits[] = { 16 };
+ cm = new ComponentColorModel(
+ ColorSpace.getInstance(ColorSpace.CS_GRAY),
+ bits,
+ false,
+ false,
+ Transparency.OPAQUE,
+ DataBuffer.TYPE_USHORT);
+ raster = cm.createCompatibleWritableRaster(width, height);
+ }
+ break;
+
+ case TYPE_BYTE_BINARY: {
+ int colorMap[] = { 0, 0xffffff };
+ cm = new IndexColorModel(1, 2, colorMap, 0, false, -1,
+ DataBuffer.TYPE_BYTE);
+
+ raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, width,
+ height, 1, 1, null);
+ }
+ break;
+
+ case TYPE_BYTE_INDEXED: {
+ int colorMap[] = new int[256];
+ int i = 0;
+ for (int r = 0; r < 256; r += 51) {
+ for (int g = 0; g < 256; g += 51) {
+ for (int b = 0; b < 256; b += 51) {
+ colorMap[i] = (r << 16) | (g << 8) | b;
+ i++;
+ }
+ }
+ }
+
+ int gray = 0x12;
+ for (; i < 256; i++, gray += 6) {
+ colorMap[i] = (gray << 16) | (gray << 8) | gray;
+ }
+ cm = new IndexColorModel(8, 256, colorMap, 0, false, -1,
+ DataBuffer.TYPE_BYTE);
+ raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
+ width, height, 1, null);
+
+ }
+ break;
+ default:
+ // awt.224=Unknown image type
+ throw new IllegalArgumentException(Messages.getString("awt.224")); //$NON-NLS-1$
+ }
+ this.imageType = imageType;
+ imageSurf = createImageSurface(imageType);
+ }
+
+ @Override
+ public Object getProperty(String name, ImageObserver observer) {
+ return getProperty(name);
+ }
+
+ public Object getProperty(String name) {
+ if(name == null) {
+ // awt.225=Property name is null
+ throw new NullPointerException(Messages.getString("awt.225")); //$NON-NLS-1$
+ }
+ if (properties == null) {
+ return Image.UndefinedProperty;
+ }
+ Object property = properties.get(name);
+ if (property == null) {
+ property = Image.UndefinedProperty;
+ }
+ return property;
+ }
+
+ public WritableRaster copyData(WritableRaster outRaster) {
+ if (outRaster == null) {
+ outRaster = Raster.createWritableRaster(raster.getSampleModel(),
+ new Point(raster.getSampleModelTranslateX(),
+ raster.getSampleModelTranslateY()));
+ }
+
+ int w = outRaster.getWidth();
+ int h = outRaster.getHeight();
+ int minX = outRaster.getMinX();
+ int minY = outRaster.getMinY();
+
+ Object data = null;
+
+ data = raster.getDataElements(minX, minY, w, h, data);
+ outRaster.setDataElements(minX, minY, w, h, data);
+
+ return outRaster;
+ }
+
+ public Raster getData(Rectangle rect) {
+ int minX = rect.x;
+ int minY = rect.y;
+ int w = rect.width;
+ int h = rect.height;
+
+ SampleModel sm = raster.getSampleModel();
+ SampleModel nsm = sm.createCompatibleSampleModel(w, h);
+ WritableRaster outr = Raster.createWritableRaster(nsm,
+ rect.getLocation());
+ Object data = null;
+
+ data = raster.getDataElements(minX, minY, w, h, data);
+ outr.setDataElements(minX, minY, w, h, data);
+ return outr;
+ }
+
+ public Vector<RenderedImage> getSources() {
+ return null;
+ }
+
+ public String[] getPropertyNames() {
+ if (properties == null) {
+ return null;
+ }
+ Vector<String> v = new Vector<String>();
+ for (Enumeration<?> e = properties.keys(); e.hasMoreElements();) {
+ try {
+ v.add((String) e.nextElement());
+ } catch (ClassCastException ex) {
+ }
+ }
+ int size = v.size();
+ if (size > 0) {
+ String names[] = new String[size];
+ for (int i = 0; i < size; i++) {
+ names[i] = v.elementAt(i);
+ }
+ return names;
+ }
+ return null;
+ }
+
+ /**
+ * Returns the string representation of this BufferedImage object.
+ *
+ * @return the string representation of this BufferedImage object.
+ */
+ @Override
+ public String toString() {
+ return "BufferedImage@" + Integer.toHexString(hashCode()) + //$NON-NLS-1$
+ ": type = " + imageType + " " + cm + " " + raster; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+ public WritableRaster getWritableTile(int tileX, int tileY) {
+ return raster;
+ }
+
+ /**
+ * Gets the WritableRaster of this BufferedImage.
+ *
+ * @return the WritableRaster of this BufferedImage.
+ */
+ public WritableRaster getRaster() {
+ return raster;
+ }
+
+ /**
+ * Gets a WritableRaster object which contains the alpha channel of
+ * BufferedImage object with ColorModel objects that supports
+ * a separate alpha channel such as ComponentColorModel
+ * or DirectColorModel.
+ *
+ * @return the WritableRaster object which contains the alpha
+ * channel of this BufferedImage.
+ */
+ public WritableRaster getAlphaRaster() {
+ return cm.getAlphaRaster(raster);
+ }
+
+ public void removeTileObserver(TileObserver to) {
+ }
+
+ public void addTileObserver(TileObserver to) {
+ }
+
+ public SampleModel getSampleModel() {
+ return raster.getSampleModel();
+ }
+
+ public void setData(Raster r) {
+
+ Rectangle from = r.getBounds();
+ Rectangle to = raster.getBounds();
+ Rectangle intersection = to.intersection(from);
+
+ int minX = intersection.x;
+ int minY = intersection.y;
+ int w = intersection.width;
+ int h = intersection.height;
+
+ Object data = null;
+
+ data = r.getDataElements(minX, minY, w, h, data);
+ raster.setDataElements(minX, minY, w, h, data);
+ }
+
+ public Raster getTile(int tileX, int tileY) {
+ if (tileX == 0 && tileY == 0) {
+ return raster;
+ }
+ // awt.226=Both tileX and tileY are not equal to 0
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.226")); //$NON-NLS-1$
+ }
+
+ public Raster getData() {
+ int w = raster.getWidth();
+ int h = raster.getHeight();
+ int minX = raster.getMinX();
+ int minY = raster.getMinY();
+
+ WritableRaster outr = Raster.createWritableRaster(
+ raster.getSampleModel(),
+ new Point(raster.getSampleModelTranslateX(),
+ raster.getSampleModelTranslateY()));
+
+ Object data = null;
+
+ data = raster.getDataElements(minX, minY, w, h, data);
+ outr.setDataElements(minX, minY, w, h, data);
+
+ return outr;
+ }
+
+ @Override
+ public ImageProducer getSource() {
+ return new BufferedImageSource(this, properties);
+ }
+
+ @Override
+ public int getWidth(ImageObserver observer) {
+ return raster.getWidth();
+ }
+
+ @Override
+ public int getHeight(ImageObserver observer) {
+ return raster.getHeight();
+ }
+
+ public ColorModel getColorModel() {
+ return cm;
+ }
+
+ /**
+ * Gets the rectangular area of this BufferedImage as a subimage.
+ *
+ * @param x the x coordinate.
+ * @param y the y coordinate.
+ * @param w the width of the subimage.
+ * @param h the height of the subimage.
+ *
+ * @return the BufferedImage.
+ */
+ public BufferedImage getSubimage(int x, int y, int w, int h) {
+ WritableRaster wr = raster.createWritableChild(x, y, w, h, 0, 0, null);
+ return new BufferedImage(cm, wr, cm.isAlphaPremultiplied(), properties);
+ }
+
+ public Point[] getWritableTileIndices() {
+ Point points[] = new Point[1];
+ points[0] = new Point(0, 0);
+ return points;
+ }
+
+ /**
+ * Creates the Graphics2D object which allows to draw into
+ * this BufferedImage.
+ *
+ * @return the graphics2D object.
+ */
+ public Graphics2D createGraphics() {
+ GraphicsEnvironment ge =
+ GraphicsEnvironment.getLocalGraphicsEnvironment();
+ //return ge.createGraphics(this);
+ //???AWT hack, FIXME
+ //return AndroidGraphics2D.getInstance();
+ //throw new RuntimeException("Not implemented!");
+ return null;
+ }
+
+ @Override
+ public Graphics getGraphics() {
+ return createGraphics();
+ }
+
+ /**
+ * Coerces the data to achieve the state which is specified by
+ * the isAlphaPremultiplied variable.
+ *
+ * @param isAlphaPremultiplied the is alpha premultiplied state.
+ */
+ public void coerceData(boolean isAlphaPremultiplied) {
+ if (cm.hasAlpha() &&
+ cm.isAlphaPremultiplied() != isAlphaPremultiplied) {
+ cm = cm.coerceData(raster, isAlphaPremultiplied);
+ }
+ }
+
+ /**
+ * Gets an array of colors in the TYPE_INT_ARGB color model and
+ * default sRGB colorspace of the specified area of this
+ * BufferedImage. The result array is composed by the following
+ * algirithm:
+ * <p>
+ * pixel = rgbArray[offset + (y-startY)*scansize + (x-startX)]
+ *
+ * @param startX the start X area coordinate.
+ * @param startY the start Y area coordinate.
+ * @param w the width of the area.
+ * @param h the height of the area.
+ * @param rgbArray the result array will be stored to this array.
+ * @param offset the offset of the rgbArray array.
+ * @param scansize the scanline stride for the rgbArray.
+ *
+ * @return an array of colors for the specified area.
+ */
+ public int[] getRGB(int startX, int startY, int w, int h, int[] rgbArray,
+ int offset, int scansize) {
+ if (rgbArray == null) {
+ rgbArray = new int[offset + h * scansize];
+ }
+
+ int off = offset;
+ for (int y = startY; y < startY + h; y++, off += scansize) {
+ int i = off;
+ for (int x = startX; x < startX + w; x++, i++) {
+ rgbArray[i] = cm.getRGB(raster.getDataElements(x, y, null));
+ }
+ }
+ return rgbArray;
+ }
+
+ /**
+ * Sets RGB values from the specified array to the specified
+ * BufferedImage area. The pixels are in the default RGB color model
+ * (TYPE_INT_ARGB) and default sRGB color space.
+ *
+ * @param startX the start X coordinate.
+ * @param startY the start Y coordinate.
+ * @param w the width of the BufferedImage area.
+ * @param h the height of the BufferedImage area.
+ * @param rgbArray the array of RGB values.
+ * @param offset the offset of the rgbArray array.
+ * @param scansize the scanline stride for the rgbArray.
+ */
+ public void setRGB(int startX, int startY, int w, int h, int[] rgbArray,
+ int offset, int scansize) {
+ int off = offset;
+ for (int y = startY; y < startY + h; y++, off += scansize) {
+ int i = off;
+ for (int x = startX; x < startX + w; x++, i++) {
+ raster.setDataElements(x, y,
+ cm.getDataElements(rgbArray[i], null));
+ }
+ }
+ }
+
+ /**
+ * Sets a the specified RGB value to the specified pixel of
+ * this BufferedImage. The pixel should be in the default
+ * RGB color model (TYPE_INT_ARGB) and default sRGB color space.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param rgb the RGB value to be set.
+ */
+ public synchronized void setRGB(int x, int y, int rgb) {
+ raster.setDataElements(x, y, cm.getDataElements(rgb, null));
+ }
+
+ public boolean isTileWritable(int tileX, int tileY) {
+ if (tileX == 0 && tileY == 0) {
+ return true;
+ }
+ // awt.226=Both tileX and tileY are not equal to 0
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.226")); //$NON-NLS-1$
+ }
+
+ public void releaseWritableTile(int tileX, int tileY) {
+ }
+
+ /**
+ * Gets a color in the TYPE_INT_ARGB color model and default
+ * sRGB colorspace of the specified pixel.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ *
+ * @return the color of the specified pixel in the TYPE_INT_ARGB
+ * color model and default sRGB colorspace.
+ */
+ public int getRGB(int x, int y) {
+ return cm.getRGB(raster.getDataElements(x, y, null));
+ }
+
+ /**
+ * Returnes true if alpha is premultiplied,
+ * false if alpha is not premultiplied or there is no alpha.
+ *
+ * @return true if alpha is premultiplied,
+ * false if alpha is not premultiplied or there is no alpha.
+ */
+ public boolean isAlphaPremultiplied() {
+ return cm.isAlphaPremultiplied();
+ }
+
+ public boolean hasTileWriters() {
+ return true;
+ }
+
+ @Override
+ public void flush() {
+ imageSurf.dispose();
+ }
+
+ public int getWidth() {
+ return raster.getWidth();
+ }
+
+ /**
+ * Gets the image type.
+ *
+ * @return the image type.
+ */
+ public int getType() {
+ return imageType;
+ }
+
+ public int getTileWidth() {
+ return raster.getWidth();
+ }
+
+ public int getTileHeight() {
+ return raster.getHeight();
+ }
+
+ public int getTileGridYOffset() {
+ return raster.getSampleModelTranslateY();
+ }
+
+ public int getTileGridXOffset() {
+ return raster.getSampleModelTranslateX();
+ }
+
+ public int getNumYTiles() {
+ return 1;
+ }
+
+ public int getNumXTiles() {
+ return 1;
+ }
+
+ public int getMinY() {
+ return raster.getMinY();
+ }
+
+ public int getMinX() {
+ return raster.getMinX();
+ }
+
+ public int getMinTileY() {
+ return 0;
+ }
+
+ public int getMinTileX() {
+ return 0;
+ }
+
+ public int getHeight() {
+ return raster.getHeight();
+ }
+
+ /**
+ * Creates the image surface.
+ *
+ * @param type the type
+ *
+ * @return the image surface
+ */
+ private ImageSurface createImageSurface(int type) {
+ return new ImageSurface(getColorModel(), getRaster(), type);
+ }
+
+ /**
+ * Gets the image surface.
+ *
+ * @return the image surface
+ */
+ ImageSurface getImageSurface() {
+ return imageSurf;
+ }
+
+ public int getTransparency() {
+ return cm.getTransparency();
+ }
+}
+
diff --git a/awt/java/awt/image/BufferedImageFilter.java b/awt/java/awt/image/BufferedImageFilter.java
new file mode 100644
index 0000000..44b3c2e
--- /dev/null
+++ b/awt/java/awt/image/BufferedImageFilter.java
@@ -0,0 +1,375 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+
+package java.awt.image;
+
+import org.apache.harmony.awt.gl.AwtImageBackdoorAccessor;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The BufferedImageFilter class provides filtering operations to
+ * the BufferedImage objects using operators which implement
+ * BufferedImageOp interface.
+ */
+public class BufferedImageFilter extends ImageFilter implements Cloneable {
+
+ /** The Constant accessor. */
+ private static final AwtImageBackdoorAccessor accessor = AwtImageBackdoorAccessor.getInstance();
+
+ /** The op. */
+ private BufferedImageOp op;
+
+ /** The raster. */
+ private WritableRaster raster;
+
+ /** The i data. */
+ private int iData[];
+
+ /** The b data. */
+ private byte bData[];
+
+ /** The width. */
+ private int width;
+
+ /** The height. */
+ private int height;
+
+ /** The cm. */
+ private ColorModel cm;
+
+ /** The forced rgb. */
+ private boolean forcedRGB = false;
+
+ /** The transfer type. */
+ private int transferType = DataBuffer.TYPE_UNDEFINED;
+
+ /**
+ * Instantiates a new BufferedImageFilter with the specified
+ * BufferedImageOp operator.
+ *
+ * @param op the specified BufferedImageOp operator.
+ *
+ * @throws NullPointerException if BufferedImageOp is null.
+ */
+ public BufferedImageFilter(BufferedImageOp op) {
+ if (op == null) {
+ throw new NullPointerException(Messages.getString("awt.05")); //$NON-NLS-1$
+ }
+ this.op = op;
+ }
+
+ /**
+ * Gets the BufferedImageOp operator associated with this
+ * BufferedImageFilter object.
+ *
+ * @return the BufferedImageOp associated with this
+ * BufferedImageFilter object.
+ */
+ public BufferedImageOp getBufferedImageOp() {
+ return op;
+ }
+
+ @Override
+ public void setDimensions(int width, int height) {
+ this.width = width;
+ this.height = height;
+ // Stop image consuming if no pixels expected.
+ if (width <= 0 || height <= 0) {
+ consumer.imageComplete(ImageConsumer.STATICIMAGEDONE);
+ reset();
+ }
+ }
+
+ @Override
+ public void setColorModel(ColorModel model) {
+ if (this.cm != null && this.cm != model && raster != null) {
+ forceRGB();
+ } else {
+ this.cm = model;
+ }
+ }
+
+ @Override
+ public void setPixels(
+ int x, int y, int
+ w, int h,
+ ColorModel model, byte[] pixels,
+ int off, int scansize
+ ) {
+ setPixels(x, y, w, h, model, pixels, off, scansize, true);
+ }
+
+ @Override
+ public void setPixels(
+ int x, int y,
+ int w, int h,
+ ColorModel model, int[] pixels,
+ int off, int scansize
+ ) {
+ setPixels(x, y, w, h, model, pixels, off, scansize, false);
+ }
+
+ @Override
+ public void imageComplete(int status) {
+ if (status == STATICIMAGEDONE || status == SINGLEFRAMEDONE) {
+ BufferedImage bim = new BufferedImage(cm, raster, cm.isAlphaPremultiplied, null);
+ bim = op.filter(bim, null);
+ DataBuffer dstDb = bim.getRaster().getDataBuffer();
+ ColorModel dstCm = bim.getColorModel();
+ int dstW = bim.getWidth();
+ int dstH = bim.getHeight();
+
+ consumer.setDimensions(dstW, dstH);
+
+ if (dstDb.getDataType() == DataBuffer.TYPE_INT) {
+ consumer.setColorModel(dstCm);
+ consumer.setPixels(0, 0, dstW, dstH, dstCm, accessor.getDataInt(dstDb), 0, dstW);
+ } else if (dstDb.getDataType() == DataBuffer.TYPE_BYTE) {
+ consumer.setColorModel(dstCm);
+ consumer.setPixels(0, 0, dstW, dstH, dstCm, accessor.getDataByte(dstDb), 0, dstW);
+ } else {
+ int dstData[] = bim.getRGB(0, 0, dstW, dstH, null, 0, dstW);
+ dstCm = ColorModel.getRGBdefault();
+ consumer.setColorModel(dstCm);
+ consumer.setPixels(0, 0, dstW, dstH, dstCm, dstData, 0, dstW);
+ }
+ } else if (status == IMAGEERROR || status == IMAGEABORTED) {
+ reset();
+ }
+
+ consumer.imageComplete(status);
+ }
+
+ /**
+ * Sets the pixels.
+ *
+ * @param x the x
+ * @param y the y
+ * @param w the w
+ * @param h the h
+ * @param model the model
+ * @param pixels the pixels
+ * @param off the off
+ * @param scansize the scansize
+ * @param isByteData the is byte data
+ */
+ private void setPixels(
+ int x, int y,
+ int w, int h,
+ ColorModel model, Object pixels,
+ int off, int scansize, boolean isByteData
+ ) {
+ // Check bounds
+ // Need to copy only the pixels that will fit into the destination area
+ if (x < 0) {
+ w -= x;
+ off += x;
+ x = 0;
+ }
+
+ if (y < 0) {
+ h -= y;
+ off += y * scansize;
+ y = 0;
+ }
+
+ if (x + w > width) {
+ w = width - x;
+ }
+
+ if (y + h > height) {
+ h = height - y;
+ }
+
+ if (w <= 0 || h <= 0) {
+ return;
+ }
+
+ // Check model
+ if (this.cm == null) {
+ setColorModel(model);
+ } else if (model == null) {
+ model = this.cm;
+ } else if (!model.equals(this.cm)) {
+ forceRGB();
+ }
+
+ boolean canArraycopy;
+ // Process pixels
+ switch(transferType) {
+ case DataBuffer.TYPE_UNDEFINED: {
+ if (isByteData) {
+ transferType = DataBuffer.TYPE_BYTE;
+ createRaster(transferType);
+ //bData = new byte[width*height];
+ canArraycopy = !forcedRGB;
+ break;
+ }
+ transferType = DataBuffer.TYPE_INT;
+ createRaster(transferType);
+ //iData = new int[width*height];
+ canArraycopy = !forcedRGB || model.equals(ColorModel.getRGBdefault());
+ break;
+ } // And proceed to copy the pixels
+ case DataBuffer.TYPE_INT: {
+ if (isByteData) { // There are int data already but the new data are bytes
+ forceRGB();
+ canArraycopy = false;
+ break;
+ } else if (!forcedRGB || model.equals(ColorModel.getRGBdefault())) {
+ canArraycopy = true;
+ break;
+ } // Else fallback to the RGB conversion
+ }
+ case DataBuffer.TYPE_BYTE: {
+ if (isByteData && !forcedRGB) {
+ canArraycopy = true;
+ break;
+ }
+
+ // RGB conversion
+ canArraycopy = false;
+ break;
+ } default: {
+ throw new IllegalStateException(Messages.getString("awt.06")); //$NON-NLS-1$
+ }
+ }
+
+ off += x;
+ int maxOffset = off + h * scansize;
+ int dstOffset = x + y * width;
+
+ if (canArraycopy) {
+ Object dstArray = isByteData ? (Object) bData : (Object) iData;
+ for (; off < maxOffset; off += scansize, dstOffset += width) {
+ System.arraycopy(pixels, off, dstArray, dstOffset, w);
+ }
+ } else {
+ // RGB conversion
+ for (; off < maxOffset; off += scansize, dstOffset += width) {
+ int srcPos = off;
+ int dstPos = dstOffset;
+ int maxDstPos = dstOffset + w;
+ for (; dstPos < maxDstPos; dstPos++, srcPos++) {
+ iData[dstPos] = model.getRGB(
+ isByteData ?
+ ((byte[])pixels)[srcPos] :
+ ((int[])pixels)[srcPos]
+ );
+ }
+ }
+ }
+ }
+
+ /**
+ * Force rgb.
+ */
+ private void forceRGB() {
+ if (!forcedRGB) {
+ forcedRGB = true;
+ int size = width*height;
+ int rgbData[] = new int[size];
+
+ if (bData != null) {
+ for (int i=0; i<size; i++) {
+ rgbData[i] = cm.getRGB(bData[i]);
+ }
+ } else if (iData != null) {
+ for (int i=0; i<size; i++) {
+ rgbData[i] = cm.getRGB(iData[i]);
+ }
+ }
+
+ cm = ColorModel.getRGBdefault();
+ DataBufferInt db = new DataBufferInt(rgbData, size);
+ int masks[] = new int[] {0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000};
+ raster = Raster.createPackedRaster(db, width, height, width, masks, null);
+ iData = accessor.getDataInt(db);
+ bData = null;
+ transferType = DataBuffer.TYPE_INT;
+ }
+ }
+
+ /**
+ * Reset.
+ */
+ private void reset() {
+ width = 0;
+ height = 0;
+ forcedRGB = false;
+ cm = null;
+ iData = null;
+ bData = null;
+ transferType = DataBuffer.TYPE_UNDEFINED;
+ raster = null;
+ }
+
+ /**
+ * Creates the raster.
+ *
+ * @param dataType the data type
+ */
+ private void createRaster(int dataType) {
+ boolean createdValidBuffer = false;
+ try{
+ raster = cm.createCompatibleWritableRaster(width, height);
+ int rasterType = raster.getDataBuffer().getDataType();
+ if (rasterType == dataType) {
+ switch (rasterType) {
+ case DataBuffer.TYPE_INT: {
+ iData = accessor.getDataInt(raster.getDataBuffer());
+ if (iData != null) {
+ createdValidBuffer = true;
+ }
+ break;
+ }
+ case DataBuffer.TYPE_BYTE: {
+ bData = accessor.getDataByte(raster.getDataBuffer());
+ if (bData != null) {
+ createdValidBuffer = true;
+ }
+ break;
+ }
+ default:
+ createdValidBuffer = false;
+ }
+
+ if(cm == ColorModel.getRGBdefault()){
+ forcedRGB = true;
+ }
+ } else {
+ createdValidBuffer = false;
+ }
+ } catch(Exception e) {
+ createdValidBuffer = false;
+ }
+
+ if (createdValidBuffer == false) {
+ cm = ColorModel.getRGBdefault();
+ raster = cm.createCompatibleWritableRaster(width, height);
+ iData = accessor.getDataInt(raster.getDataBuffer());
+ bData = null;
+ forcedRGB = true;
+ }
+ }
+}
diff --git a/awt/java/awt/image/BufferedImageOp.java b/awt/java/awt/image/BufferedImageOp.java
new file mode 100644
index 0000000..85b9f4e
--- /dev/null
+++ b/awt/java/awt/image/BufferedImageOp.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.RenderingHints;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * The BufferedImageOp interface provides methods for performing transformations
+ * from source data to destination data for BufferedImage objects. An object
+ * implementing this interface can be passed into a BufferedImageFilter
+ * to operate on a BufferedImage.
+ */
+public interface BufferedImageOp {
+
+ /**
+ * Creates a destination image with the specified BufferedImage and
+ * ColorModel; this destination image is empty and has the correct size
+ * and number of bands.
+ *
+ * @param src the source BufferedImage.
+ * @param destCM the destination ColorModel.
+ *
+ * @return the BufferedImage.
+ */
+ public BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel destCM);
+
+ /**
+ * Performs a filter operation on the source BufferedImage and stores
+ * the resulting BufferedImage to the destination BufferedImage. If
+ * the destination BufferedImage is null, a BufferedImage with an
+ * appropriate ColorModel is created.
+ *
+ * @param src the source BufferedImage.
+ * @param dest the destination BufferedImage, where the result is stored.
+ *
+ * @return the filtered BufferedImage.
+ */
+ public BufferedImage filter(BufferedImage src, BufferedImage dest);
+
+ /**
+ * Gets the bounds of filtered image.
+ *
+ * @param src the source BufferedImage to be filtered.
+ *
+ * @return the rectangle bounds of filtered image.
+ */
+ public Rectangle2D getBounds2D(BufferedImage src);
+
+ /**
+ * Gets the point of the destination image which corresponds
+ * to the specified point in the source image.
+ *
+ * @param srcPt the point of the source image.
+ * @param dstPt the point where the result will be stored.
+ *
+ * @return the destination point.
+ */
+ public Point2D getPoint2D(Point2D srcPt, Point2D dstPt);
+
+ /**
+ * Gets the RenderingHints of the BufferedImageOp.
+ *
+ * @return the RenderingHints of the BufferedImageOp.
+ */
+ public RenderingHints getRenderingHints();
+}
diff --git a/awt/java/awt/image/ByteLookupTable.java b/awt/java/awt/image/ByteLookupTable.java
new file mode 100644
index 0000000..043b533
--- /dev/null
+++ b/awt/java/awt/image/ByteLookupTable.java
@@ -0,0 +1,134 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ *
+ * @date: Oct 14, 2005
+ */
+
+package java.awt.image;
+
+/**
+ * The ByteLookupTable class provides functionality for lookup operations,
+ * and is defined by an input byte array for bands or components of
+ * image and an offset value.
+ * The offset value will be subtracted from the input values before
+ * indexing the input arrays. The output of a lookup operation is
+ * represented as an array of unsigned bytes.
+ */
+public class ByteLookupTable extends LookupTable {
+
+ /** The data. */
+ private byte data[][];
+
+ /**
+ * Instantiates a new ByteLookupTable with the specified offset value
+ * and the specified byte array which represents the lookup table for
+ * all bands.
+ *
+ * @param offset the offset value.
+ * @param data the data array of bytes.
+ */
+ public ByteLookupTable(int offset, byte[] data) {
+ super(offset, 1);
+ if (data.length < 1)
+ throw new IllegalArgumentException("Length of data should not be less then one");
+ this.data = new byte[1][data.length];
+ // The data array stored as a reference
+ this.data[0] = data;
+ }
+
+ /**
+ * Instantiates a new ByteLookupTable with the specified offset value
+ * and the specified byte array of arrays which represents the lookup table
+ * for each band.
+ *
+ * @param offset the offset value.
+ * @param data the data array of bytes array for each band.
+ */
+ public ByteLookupTable(int offset, byte[][] data) {
+ super(offset, data.length);
+ this.data = new byte[data.length][data[0].length];
+ for (int i = 0; i < data.length; i++) {
+ // The data array for each band stored as a reference
+ this.data[i] = data[i];
+ }
+ }
+
+ /**
+ * Gets the lookup table of this ByteLookupTable object. If
+ * this ByteLookupTable object has one byte array for all bands,
+ * the returned array length is one.
+ *
+ * @return the lookup table of this ByteLookupTable object.
+ */
+ public final byte[][] getTable() {
+ // Returns data by reference
+ return data;
+ }
+
+ @Override
+ public int[] lookupPixel(int[] src, int[] dst) {
+ if (dst == null) {
+ dst = new int[src.length];
+ }
+
+ int offset = getOffset();
+ if (getNumComponents() == 1) {
+ for (int i = 0; i < src.length; i++) {
+ dst[i] = data[0][src[i]-offset];
+ }
+ } else {
+ for (int i = 0; i < getNumComponents(); i++) {
+ dst[i] = data[i][src[i]-offset];
+ }
+ }
+
+ return dst;
+ }
+
+ /**
+ * Returns a byte array which contains samples of the specified
+ * pixel which is translated with the lookup table of this
+ * ByteLookupTable object. The resulted array is stored to
+ * the dst array.
+ *
+ * @param src the source array.
+ * @param dst the destination array where the result can be stored.
+ *
+ * @return the byte array of translated samples of a pixel.
+ */
+ public byte[] lookupPixel(byte[] src, byte[] dst) {
+ if (dst == null) {
+ dst = new byte[src.length];
+ }
+
+ int offset = getOffset();
+ if (getNumComponents() == 1) {
+ for (int i = 0; i < src.length; i++) {
+ dst[i] = data[0][src[i]-offset];
+ }
+ } else {
+ for (int i = 0; i < getNumComponents(); i++) {
+ dst[i] = data[i][src[i]-offset];
+ }
+ }
+
+ return dst;
+ }
+}
diff --git a/awt/java/awt/image/ColorConvertOp.java b/awt/java/awt/image/ColorConvertOp.java
new file mode 100644
index 0000000..6d503d7
--- /dev/null
+++ b/awt/java/awt/image/ColorConvertOp.java
@@ -0,0 +1,711 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ */
+package java.awt.image;
+
+
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RenderingHints;
+import java.awt.color.ColorSpace;
+import java.awt.color.ICC_ColorSpace;
+import java.awt.color.ICC_Profile;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.util.ArrayList;
+
+import org.apache.harmony.awt.gl.color.ColorConverter;
+import org.apache.harmony.awt.gl.color.ColorScaler;
+import org.apache.harmony.awt.gl.color.ICC_Transform;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The ColorConvertOp class converts the pixels of the data in the
+ * source image with the specified ColorSpace objects or an array
+ * of ICC_Profile objects. The result pixels are scaled to the precision
+ * of the destination image.
+ */
+public class ColorConvertOp implements BufferedImageOp, RasterOp {
+ // Unused but required by interfaces
+ /** The rendering hints. */
+ RenderingHints renderingHints;
+
+ // Sequence consisting of ColorSpace and ICC_Profile elements
+ /** The conversion sequence. */
+ Object conversionSequence[] = new ICC_Profile[0]; // To eliminate checks for null
+
+ // Not null if ColorConvertOp is constructed from the array of ICC profiles
+ /** The mid profiles. */
+ private ICC_Profile midProfiles[];
+
+ /** The cc. */
+ private final ColorConverter cc = new ColorConverter();
+
+ /** The t creator. */
+ private final ICC_TransfomCreator tCreator = new ICC_TransfomCreator();
+
+ /** The is icc. */
+ private boolean isICC = true;
+
+
+ // Cached ICC_Transform
+ /**
+ * The Class ICC_TransfomCreator.
+ */
+ private class ICC_TransfomCreator {
+
+ /** The transform. */
+ private ICC_Transform transform;
+
+ /** The max components. */
+ private int maxComponents;
+
+ /**
+ * For the full ICC case.
+ *
+ * @param src the src
+ * @param dst the dst
+ * @param convSeq the conv seq
+ *
+ * @return the transform
+ */
+ public ICC_Transform getTransform(ICC_Profile src, ICC_Profile dst, ICC_Profile convSeq[]) {
+ if (transform != null &&
+ src == transform.getSrc() &&
+ dst == transform.getDst()) {
+ return transform;
+ }
+
+ int length = convSeq.length;
+ int srcFlg = 0, dstFlg = 0;
+
+ if (length == 0 || src != convSeq[0]) {
+ if (src != null) {
+ srcFlg = 1; // need src profile
+ }
+ }
+ if (length == 0 || dst != convSeq[length-1]) {
+ if (dst != null) {
+ dstFlg = 1; // need dst profile
+ }
+ }
+
+ ICC_Profile profiles[];
+ int nProfiles = length + srcFlg + dstFlg;
+ if (nProfiles == length) {
+ profiles = convSeq;
+ } else {
+ profiles = new ICC_Profile[nProfiles];
+ int pos = 0;
+ if (srcFlg != 0) {
+ profiles[pos++] = src;
+ }
+ for (int i=0; i<length; i++) {
+ profiles[pos++] = convSeq[i];
+ }
+ if (dstFlg != 0) {
+ profiles[pos++] = dst;
+ }
+ }
+
+ return transform = new ICC_Transform(profiles);
+ }
+
+ /**
+ * Used only when there are non-ICC color spaces.
+ * Returns sequence of non-ICC color spaces and ICC transforms
+ * made from src, dst and conversionSequence.
+ *
+ * @param src the src
+ * @param dst the dst
+ *
+ * @return the sequence
+ */
+ public Object[] getSequence(Object src, Object dst) {
+ ArrayList<Object> profiles = new ArrayList<Object>(10);
+ ArrayList<Object> sequence = new ArrayList<Object>(10);
+
+ // We need this profile anyway
+ ICC_Profile xyzProfile = ICC_Profile.getInstance(ColorSpace.CS_CIEXYZ);
+
+ Object conversionFirst = null, conversionLast = null;
+ int conversionLength = conversionSequence.length;
+ if (conversionLength > 0) {
+ conversionFirst = conversionSequence[0];
+ conversionLast = conversionSequence[conversionLength-1];
+ }
+
+ boolean iccSequenceStarted = false;
+
+ if (src != conversionFirst && src != null) {
+ if (src instanceof ICC_Profile) {
+ profiles.add(src);
+ iccSequenceStarted = true;
+ } else {
+ profiles.add(xyzProfile);
+ sequence.add(src); // Add non-ICC color space to the sequence
+ }
+ } else {
+ profiles.add(xyzProfile);
+ }
+
+ for (int i=0; i<conversionLength; i++) {
+ if (conversionSequence[i] instanceof ICC_Profile) {
+ profiles.add(conversionSequence[i]);
+ iccSequenceStarted = true;
+ } else if (iccSequenceStarted) {
+ profiles.add(xyzProfile);
+
+ // Eliminate same profiles if there are any
+ // (e.g. xyzProfile may occur several times)
+ Object prev = profiles.get(0);
+ for (int k=1; k<profiles.size(); k++) {
+ if (prev == profiles.get(k)) {
+ k--;
+ profiles.remove(k);
+ }
+ prev = profiles.get(k);
+ }
+
+ // If only one profile left we skip the transform -
+ // it can be only CIEXYZ
+ if (profiles.size() > 1) {
+ sequence.add(new ICC_Transform(profiles.toArray(new ICC_Profile[0])));
+
+ // Add non-ICC color space to the sequence
+ sequence.add(conversionSequence[i]);
+ }
+
+ profiles.clear();
+ profiles.add(xyzProfile);
+ iccSequenceStarted = false; // Sequence of ICC profiles is processed
+ } else { // Add non-ICC color space to the sequence
+ sequence.add(conversionSequence[i]);
+ }
+ }
+
+ if (dst != conversionLast && dst != null) { // Add last profile if needed
+ if (dst instanceof ICC_Profile) {
+ profiles.add(dst);
+ iccSequenceStarted = true;
+ } else if (iccSequenceStarted) {
+ profiles.add(xyzProfile);
+ } else {
+ sequence.add(dst); // Add last non-ICC color space to the sequence
+ }
+ }
+
+ if (iccSequenceStarted) { // Make last transform if needed
+ sequence.add(new ICC_Transform(profiles.toArray(new ICC_Profile[0])));
+ if (dst != null && !(dst instanceof ICC_Profile)) {
+ sequence.add(dst); // Add last non-ICC color space to the
+ // sequence
+ }
+ }
+
+ // Calculate max number of components
+ // This number will be used for memory allocation
+ maxComponents = 0;
+ Object o;
+ for (int i=0, size = sequence.size(); i<size; i++) {
+ o = sequence.get(i);
+ if (o instanceof ICC_Transform) {
+ ICC_Transform t = (ICC_Transform) o;
+ maxComponents =
+ (maxComponents > t.getNumInputChannels() + 1) ?
+ maxComponents :
+ t.getNumInputChannels() + 1;
+ maxComponents =
+ (maxComponents > t.getNumOutputChannels() + 1) ?
+ maxComponents :
+ t.getNumOutputChannels() + 1;
+ } else {
+ ColorSpace cs = (ColorSpace) o;
+ maxComponents =
+ (maxComponents > cs.getNumComponents() + 1) ?
+ maxComponents :
+ cs.getNumComponents() + 1;
+ }
+ }
+
+ return sequence.toArray();
+ }
+ }
+
+ /**
+ * Instantiates a new ColorConvertOp object using two specified
+ * ColorSpace objects.
+ *
+ * @param srcCS the source ColorSpace.
+ * @param dstCS the destination ColorSpace.
+ * @param hints the RenderingHints object used for
+ * the color conversion, or null.
+ */
+ public ColorConvertOp(ColorSpace srcCS, ColorSpace dstCS, RenderingHints hints) {
+ if (srcCS == null || dstCS == null) {
+ throw new NullPointerException(Messages.getString("awt.25B")); //$NON-NLS-1$
+ }
+
+ renderingHints = hints;
+
+ boolean srcICC = srcCS instanceof ICC_ColorSpace;
+ boolean dstICC = dstCS instanceof ICC_ColorSpace;
+
+ if (srcICC && dstICC) {
+ conversionSequence = new ICC_Profile[2];
+ } else {
+ conversionSequence = new Object[2];
+ isICC = false;
+ }
+
+ if (srcICC) {
+ conversionSequence[0] = ((ICC_ColorSpace) srcCS).getProfile();
+ } else {
+ conversionSequence[0] = srcCS;
+ }
+
+ if (dstICC) {
+ conversionSequence[1] = ((ICC_ColorSpace) dstCS).getProfile();
+ } else {
+ conversionSequence[1] = dstCS;
+ }
+ }
+
+ /**
+ * Instantiates a new ColorConvertOp object from the specified
+ * ICC_Profile objects.
+ *
+ * @param profiles the array of ICC_Profile objects.
+ * @param hints the RenderingHints object used for
+ * the color conversion, or null.
+ */
+ public ColorConvertOp(ICC_Profile profiles[], RenderingHints hints) {
+ if (profiles == null) {
+ throw new NullPointerException(Messages.getString("awt.25C")); //$NON-NLS-1$
+ }
+
+ renderingHints = hints;
+
+ // This array is not used in the program logic, so don't need to copy it
+ // Store it only to return back
+ midProfiles = profiles;
+
+ conversionSequence = new ICC_Profile[midProfiles.length];
+
+ // Add profiles to the conversion sequence
+ for (int i=0, length=midProfiles.length; i<length; i++) {
+ conversionSequence[i] = midProfiles[i];
+ }
+ }
+
+ /**
+ * Instantiates a new ColorConvertOp object using the specified
+ * ColorSpace object.
+ *
+ * @param cs the destination ColorSpace or an intermediate ColorSpace.
+ * @param hints the RenderingHints object used for
+ * the color conversion, or null.
+ */
+ public ColorConvertOp(ColorSpace cs, RenderingHints hints) {
+ if (cs == null) {
+ throw new NullPointerException(Messages.getString("awt.25B")); //$NON-NLS-1$
+ }
+
+ renderingHints = hints;
+
+ if (cs instanceof ICC_ColorSpace) {
+ conversionSequence = new ICC_Profile[1];
+ conversionSequence[0] = ((ICC_ColorSpace) cs).getProfile();
+ } else {
+ conversionSequence = new Object[1];
+ conversionSequence[0] = cs;
+ isICC = false;
+ }
+ }
+
+ /**
+ * Instantiates a new ColorConvertOp object which converts from
+ * a source color space to a destination color space.
+ *
+ * @param hints the RenderingHints object used for
+ * the color conversion, or null.
+ */
+ public ColorConvertOp(RenderingHints hints) {
+ renderingHints = hints;
+ }
+
+ public final WritableRaster filter(Raster src, WritableRaster dst) {
+ if (conversionSequence.length < 2) {
+ throw new IllegalArgumentException(Messages.getString("awt.25D")); //$NON-NLS-1$
+ }
+
+ ICC_Profile srcPf = null, dstPf = null; // unused if isICC is false
+ int nSrcColorComps, nDstColorComps;
+ Object first = conversionSequence[0];
+ Object last = conversionSequence[conversionSequence.length - 1];
+
+ // Get the number of input/output color components
+ if (isICC) {
+ srcPf = (ICC_Profile) first;
+ dstPf = (ICC_Profile) last;
+ nSrcColorComps = srcPf.getNumComponents();
+ nDstColorComps = dstPf.getNumComponents();
+ } else {
+ if (first instanceof ICC_Profile) {
+ srcPf = (ICC_Profile) first;
+ nSrcColorComps = srcPf.getNumComponents();
+ } else {
+ nSrcColorComps = ((ColorSpace) first).getNumComponents();
+ }
+
+ if (last instanceof ICC_Profile) {
+ dstPf = (ICC_Profile) last;
+ nDstColorComps = dstPf.getNumComponents();
+ } else {
+ nDstColorComps = ((ColorSpace) last).getNumComponents();
+ }
+ }
+
+ // Check that source and destination rasters are compatible with
+ // transforms and with each other
+ if (src.getNumBands() != nSrcColorComps) {
+ // awt.25E=Incorrect number of source raster bands. Should be equal
+ // to the number of color components of source colorspace.
+ throw new IllegalArgumentException(Messages.getString("awt.25E")); //$NON-NLS-1$
+ }
+
+ if (dst != null) { // Check destination raster
+ if (dst.getNumBands() !=
+ nDstColorComps) {
+ // awt.25F=Incorrect number of destination raster bands. Should
+ // be equal to the number of color components of destination
+ // colorspace.
+ throw new IllegalArgumentException(Messages.getString("awt.25F")); //$NON-NLS-1$
+ }
+
+ if (src.getWidth() != dst.getWidth() ||
+ src.getHeight() != dst.getHeight()) {
+ throw new IllegalArgumentException(Messages.getString("awt.260")); //$NON-NLS-1$
+ }
+
+ } else {
+ dst = createCompatibleDestRaster(src);
+ }
+
+ if (isICC) {
+ // Create transform
+ ICC_Transform t = tCreator.getTransform(srcPf, dstPf,
+ (ICC_Profile[])conversionSequence);
+ cc.translateColor(t, src, dst);
+ } else {
+ Object[] sequence = tCreator.getSequence(null, null);
+
+ // Get data from the source raster
+ ColorScaler scaler = new ColorScaler();
+ scaler.loadScalingData(src, null);
+ float tmpData[][] = scaler.scaleNormalize(src);
+
+ // Get source and destination color spaces
+ ColorSpace srcCS = (srcPf == null) ?
+ (ColorSpace) first:
+ new ICC_ColorSpace(srcPf);
+ ColorSpace dstCS = (dstPf == null) ?
+ (ColorSpace) last:
+ new ICC_ColorSpace(dstPf);
+
+ applySequence(sequence, tmpData, srcCS, dstCS);
+
+ scaler.loadScalingData(dst, null);
+ scaler.unscaleNormalized(dst, tmpData);
+ }
+
+ return dst;
+ }
+
+ public BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel destCM) {
+ // If destination color model is passed only one line needed
+ if (destCM != null) {
+ return new BufferedImage(destCM,
+ destCM.createCompatibleWritableRaster(src.getWidth(), src.getHeight()),
+ destCM.isAlphaPremultiplied(),
+ null);
+ }
+
+ int nSpaces = conversionSequence.length;
+
+ if (nSpaces < 1) {
+ throw new IllegalArgumentException(Messages.getString("awt.261")); //$NON-NLS-1$
+ }
+
+ // Get destination color space
+ Object destination = conversionSequence[nSpaces-1];
+ ColorSpace dstCS =
+ (destination instanceof ColorSpace) ?
+ (ColorSpace) destination :
+ new ICC_ColorSpace((ICC_Profile) destination);
+
+ ColorModel srcCM = src.getColorModel();
+ ColorModel dstCM = new ComponentColorModel(dstCS,
+ srcCM.hasAlpha(),
+ srcCM.isAlphaPremultiplied(),
+ srcCM.getTransparency(),
+ srcCM.getTransferType());
+
+ return new BufferedImage(dstCM,
+ destCM.createCompatibleWritableRaster(src.getWidth(), src.getHeight()),
+ destCM.isAlphaPremultiplied(),
+ null);
+ }
+
+ public final BufferedImage filter(BufferedImage src, BufferedImage dst) {
+ if (dst == null && conversionSequence.length < 1) {
+ throw new IllegalArgumentException(Messages.getString("awt.262")); //$NON-NLS-1$
+ }
+
+ ColorModel srcCM = src.getColorModel();
+ // First handle index color model
+ if (srcCM instanceof IndexColorModel) {
+ src = ((IndexColorModel) srcCM).convertToIntDiscrete(src.getRaster(), false);
+ }
+ ColorSpace srcCS = srcCM.getColorSpace();
+
+ BufferedImage res;
+ boolean isDstIndex = false;
+ if (dst != null) {
+
+ if (src.getWidth() != dst.getWidth() ||
+ src.getHeight() != dst.getHeight()) {
+ throw new IllegalArgumentException(Messages.getString("awt.263")); //$NON-NLS-1$
+ }
+
+ if (dst.getColorModel() instanceof IndexColorModel) {
+ isDstIndex = true;
+ res = createCompatibleDestImage(src, null);
+ } else {
+ res = dst;
+ }
+ } else {
+ res = createCompatibleDestImage(src, null);
+ }
+ ColorModel dstCM = res.getColorModel();
+ ColorSpace dstCS = dstCM.getColorSpace();
+
+ ICC_Profile srcPf = null, dstPf = null;
+ if (srcCS instanceof ICC_ColorSpace) {
+ srcPf = ((ICC_ColorSpace)srcCS).getProfile();
+ }
+ if (dstCS instanceof ICC_ColorSpace) {
+ dstPf = ((ICC_ColorSpace)dstCS).getProfile();
+ }
+
+ boolean isFullICC = isICC && srcPf != null && dstPf != null;
+
+ if (isFullICC) {
+ ICC_Transform t =
+ tCreator.getTransform(srcPf, dstPf, (ICC_Profile[]) conversionSequence);
+ cc.translateColor(t, src, res);
+ } else { // Perform non-ICC transform
+ Object sequence[] = tCreator.getSequence(
+ srcPf == null ? (Object) srcCS : srcPf,
+ dstPf == null ? (Object) dstCS : dstPf);
+
+ int srcW = src.getWidth();
+ int srcH = src.getHeight();
+ int numPixels = srcW*srcH;
+
+ // Load all pixel data into array tmpData
+ float tmpData[][] =
+ new float[numPixels][tCreator.maxComponents];
+ for (int row=0, dataPos=0; row<srcW; row++) {
+ for (int col=0; col<srcH; col++) {
+ tmpData[dataPos] =
+ srcCM.getNormalizedComponents(
+ src.getRaster().getDataElements(row, col, null),
+ tmpData[dataPos], 0);
+ dataPos++;
+ }
+ }
+
+ // Copy alpha channel if needed
+ float alpha[] = null;
+ int alphaIdx = srcCM.numComponents - 1;
+ if (srcCM.hasAlpha() && dstCM.hasAlpha()) {
+ alpha = new float[numPixels];
+ for (int i=0; i<numPixels; i++) {
+ alpha[i] = tmpData[i][alphaIdx];
+ }
+ }
+
+ // Translate colors
+ applySequence(sequence, tmpData, srcCS, dstCS);
+
+ // Copy alpha if needed
+ if (dstCM.hasAlpha()) {
+ alphaIdx = dstCM.numComponents - 1;
+ if (alpha != null) {
+ for (int i=0; i<numPixels; i++) {
+ tmpData[i][alphaIdx] = alpha[i];
+ }
+ } else {
+ for (int i=0; i<numPixels; i++) {
+ tmpData[i][alphaIdx] = 1f;
+ }
+ }
+ }
+
+ // Store data back to the image
+ for (int row=0, dataPos=0; row<srcW; row++) {
+ for (int col=0; col<srcH; col++) {
+ res.getRaster().setDataElements(row, col,
+ dstCM.getDataElements(tmpData[dataPos++], 0 , null));
+ }
+ }
+ }
+
+ if (isDstIndex) { // Convert image into indexed color
+ Graphics2D g2d = dst.createGraphics();
+ g2d.drawImage(res, 0, 0, null);
+ g2d.dispose();
+ return dst;
+ }
+
+ return res;
+ }
+
+ /**
+ * Apply sequence.
+ *
+ * @param sequence the sequence
+ * @param tmpData the tmp data
+ * @param srcCS the src cs
+ * @param dstCS the dst cs
+ */
+ private void applySequence(
+ Object sequence[],
+ float tmpData[][],
+ ColorSpace srcCS,
+ ColorSpace dstCS
+ ) {
+ ColorSpace xyzCS = ColorSpace.getInstance(ColorSpace.CS_CIEXYZ);
+
+ int numPixels = tmpData.length;
+
+ // First transform...
+ if (sequence[0] instanceof ICC_Transform) { // ICC
+ ICC_Transform t = (ICC_Transform)sequence[0];
+ cc.translateColor(t, tmpData, srcCS, xyzCS, numPixels);
+ } else { // non ICC
+ for (int k=0; k<numPixels; k++) {
+ tmpData[k] = srcCS.toCIEXYZ(tmpData[k]);
+ }
+ cc.loadScalingData(xyzCS); // prepare for scaling XYZ
+ }
+
+ for (Object element : sequence) {
+ if (element instanceof ICC_Transform) {
+ ICC_Transform t = (ICC_Transform)element;
+ cc.translateColor(t, tmpData, null, null, numPixels);
+ } else {
+ ColorSpace cs = (ColorSpace) element;
+ for (int k=0; k<numPixels; k++) {
+ tmpData[k] = cs.fromCIEXYZ(tmpData[k]);
+ tmpData[k] = cs.toCIEXYZ(tmpData[k]);
+ }
+ }
+ }
+
+ // Last transform...
+ if (sequence[sequence.length-1] instanceof ICC_Transform) { // ICC
+ ICC_Transform t = (ICC_Transform)sequence[sequence.length-1];
+ cc.translateColor(t, tmpData, xyzCS, dstCS, numPixels);
+ } else { // non ICC
+ for (int k=0; k<numPixels; k++) {
+ tmpData[k] = dstCS.fromCIEXYZ(tmpData[k]);
+ }
+ }
+ }
+
+ public final Point2D getPoint2D(Point2D srcPt, Point2D dstPt) {
+ if (dstPt != null) {
+ dstPt.setLocation(srcPt);
+ return dstPt;
+ }
+ return new Point2D.Float((float) srcPt.getX(), (float) srcPt.getY());
+ }
+
+ public WritableRaster createCompatibleDestRaster(Raster src) {
+ int nComps = 0;
+ int nSpaces = conversionSequence.length;
+
+ if (nSpaces < 2) {
+ throw new IllegalArgumentException(Messages.getString("awt.261")); //$NON-NLS-1$
+ }
+
+ Object lastCS = conversionSequence[nSpaces-1];
+ if (lastCS instanceof ColorSpace) {
+ nComps = ((ColorSpace) lastCS).getNumComponents();
+ } else {
+ nComps = ((ICC_Profile) lastCS).getNumComponents();
+ }
+
+ // Calculate correct data type
+ int dstDataType = src.getDataBuffer().getDataType();
+ if (dstDataType != DataBuffer.TYPE_BYTE &&
+ dstDataType != DataBuffer.TYPE_SHORT) {
+ dstDataType = DataBuffer.TYPE_SHORT;
+ }
+
+ return Raster.createInterleavedRaster(
+ dstDataType,
+ src.getWidth(),
+ src.getHeight(),
+ nComps,
+ new Point(src.getMinX(), src.getMinY())
+ );
+ }
+
+ public final Rectangle2D getBounds2D(Raster src) {
+ return src.getBounds();
+ }
+
+ public final Rectangle2D getBounds2D(BufferedImage src) {
+ return src.getRaster().getBounds();
+ }
+
+ /**
+ * Gets an array of ICC_Profiles objects which constructs
+ * this ColorConvertOp object or returns null if this ColorConvertOp
+ * is not constructed from array of ICC_Profiles.
+ *
+ * @return an array of ICC_Profiles objects which constructs
+ * this ColorConvertOp object or returns null if this ColorConvertOp
+ * is not constructed from array of ICC_Profiles.
+ */
+ public final ICC_Profile[] getICC_Profiles() {
+ if (midProfiles != null) {
+ return midProfiles;
+ }
+ return null;
+ }
+
+ public final RenderingHints getRenderingHints() {
+ return renderingHints;
+ }
+}
diff --git a/awt/java/awt/image/ColorModel.java b/awt/java/awt/image/ColorModel.java
new file mode 100644
index 0000000..945c087
--- /dev/null
+++ b/awt/java/awt/image/ColorModel.java
@@ -0,0 +1,911 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Transparency;
+import java.awt.color.ColorSpace;
+import java.util.Arrays;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class ColorModel.
+ */
+public abstract class ColorModel implements Transparency {
+
+ /** The pixel_bits. */
+ protected int pixel_bits; // Pixel length in bits
+
+ /** The transfer type. */
+ protected int transferType;
+
+ /** The cs. */
+ ColorSpace cs;
+
+ /** The has alpha. */
+ boolean hasAlpha;
+
+ /** The is alpha premultiplied. */
+ boolean isAlphaPremultiplied;
+
+ /** The transparency. */
+ int transparency;
+
+ /** The num color components. */
+ int numColorComponents;
+
+ /** The num components. */
+ int numComponents;
+
+ /** The bits. */
+ int[] bits; // Array of components masks
+
+ /** The max values. */
+ int[] maxValues = null; // Max values that may be represent by color
+ // components
+
+ /** The max bit length. */
+ int maxBitLength; // Max length color components in bits
+
+ /** The RG bdefault. */
+ private static ColorModel RGBdefault;
+
+ /**
+ * Instantiates a new color model with the specified values.
+ *
+ * @param pixel_bits the pixel length in bits
+ * @param bits the array of component masks
+ * @param cspace the colorspace
+ * @param hasAlpha whether the color model has alpha
+ * @param isAlphaPremultiplied whether the alpha is premultiplied
+ * @param transparency the transparency strategy, @see java.awt.Transparency
+ * @param transferType the transfer type (primitive java type
+ * to use for the components)
+ */
+ protected ColorModel(int pixel_bits, int[] bits, ColorSpace cspace,
+ boolean hasAlpha, boolean isAlphaPremultiplied, int transparency,
+ int transferType) {
+
+ if (pixel_bits < 1) {
+ // awt.26B=The number of bits in the pixel values is less than 1
+ throw new IllegalArgumentException(Messages.getString("awt.26B")); //$NON-NLS-1$
+ }
+
+ if (bits == null) {
+ // awt.26C=bits is null
+ throw new NullPointerException(Messages.getString("awt.26C")); //$NON-NLS-1$
+ }
+
+ int sum = 0;
+ for (int element : bits) {
+ if (element < 0) {
+ // awt.26D=The elements in bits is less than 0
+ throw new IllegalArgumentException(Messages.getString("awt.26D")); //$NON-NLS-1$
+ }
+ sum += element;
+ }
+
+ if (sum < 1) {
+ // awt.26E=The sum of the number of bits in bits is less than 1
+ throw new NullPointerException(Messages.getString("awt.26E")); //$NON-NLS-1$
+ }
+
+ if (cspace == null) {
+ // awt.26F=The cspace is null
+ throw new IllegalArgumentException(Messages.getString("awt.26F")); //$NON-NLS-1$
+ }
+
+ if (transparency < Transparency.OPAQUE ||
+ transparency > Transparency.TRANSLUCENT) {
+ // awt.270=The transparency is not a valid value
+ throw new IllegalArgumentException(Messages.getString("awt.270")); //$NON-NLS-1$
+ }
+
+ this.pixel_bits = pixel_bits;
+ this.bits = bits.clone();
+
+ maxValues = new int[bits.length];
+ maxBitLength = 0;
+ for (int i = 0; i < maxValues.length; i++) {
+ maxValues[i] = (1 << bits[i]) - 1;
+ if (bits[i] > maxBitLength) {
+ maxBitLength = bits[i];
+ }
+ }
+
+ cs = cspace;
+ this.hasAlpha = hasAlpha;
+ this.isAlphaPremultiplied = isAlphaPremultiplied;
+ numColorComponents = cs.getNumComponents();
+
+ if (hasAlpha) {
+ numComponents = numColorComponents + 1;
+ } else {
+ numComponents = numColorComponents;
+ }
+
+ this.transparency = transparency;
+ this.transferType = transferType;
+
+ }
+
+ /**
+ * Instantiates a new color model with the specified pixel bit depth.
+ * The transferType is chosen based on the pixel bits, and the other
+ * data fields are given default values.
+ *
+ * @param bits the array of component masks
+ */
+ public ColorModel(int bits) {
+
+ if (bits < 1) {
+ // awt.271=The number of bits in bits is less than 1
+ throw new IllegalArgumentException(Messages.getString("awt.271")); //$NON-NLS-1$
+ }
+
+ pixel_bits = bits;
+ transferType = getTransferType(bits);
+ cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
+ hasAlpha = true;
+ isAlphaPremultiplied = false;
+ transparency = Transparency.TRANSLUCENT;
+
+ numColorComponents = 3;
+ numComponents = 4;
+
+ this.bits = null;
+ }
+
+ /**
+ * Gets the data elements from the specified component array, transforming
+ * them according to rules of the color model.
+ *
+ * @param components the components
+ * @param offset the offset in the normComponents array
+ * @param obj the array that the result is written to: an array of values
+ * whose length must be the number of components used by the color model and
+ * whose type depends on the transfer type (based on the pixel bit depth),
+ * or null to have the appropriate array created
+ *
+ * @return the array of data elements
+ */
+ public Object getDataElements(int[] components, int offset, Object obj) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the data elements from the specified array of normalized components.
+ *
+ * @param normComponents the array normalized components
+ * @param normOffset the offset in the normComponents array
+ * @param obj the array that the result is written to: an array of values
+ * whose length must be the number of components used by the color model and
+ * whose type depends on the transfer type (based on the pixel bit depth),
+ * or null to have the appropriate array created
+ *
+ * @return the array of data elements
+ */
+ public Object getDataElements(float[] normComponents, int normOffset,
+ Object obj) {
+ int unnormComponents[] = getUnnormalizedComponents(normComponents,
+ normOffset, null, 0);
+ return getDataElements(unnormComponents, 0, obj);
+ }
+
+ /**
+ * Gets the data elements corresponding to the pixel determined by the
+ * RGB data.
+ *
+ * @param rgb the rgb int that defines the pixel
+ * @param pixel the array that the result is written to: an array of values
+ * whose length must be the number of components used by the color model and
+ * whose type depends on the transfer type (based on the pixel bit depth),
+ * or null to have the appropriate array created
+ *
+ * @return the array of data elements
+ */
+ public Object getDataElements(int rgb, Object pixel) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the child raster corresponding to the alpha channel of the
+ * specified writable raster, or null if alpha is not supported.
+ *
+ * @param raster the raster
+ *
+ * @return the alpha raster
+ */
+ public WritableRaster getAlphaRaster(WritableRaster raster) {
+ return null;
+ }
+
+ /**
+ * Creates a new color model by coercing the data in the writable raster
+ * in accordance with the alpha strategy of this color model.
+ *
+ * @param raster the raster
+ * @param isAlphaPremultiplied whether the alpha is premultiplied in this
+ * color model
+ *
+ * @return the new color model
+ */
+ public ColorModel coerceData(WritableRaster raster,
+ boolean isAlphaPremultiplied) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ @Override
+ public String toString() {
+ // The output format based on 1.5 release behaviour.
+ // It could be reveled such way:
+ // ColorModel cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB,
+ // false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
+ // System.out.println(cm.toString());
+ return "ColorModel: Color Space = " + cs.toString() + "; has alpha = " //$NON-NLS-1$ //$NON-NLS-2$
+ + hasAlpha + "; is alpha premultipied = " //$NON-NLS-1$
+ + isAlphaPremultiplied + "; transparency = " + transparency //$NON-NLS-1$
+ + "; number color components = " + numColorComponents //$NON-NLS-1$
+ + "; pixel bits = " + pixel_bits + "; transfer type = " //$NON-NLS-1$ //$NON-NLS-2$
+ + transferType;
+ }
+
+ /**
+ * Gets the components of the pixel determined by the data array.
+ *
+ * @param pixel the data array that defines the pixel (whose
+ * primitive type corresponds to the pixel length in bits,
+ * @see ColorModel#getTransferType()
+ * @param components the the array where the resulting components
+ * are written (or null to prompt the method to create the return array)
+ * @param offset the offset that tells where the results should be written
+ * in the return array
+ *
+ * @return the array of components
+ */
+ public int[] getComponents(Object pixel, int[] components, int offset) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the normalized components of the pixel determined by the data array.
+ *
+ * @param pixel the data array that defines the pixel (whose
+ * primitive type corresponds to the pixel length in bits,
+ * @see ColorModel#getTransferType()
+ * @param normComponents the array where the resulting normalised components
+ * are written (or null to prompt the method to create the return array)
+ * @param normOffset the offset that tells where the results should be written
+ * in the return array
+ *
+ * @return the array of normalized components
+ */
+ public float[] getNormalizedComponents(Object pixel,
+ float[] normComponents, int normOffset) {
+
+ if (pixel == null) {
+ // awt.294=pixel is null
+ throw new NullPointerException(Messages.getString("awt.294")); //$NON-NLS-1$
+ }
+
+ int unnormComponents[] = getComponents(pixel, null, 0);
+ return getNormalizedComponents(unnormComponents, 0, normComponents,
+ normOffset);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (!(obj instanceof ColorModel)) {
+ return false;
+ }
+ ColorModel cm = (ColorModel) obj;
+
+ return (pixel_bits == cm.getPixelSize() &&
+ transferType == cm.getTransferType() &&
+ cs.getType() == cm.getColorSpace().getType() &&
+ hasAlpha == cm.hasAlpha() &&
+ isAlphaPremultiplied == cm.isAlphaPremultiplied() &&
+ transparency == cm.getTransparency() &&
+ numColorComponents == cm.getNumColorComponents() &&
+ numComponents == cm.getNumComponents() &&
+ Arrays.equals(bits, cm.getComponentSize()));
+ }
+
+ /**
+ * Gets the red component of the pixel determined by the data array.
+ *
+ * @param inData the data array that defines the pixel (whose
+ * primitive type corresponds to the pixel length in bits,
+ * @see ColorModel#getTransferType()
+ *
+ * @return the red
+ */
+ public int getRed(Object inData) {
+ return getRed(constructPixel(inData));
+ }
+
+ /**
+ * Gets the RGB int corresponding to the pixel defined by the data array.
+ *
+ * @param inData the data array that defines the pixel (whose
+ * primitive type corresponds to the pixel length in bits,
+ * @see ColorModel#getTransferType()
+ *
+ * @return the int that gives the pixel's colors in RGB format
+ */
+ public int getRGB(Object inData) {
+ return (getAlpha(inData) << 24 | getRed(inData) << 16 |
+ getGreen(inData) << 8 | getBlue(inData));
+ }
+
+ /**
+ * Gets the green component of the pixel defined by the data array.
+ *
+ * @param inData the data array that defines the pixel (whose
+ * primitive type corresponds to the pixel length in bits,
+ * @see ColorModel#getTransferType()
+ *
+ * @return the green
+ */
+ public int getGreen(Object inData) {
+ return getGreen(constructPixel(inData));
+ }
+
+ /**
+ * Gets the blue component of the pixel defined by the data array.
+ *
+ * @param inData the data array that defines the pixel (whose
+ * primitive type corresponds to the pixel length in bits,
+ * @see ColorModel#getTransferType()
+ *
+ * @return the blue
+ */
+ public int getBlue(Object inData) {
+ return getBlue(constructPixel(inData));
+ }
+
+ /**
+ * Gets the alpha component of the pixel defined by the data array.
+ *
+ * @param inData the data array that defines the pixel (whose
+ * primitive type corresponds to the pixel length in bits,
+ * @see ColorModel#getTransferType()
+ *
+ * @return the alpha
+ */
+ public int getAlpha(Object inData) {
+ return getAlpha(constructPixel(inData));
+ }
+
+ /**
+ * Creates a compatible writable raster.
+ *
+ * @param w the width of the desired writable raster
+ * @param h the height of the desired writable raster
+ *
+ * @return the writable raster
+ */
+ public WritableRaster createCompatibleWritableRaster(int w, int h) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ /**
+ * Checks if the sample model is compatible with this color model.
+ *
+ * @param sm the sample model
+ *
+ * @return true, if the sample model is compatible with this color model
+ */
+ public boolean isCompatibleSampleModel(SampleModel sm) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ /**
+ * Creates the compatible sample model.
+ *
+ * @param w the width of the desired sample model
+ * @param h the height of the desired sample model
+ *
+ * @return the sample model
+ */
+ public SampleModel createCompatibleSampleModel(int w, int h) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ /**
+ * Checks if the specified raster is compatible with this color model.
+ *
+ * @param raster the raster to inspect
+ *
+ * @return true, if the raster is compatible with this color model
+ */
+ public boolean isCompatibleRaster(Raster raster) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the color space of this color model.
+ *
+ * @return the color space
+ */
+ public final ColorSpace getColorSpace() {
+ return cs;
+ }
+
+ /**
+ * Gets the normalized components corresponding to the specified
+ * unnormalized components.
+ *
+ * @param components the array of unnormalized components
+ * @param offset the offset where the components should be read
+ * from the array of unnormalized components
+ * @param normComponents the array where the resulting normalised components
+ * are written (or null to prompt the method to create the return array)
+ * @param normOffset the offset that tells where the results should be written
+ * in the return array
+ *
+ * @return the normalized components
+ */
+ public float[] getNormalizedComponents(int[] components, int offset,
+ float normComponents[], int normOffset) {
+ if (bits == null) {
+ // awt.26C=bits is null
+ throw new UnsupportedOperationException(Messages.getString("awt.26C")); //$NON-NLS-1$
+ }
+
+ if (normComponents == null) {
+ normComponents = new float[numComponents + normOffset];
+ }
+
+ if (hasAlpha && isAlphaPremultiplied) {
+ float normAlpha =
+ (float) components[offset + numColorComponents] /
+ maxValues[numColorComponents];
+ if (normAlpha != 0.0f) {
+ for (int i = 0; i < numColorComponents; i++) {
+ normComponents[normOffset + i] =
+ components[offset + i] /
+ (normAlpha * maxValues[i]);
+ }
+ normComponents[normOffset + numColorComponents] = normAlpha;
+ } else {
+ for (int i = 0; i < numComponents; i++) {
+ normComponents[normOffset + i] = 0.0f;
+ }
+ }
+ } else {
+ for (int i = 0; i < numComponents; i++) {
+ normComponents[normOffset + i] =
+ (float) components[offset + i] /
+ maxValues[i];
+ }
+ }
+
+ return normComponents;
+ }
+
+ /**
+ * Gets the data element corresponding to the unnormalized components.
+ *
+ * @param components the components
+ * @param offset the offset to start reading the components from the
+ * array of components
+ *
+ * @return the data element
+ */
+ public int getDataElement(int[] components, int offset) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the unnormalized components corresponding to the specified
+ * normalized components.
+ *
+ * @param normComponents the array of normalized components
+ * @param normOffset the offset where the components should be read
+ * from the array of normalized components
+ * @param components the array where the resulting unnormalised components
+ * are written (or null to prompt the method to create the return array)
+ * @param offset the offset that tells where the results should be written
+ * in the return array
+ *
+ * @return the unnormalized components
+ */
+ public int[] getUnnormalizedComponents(float normComponents[],
+ int normOffset, int components[], int offset) {
+
+ if (bits == null) {
+ // awt.26C=bits is null
+ throw new UnsupportedOperationException(Messages.getString("awt.26C")); //$NON-NLS-1$
+ }
+
+ if (normComponents.length - normOffset < numComponents) {
+ // awt.273=The length of normComponents minus normOffset is less than numComponents
+ throw new IllegalArgumentException(Messages.getString("awt.273")); //$NON-NLS-1$
+ }
+
+ if (components == null) {
+ components = new int[numComponents + offset];
+ } else {
+ if (components.length - offset < numComponents) {
+ // awt.272=The length of components minus offset is less than numComponents
+ throw new IllegalArgumentException(Messages.getString("awt.272")); //$NON-NLS-1$
+ }
+ }
+
+ if (hasAlpha && isAlphaPremultiplied) {
+ float alpha = normComponents[normOffset + numColorComponents];
+ for (int i = 0; i < numColorComponents; i++) {
+ components[offset + i] = (int) (normComponents[normOffset + i]
+ * maxValues[i] * alpha + 0.5f);
+ }
+ components[offset + numColorComponents] =
+ (int) (normComponents[normOffset + numColorComponents] *
+ maxValues[numColorComponents] + 0.5f);
+ } else {
+ for (int i = 0; i < numComponents; i++) {
+ components[offset + i] =
+ (int) (normComponents[normOffset + i] *
+ maxValues[i] + 0.5f);
+ }
+ }
+
+ return components;
+ }
+
+ /**
+ * Gets the data element corresponding to the normalized components.
+ *
+ * @param normComponents the normalized components
+ * @param normOffset the offset where the normalized components should
+ * be read from the normalized component array
+ *
+ * @return the data element
+ */
+ public int getDataElement(float normComponents[], int normOffset) {
+ int unnormComponents[] = getUnnormalizedComponents(normComponents,
+ normOffset, null, 0);
+ return getDataElement(unnormComponents, 0);
+ }
+
+ /**
+ * Takes a pixel whose data is defined by an int, and writes the
+ * corresponding components into the components array, starting
+ * from the index offset.
+ *
+ * @param pixel the pixel data
+ * @param components the data array to write the components to (or
+ * null to have the method create the return array)
+ * @param offset the offset that determines where the results are
+ * written in the components array
+ *
+ * @return the array of components corresponding to the pixel
+ */
+ public int[] getComponents(int pixel, int components[], int offset) {
+ throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
+ "supported by this ColorModel"); //$NON-NLS-1$
+ }
+
+ /**
+ * Gets the red component of the pixel determined by the pixel data.
+ *
+ * @param pixel the pixel data
+ *
+ * @return the red component of the pixel
+ */
+ public abstract int getRed(int pixel);
+
+ /**
+ * Takes the pixel data and returns the int corresponding
+ * to the pixel's color in RGB format.
+ *
+ * @param pixel the pixel data
+ *
+ * @return the corresponding RGB int
+ */
+ public int getRGB(int pixel) {
+ return (getAlpha(pixel) << 24 | getRed(pixel) << 16
+ | getGreen(pixel) << 8 | getBlue(pixel));
+ }
+
+ /**
+ * Gets the green component of the pixel determined by the pixel data.
+ *
+ * @param pixel the pixel data
+ *
+ * @return the green component of the pixel
+ */
+ public abstract int getGreen(int pixel);
+
+ /**
+ * Gets the size of the desired component of this color model.
+ *
+ * @param componentIdx the index that determines which component size to get
+ *
+ * @return the component size corresponding to the index
+ *
+ * @throws NullPointerException if this color model doesn't support
+ * an array of separate components.
+ * @throws ArrayIndexOutOfBoundsException if the index is negative or
+ * greater than or equal to the number of components
+ */
+ public int getComponentSize(int componentIdx) {
+ if (bits == null) {
+ // awt.26C=bits is null
+ throw new NullPointerException(Messages.getString("awt.26C")); //$NON-NLS-1$
+ }
+
+ if (componentIdx < 0 || componentIdx >= bits.length) {
+ // awt.274=componentIdx is greater than the number of components or less than zero
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.274")); //$NON-NLS-1$
+ }
+
+ return bits[componentIdx];
+ }
+
+ /**
+ * Gets the blue component of the pixel determined by the pixel data.
+ *
+ * @param pixel the pixel
+ *
+ * @return the blue component of the pixel
+ */
+ public abstract int getBlue(int pixel);
+
+ /**
+ * Gets the alpha component of the pixel determined by the pixel data.
+ *
+ * @param pixel the pixel
+ *
+ * @return the alpha component of the pixel
+ */
+ public abstract int getAlpha(int pixel);
+
+ /**
+ * Gets the array of sizes of the different components.
+ *
+ * @return the array of sizes of the different components
+ */
+ public int[] getComponentSize() {
+ if (bits != null) {
+ return bits.clone();
+ }
+ return null;
+ }
+
+ /**
+ * Checks if the alpha component is premultiplied.
+ *
+ * @return true, if the alpha component is premultiplied
+ */
+ public final boolean isAlphaPremultiplied() {
+ return isAlphaPremultiplied;
+ }
+
+ /**
+ * Checks whether this color model supports alpha.
+ *
+ * @return true, if this color model has alpha
+ */
+ public final boolean hasAlpha() {
+ return hasAlpha;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = 0;
+ int tmp;
+
+ if (hasAlpha) {
+ hash ^= 1;
+ hash <<= 8;
+ }
+ if (isAlphaPremultiplied) {
+ hash ^= 1;
+ hash <<= 8;
+ }
+
+ tmp = hash >>> 24;
+ hash ^= numColorComponents;
+ hash <<= 8;
+ hash |= tmp;
+
+ tmp = hash >>> 24;
+ hash ^= transparency;
+ hash <<= 8;
+ hash |= tmp;
+
+ tmp = hash >>> 24;
+ hash ^= cs.getType();
+ hash <<= 8;
+ hash |= tmp;
+
+ tmp = hash >>> 24;
+ hash ^= pixel_bits;
+ hash <<= 8;
+ hash |= tmp;
+
+ tmp = hash >>> 24;
+ hash ^= transferType;
+ hash <<= 8;
+ hash |= tmp;
+
+ if (bits != null) {
+
+ for (int element : bits) {
+ tmp = hash >>> 24;
+ hash ^= element;
+ hash <<= 8;
+ hash |= tmp;
+ }
+
+ }
+
+ return hash;
+ }
+
+ public int getTransparency() {
+ return transparency;
+ }
+
+ /**
+ * Gets the transfer type, which is the type of Java primitive
+ * value that corresponds to the bit length per pixel: either
+ * {@link DataBuffer#TYPE_BYTE}, {@link DataBuffer#TYPE_USHORT},
+ * {@link DataBuffer#TYPE_INT}, or {@link DataBuffer#TYPE_UNDEFINED}.
+ *
+ * @return the transfer type
+ */
+ public final int getTransferType() {
+ return transferType;
+ }
+
+ /**
+ * Gets the pixel size in bits.
+ *
+ * @return the pixel size
+ */
+ public int getPixelSize() {
+ return pixel_bits;
+ }
+
+ /**
+ * Gets the number of components of this color model.
+ *
+ * @return the number of components
+ */
+ public int getNumComponents() {
+ return numComponents;
+ }
+
+ /**
+ * Gets the number of color components of this color model.
+ *
+ * @return the number color components
+ */
+ public int getNumColorComponents() {
+ return numColorComponents;
+ }
+
+ /**
+ * Gets the default RGB color model.
+ *
+ * @return the default RGB color model
+ */
+ public static ColorModel getRGBdefault() {
+ if (RGBdefault == null) {
+ RGBdefault = new DirectColorModel(32, 0x00ff0000, 0x0000ff00,
+ 0x000000ff, 0xff000000);
+ }
+ return RGBdefault;
+ }
+
+ /*
+ * Construct INT pixel representation from Object
+ * @param obj
+ *
+ * @return
+ */
+ /**
+ * Construct pixel.
+ *
+ * @param obj the obj
+ *
+ * @return the int
+ */
+ private int constructPixel(Object obj) {
+ int pixel = 0;
+
+ switch (getTransferType()) {
+
+ case DataBuffer.TYPE_BYTE:
+ byte[] bPixel = (byte[]) obj;
+ if(bPixel.length > 1) {
+ // awt.275=This pixel representation is not suuported by tis Color Model
+ throw new UnsupportedOperationException(Messages.getString("awt.275")); //$NON-NLS-1$
+ }
+ pixel = bPixel[0] & 0xff;
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short[] sPixel = (short[]) obj;
+ if(sPixel.length > 1) {
+ // awt.275=This pixel representation is not suuported by tis Color Model
+ throw new UnsupportedOperationException(Messages.getString("awt.275")); //$NON-NLS-1$
+ }
+ pixel = sPixel[0] & 0xffff;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int[] iPixel = (int[]) obj;
+ if(iPixel.length > 1) {
+ // awt.275=This pixel representation is not suuported by tis Color Model
+ throw new UnsupportedOperationException(Messages.getString("awt.275")); //$NON-NLS-1$
+ }
+ pixel = iPixel[0];
+ break;
+
+ default:
+ // awt.22D=This transferType ( {0} ) is not supported by this color model
+ throw new UnsupportedOperationException(Messages.getString("awt.22D", //$NON-NLS-1$
+ transferType));
+
+ }
+ return pixel;
+ }
+
+ /**
+ * Gets the transfer type, which is the type of Java primitive
+ * value that corresponds to the bit length per pixel: either
+ * {@link DataBuffer#TYPE_BYTE}, {@link DataBuffer#TYPE_USHORT},
+ * {@link DataBuffer#TYPE_INT}, or {@link DataBuffer#TYPE_UNDEFINED}.
+ *
+ * @param bits the array of component masks
+ *
+ * @return the transfer type
+ */
+ static int getTransferType(int bits) {
+ if (bits <= 8) {
+ return DataBuffer.TYPE_BYTE;
+ } else if (bits <= 16) {
+ return DataBuffer.TYPE_USHORT;
+ } else if (bits <= 32) {
+ return DataBuffer.TYPE_INT;
+ } else {
+ return DataBuffer.TYPE_UNDEFINED;
+ }
+ }
+
+ @Override
+ public void finalize() {
+ // This method is added for the API compatibility
+ // Don't need to call super since Object's finalize is always empty
+ }
+}
diff --git a/awt/java/awt/image/ComponentColorModel.java b/awt/java/awt/image/ComponentColorModel.java
new file mode 100644
index 0000000..a152f55
--- /dev/null
+++ b/awt/java/awt/image/ComponentColorModel.java
@@ -0,0 +1,1471 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.color.ColorSpace;
+
+import org.apache.harmony.awt.gl.color.LUTColorConverter;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class ComponentColorModel represents a color model that is defined
+ * in terms of its components.
+ */
+public class ComponentColorModel extends ColorModel {
+
+ /** The signed. */
+ private boolean signed; // Pixel samples are signed.
+ // Samples with TransferType DataBuffer.TYPE_BYTE,
+ // DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT -
+ // unsigned. Samples with others TransferType -
+ // signed.
+
+ /** The integral. */
+ private boolean integral; // Pixel samples are integral.
+ // Samples with TransferType DataBuffer.TYPE_BYTE,
+ // DataBuffer.TYPE_USHORT, DataBuffer.Short and
+ // DataBuffer.TYPE_INT - integral.
+
+ /** The scale factors. */
+ private float scaleFactors[]; // Array of factors for reduction components
+ // values into the form scaled from 0 to 255
+
+ /** The donot support unnormalized. */
+ private boolean donotSupportUnnormalized; // This Color Model don't support
+ // unnormolized form
+
+ /** The need alpha divide. */
+ private boolean needAlphaDivide; // hasAlpha && isAlphaPremultiplied
+
+ /** The calc value. */
+ private boolean calcValue; // Value was culculated
+
+ /** The need scale. */
+ private boolean needScale; // Normalized value need to scale
+
+ /** The min vals. */
+ private float minVals[]; // Array of Min normalized values
+
+ /** The ranges. */
+ private float ranges[]; // Array of range normalized values
+
+ /** The alpha lut. */
+ private byte alphaLUT[]; // Lookup table for scale alpha value
+
+ /** The color lu ts. */
+ private byte colorLUTs[][]; // Lookup tables for scale color values
+
+ /** The from_ linea r_ rg b_ lut. */
+ private byte from_LINEAR_RGB_LUT[]; // Lookup table for conversion from
+ // Linear RGB Color Space into sRGB
+
+ /** The to_ linea r_8 rg b_ lut. */
+ private byte to_LINEAR_8RGB_LUT[]; // Lookup table for conversion from
+ // sRGB Color Space into Linear RGB
+ // 8 bit
+
+ /** The to_ linea r_16 rg b_ lut. */
+ private short to_LINEAR_16RGB_LUT[]; // Lookup table for conversion from
+ // sRGB Color Space into Linear RGB
+ // 16 bit
+
+ /** The LINEA r_ rg b_ length. */
+ private int LINEAR_RGB_Length; // Linear RGB bit length
+
+ /** The factor. */
+ private float fFactor; // Scale factor
+
+ /** The is_s rgb. */
+ private boolean is_sRGB; // ColorModel has sRGB ColorSpace
+
+ /** The is_ linea r_ rgb. */
+ private boolean is_LINEAR_RGB; // Color Model has Linear RGB Color
+ // Space
+
+ /**
+ * Instantiates a new component color model.
+ *
+ * @param colorSpace the color space
+ * @param bits the array of component masks
+ * @param hasAlpha whether the color model has alpha
+ * @param isAlphaPremultiplied whether the alpha is premultiplied
+ * @param transparency the transparency strategy, @see java.awt.Transparency
+ * @param transferType the transfer type (primitive java type
+ * to use for the components)
+ */
+ public ComponentColorModel(ColorSpace colorSpace, int bits[],
+ boolean hasAlpha, boolean isAlphaPremultiplied, int transparency,
+ int transferType) {
+ super(createPixelBits(colorSpace, hasAlpha, transferType),
+ validateBits(bits, colorSpace, hasAlpha, transferType),
+ colorSpace, hasAlpha, isAlphaPremultiplied, transparency,
+ transferType);
+
+ needScale = false;
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ case DataBuffer.TYPE_USHORT:
+ case DataBuffer.TYPE_INT:
+ signed = false;
+ integral = true;
+ donotSupportUnnormalized = false;
+ scaleFactors = new float[numComponents];
+ for (int i = 0; i < numColorComponents; i++) {
+ scaleFactors[i] = 1.0f / maxValues[i];
+ if (cs.getMinValue(i) != 0.0f || cs.getMaxValue(i) != 1.0f) {
+ donotSupportUnnormalized = true;
+ }
+ }
+ if (hasAlpha) {
+ maxValues[numColorComponents] =
+ (1 << bits[numColorComponents]) - 1;
+ scaleFactors[numColorComponents] =
+ 1.0f / maxValues[numColorComponents];
+ }
+ break;
+ case DataBuffer.TYPE_SHORT:
+ signed = true;
+ integral = true;
+ donotSupportUnnormalized = true;
+ scaleFactors = new float[numComponents];
+ for (int i = 0; i < numComponents; i++) {
+ maxValues[i] = Short.MAX_VALUE;
+ scaleFactors[i] = 1.0f / maxValues[i];
+ if (cs.getMinValue(i) != 0.0f || cs.getMaxValue(i) != 1.0f) {
+ needScale = true;
+ }
+ }
+ if (needScale) {
+ minVals = new float[numColorComponents];
+ ranges = new float[numColorComponents];
+ for (int i = 0; i < numColorComponents; i++) {
+ minVals[i] = cs.getMinValue(i);
+ ranges[i] = cs.getMaxValue(i) - minVals[i];
+ }
+ }
+ break;
+ case DataBuffer.TYPE_FLOAT:
+ case DataBuffer.TYPE_DOUBLE:
+ signed = true;
+ integral = false;
+ donotSupportUnnormalized = true;
+ break;
+ default:
+ // awt.215=transferType is not one of DataBuffer.TYPE_BYTE,
+ // DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT,
+ // DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT, or
+ // DataBuffer.TYPE_DOUBLE
+ throw new IllegalArgumentException(Messages.getString("awt.215")); //$NON-NLS-1$
+ }
+
+ needAlphaDivide = hasAlpha && isAlphaPremultiplied;
+ initLUTs();
+ }
+
+ /**
+ * Instantiates a new component color model.
+ *
+ * @param colorSpace the color space
+ * @param hasAlpha whether the color model has alpha
+ * @param isAlphaPremultiplied whether the alpha is premultiplied
+ * @param transparency the transparency strategy, @see java.awt.Transparency
+ * @param transferType the transfer type (primitive java type
+ * to use for the components)
+ */
+ public ComponentColorModel(ColorSpace colorSpace, boolean hasAlpha,
+ boolean isAlphaPremultiplied, int transparency, int transferType) {
+
+ this(colorSpace,
+ createPixelBitsArray(colorSpace, hasAlpha, transferType),
+ hasAlpha,
+ isAlphaPremultiplied,
+ transparency,
+ transferType);
+ }
+
+ /**
+ * Validate bits.
+ *
+ * @param bits the bits
+ * @param colorSpace the color space
+ * @param hasAlpha the has alpha
+ * @param transferType the transfer type
+ *
+ * @return the int[]
+ */
+ private static int[] validateBits(int bits[], ColorSpace colorSpace,
+ boolean hasAlpha, int transferType) {
+ if (bits != null) {
+ return bits;
+ }
+
+ int numComponents = colorSpace.getNumComponents();
+ if (hasAlpha) {
+ numComponents++;
+ }
+ bits = new int[numComponents];
+
+ int componentLength = DataBuffer.getDataTypeSize(transferType);
+
+ for (int i = 0; i < numComponents; i++) {
+ bits[i] = componentLength;
+ }
+
+ return bits;
+ }
+
+ /**
+ * Creates the pixel bits.
+ *
+ * @param colorSpace the color space
+ * @param hasAlpha the has alpha
+ * @param transferType the transfer type
+ *
+ * @return the int
+ */
+ private static int createPixelBits(ColorSpace colorSpace, boolean hasAlpha,
+ int transferType) {
+ int numComponents = colorSpace.getNumComponents();
+ if (hasAlpha) {
+ numComponents++;
+ }
+ int componentLength = DataBuffer.getDataTypeSize(transferType);
+ return numComponents * componentLength;
+ }
+
+ /**
+ * Creates the pixel bits array.
+ *
+ * @param colorSpace the color space
+ * @param hasAlpha the has alpha
+ * @param transferType the transfer type
+ *
+ * @return the int[]
+ */
+ private static int[] createPixelBitsArray(ColorSpace colorSpace,
+ boolean hasAlpha, int transferType) {
+
+ int numComponents = colorSpace.getNumComponents();
+ if (hasAlpha) {
+ numComponents++;
+ }
+
+ int bits[] = new int[numComponents];
+ for(int i = 0; i < numComponents; i++){
+ bits[i] = DataBuffer.getDataTypeSize(transferType);
+ }
+ return bits;
+ }
+
+ @Override
+ public Object getDataElements(int components[], int offset, Object obj) {
+ if (donotSupportUnnormalized) {
+ // awt.213=This ComponentColorModel does not support the unnormalized form
+ throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
+ }
+
+ if (offset + numComponents > components.length) {
+ // awt.216=The components array is not large enough to hold all the color and alpha components
+ throw new IllegalArgumentException(Messages.getString("awt.216")); //$NON-NLS-1$
+ }
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[];
+ if (obj == null) {
+ ba = new byte[numComponents];
+ } else {
+ ba = (byte[]) obj;
+ }
+ for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
+ ba[i] = (byte) components[idx];
+ }
+ return ba;
+ case DataBuffer.TYPE_USHORT:
+ short sa[];
+ if (obj == null) {
+ sa = new short[numComponents];
+ } else {
+ sa = (short[]) obj;
+ }
+ for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
+ sa[i] = (short) components[idx];
+ }
+ return sa;
+ case DataBuffer.TYPE_INT:
+ int ia[];
+ if (obj == null) {
+ ia = new int[numComponents];
+ } else {
+ ia = (int[]) obj;
+ }
+ for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
+ ia[i] = components[idx];
+ }
+ return ia;
+ default:
+ // awt.217=The transfer type of this ComponentColorModel is not one
+ // of the following transfer types: DataBuffer.TYPE_BYTE,
+ // DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT
+ throw new UnsupportedOperationException(Messages
+ .getString("awt.217")); //$NON-NLS-1$
+ }
+ }
+
+ @Override
+ public Object getDataElements(float normComponents[], int normOffset,
+ Object obj) {
+ if (needScale) {
+ for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
+ normComponents[idx] =
+ (normComponents[idx] - minVals[i]) / ranges[i];
+ }
+ }
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[];
+ if (obj == null) {
+ ba = new byte[numComponents];
+ } else {
+ ba = (byte[]) obj;
+ }
+
+ if (needAlphaDivide) {
+ float alpha = normComponents[normOffset + numColorComponents];
+ for (int i = 0, idx = normOffset; i < numColorComponents;
+ i++, idx++) {
+ ba[i] = (byte) (normComponents[idx] * alpha *
+ maxValues[i] + 0.5f);
+ }
+ ba[numColorComponents] =
+ (byte) (normComponents[normOffset + numColorComponents] *
+ maxValues[numColorComponents] + 0.5f);
+ } else {
+ for (int i = 0, idx = normOffset; i < numComponents;
+ i++, idx++) {
+ ba[idx] =
+ (byte) (normComponents[idx] * maxValues[i] + 0.5f);
+ }
+ }
+ return ba;
+
+ case DataBuffer.TYPE_USHORT:
+ short usa[];
+ if (obj == null) {
+ usa = new short[numComponents];
+ } else {
+ usa = (short[]) obj;
+ }
+
+ if (needAlphaDivide) {
+ float alpha = normComponents[normOffset + numColorComponents];
+ for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
+ usa[i] = (short) (normComponents[idx] * alpha *
+ maxValues[i] + 0.5f);
+ }
+ usa[numColorComponents] = (short) (alpha *
+ maxValues[numColorComponents] + 0.5f);
+ } else {
+ for (int i = 0, idx = normOffset; i < numComponents;
+ i++, idx++) {
+ usa[i] = (short) (normComponents[idx] *
+ maxValues[i] + 0.5f);
+ }
+ }
+ return usa;
+
+ case DataBuffer.TYPE_INT:
+ int ia[];
+ if (obj == null) {
+ ia = new int[numComponents];
+ } else {
+ ia = (int[]) obj;
+ }
+
+ if (needAlphaDivide) {
+ float alpha = normComponents[normOffset + numColorComponents];
+ for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
+ ia[i] = (int) (normComponents[idx] * alpha *
+ maxValues[i] + 0.5f);
+ }
+ ia[numColorComponents] = (int) (alpha *
+ maxValues[numColorComponents] + 0.5f);
+ } else {
+ for (int i = 0, idx = normOffset; i < numComponents;
+ i++, idx++) {
+ ia[i] = (int) (normComponents[idx] * maxValues[i] + 0.5f);
+ }
+ }
+ return ia;
+
+ case DataBuffer.TYPE_SHORT:
+ short sa[];
+ if (obj == null) {
+ sa = new short[numComponents];
+ } else {
+ sa = (short[]) obj;
+ }
+
+ if (needAlphaDivide) {
+ float alpha = normComponents[normOffset + numColorComponents];
+ for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
+ sa[i] = (short) (normComponents[idx] * alpha *
+ maxValues[i] + 0.5f);
+ }
+ sa[numColorComponents] = (short) (alpha *
+ maxValues[numColorComponents] + 0.5f);
+ } else {
+ for (int i = 0, idx = normOffset; i < numComponents;
+ i++, idx++) {
+ sa[i] = (short) (normComponents[idx] *
+ maxValues[i] + 0.5f);
+ }
+ }
+ return sa;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fa[];
+ if (obj == null) {
+ fa = new float[numComponents];
+ } else {
+ fa = (float[]) obj;
+ }
+
+ if (needAlphaDivide) {
+ float alpha = normComponents[normOffset + numColorComponents];
+ for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
+ fa[i] = normComponents[idx] * alpha;
+ }
+ fa[numColorComponents] = alpha;
+ } else {
+ for (int i = 0, idx = normOffset; i < numComponents;
+ i++, idx++) {
+ fa[i] = normComponents[idx];
+ }
+ }
+ return fa;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double da[];
+ if (obj == null) {
+ da = new double[numComponents];
+ } else {
+ da = (double[]) obj;
+ }
+
+ if (needAlphaDivide) {
+ double alpha = normComponents[normOffset + numColorComponents];
+ for (int i = 0, idx = 0; i < numColorComponents; i++, idx++) {
+ da[i] = normComponents[idx] * alpha;
+ }
+ da[numColorComponents] = alpha;
+ } else {
+ for (int i = 0, idx = normOffset; i < numComponents;
+ i++, idx++) {
+ da[i] = normComponents[idx];
+ }
+ }
+ return da;
+
+ default:
+ // awt.213=This ComponentColorModel does not support the unnormalized form
+ throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
+ }
+ }
+
+ @Override
+ public Object getDataElements(int rgb, Object pixel) {
+ float normComp[];
+ float comp[];
+
+ int red = (rgb >> 16) & 0xff;
+ int green = (rgb >> 8) & 0xff;
+ int blue = rgb & 0xff;
+ int alpha = (rgb >> 24) & 0xff;
+
+ comp = new float[3];
+ if (is_sRGB || is_LINEAR_RGB) {
+ if (is_LINEAR_RGB) {
+ if (LINEAR_RGB_Length == 8) {
+ red = to_LINEAR_8RGB_LUT[red] & 0xff;
+ green = to_LINEAR_8RGB_LUT[green] & 0xff;
+ blue = to_LINEAR_8RGB_LUT[blue] & 0xff;
+ } else {
+ red = to_LINEAR_16RGB_LUT[red] & 0xffff;
+ green = to_LINEAR_16RGB_LUT[green] & 0xffff;
+ blue = to_LINEAR_16RGB_LUT[blue] & 0xffff;
+ }
+ }
+ comp[0] = red / fFactor;
+ comp[1] = green / fFactor;
+ comp[2] = blue / fFactor;
+ if (!hasAlpha) {
+ normComp = comp;
+ } else {
+ float normAlpha = alpha / 255.0f;
+ normComp = new float[numComponents];
+ for (int i = 0; i < numColorComponents; i++) {
+ normComp[i] = comp[i];
+ }
+ normComp[numColorComponents] = normAlpha;
+ }
+ } else {
+ comp[0] = red / fFactor;
+ comp[1] = green / fFactor;
+ comp[2] = blue / fFactor;
+ float[] defComp = cs.fromRGB(comp);
+ if (!hasAlpha) {
+ normComp = defComp;
+ } else {
+ float normAlpha = alpha / 255.0f;
+ normComp = new float[numComponents];
+ for (int i = 0; i < numColorComponents; i++) {
+ normComp[i] = defComp[i];
+ }
+ normComp[numColorComponents] = normAlpha;
+ }
+ }
+ if(hasAlpha && isAlphaPremultiplied){
+ normComp[0] *= normComp[numColorComponents];
+ normComp[1] *= normComp[numColorComponents];
+ normComp[2] *= normComp[numColorComponents];
+ }
+
+ return getDataElements(normComp, 0, pixel);
+ }
+
+ @Override
+ public WritableRaster getAlphaRaster(WritableRaster raster) {
+ if(!hasAlpha) {
+ return null;
+ }
+
+ int x = raster.getMinX();
+ int y = raster.getMinY();
+ int bandList[] = new int[1];
+ bandList[0] = raster.getNumBands() - 1;
+
+ return raster.createWritableChild(x, y, raster.getWidth(),
+ raster.getHeight(), x, y, bandList);
+ }
+
+ @Override
+ public ColorModel coerceData(WritableRaster raster,
+ boolean isAlphaPremultiplied) {
+ if (!hasAlpha || this.isAlphaPremultiplied == isAlphaPremultiplied) {
+ return this;
+ }
+
+ int minX = raster.getMinX();
+ int minY = raster.getMinY();
+ int w = raster.getWidth();
+ int h = raster.getHeight();
+
+ if (isAlphaPremultiplied) {
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ case DataBuffer.TYPE_USHORT:
+ case DataBuffer.TYPE_INT:
+ float alphaFactor = maxValues[numColorComponents];
+ int iComponents[] = null;
+ int iTransparentComponents[] = new int[numComponents];
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ iComponents = raster.getPixel(x, minY,
+ iComponents);
+ if (iComponents[numColorComponents] == 0) {
+ raster.setPixel(x, minY, iTransparentComponents);
+ } else {
+ float alpha =
+ iComponents[numColorComponents] /
+ alphaFactor;
+ for (int n = 0; n < numColorComponents; n++) {
+ iComponents[n] =
+ (int) (alpha * iComponents[n] + 0.5f);
+ }
+ raster.setPixel(x, minY, iComponents);
+ }
+ }
+
+ }
+ break;
+
+ case DataBuffer.TYPE_SHORT:
+ float sAlphaFactor = maxValues[numColorComponents];
+ short sComponents[] = null;
+ short sTransparentComponents[] = new short[numComponents];
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ sComponents = (short[]) raster.getDataElements(x, minY,
+ sComponents);
+ if (sComponents[numColorComponents] == 0) {
+ raster.setDataElements(x, minY,
+ sTransparentComponents);
+ } else {
+ float alpha =
+ sComponents[numColorComponents] /
+ sAlphaFactor;
+ for (int n = 0; n < numColorComponents; n++) {
+ sComponents[n] =
+ (byte) (alpha * sComponents[n] + 0.5f);
+ }
+ raster.setDataElements(x, minY, sComponents);
+ }
+ }
+
+ }
+ break;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fComponents[] = null;
+ float fTransparentComponents[] = new float[numComponents];
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ fComponents = raster.getPixel(x, minY, fComponents);
+ if (fComponents[numColorComponents] == 0.0f) {
+ raster.setDataElements(x, minY,
+ fTransparentComponents);
+ } else {
+ float alpha = fComponents[numColorComponents];
+ for (int n = 0; n < numColorComponents; n++) {
+ fComponents[n] = fComponents[n] * alpha;
+ }
+ raster.setPixel(x, minY, fComponents);
+ }
+ }
+
+ }
+ break;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double dComponents[] = null;
+ double dTransparentComponents[] = new double[numComponents];
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ dComponents = raster.getPixel(x, minY, dComponents);
+ if (dComponents[numColorComponents] == 0.0) {
+ raster.setPixel(x, minY, dTransparentComponents);
+ } else {
+ double alpha = dComponents[numColorComponents];
+ for (int n = 0; n < numColorComponents; n++) {
+ dComponents[n] = dComponents[n] * alpha;
+ }
+ raster.setPixel(x, minY, dComponents);
+ }
+ }
+
+ }
+ break;
+
+ default:
+ // awt.219=This transferType is not supported by this color model
+ throw new UnsupportedOperationException(Messages.getString("awt.219")); //$NON-NLS-1$
+ }
+ } else {
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ case DataBuffer.TYPE_USHORT:
+ case DataBuffer.TYPE_INT:
+ float alphaFactor = maxValues[numColorComponents];
+ int iComponents[] = null;
+ int iTransparentComponents[] = new int[numComponents];
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ iComponents = raster.getPixel(x, minY,
+ iComponents);
+ if (iComponents[numColorComponents] == 0) {
+ raster.setPixel(x, minY, iTransparentComponents);
+ } else {
+ float alpha =
+ iComponents[numColorComponents] /
+ alphaFactor;
+ for (int n = 0; n < numColorComponents; n++) {
+ iComponents[n] =
+ (int) (iComponents[n] /
+ alpha + 0.5f);
+ }
+ raster.setPixel(x, minY, iComponents);
+ }
+ }
+
+ }
+ break;
+
+ case DataBuffer.TYPE_SHORT:
+ float sAlphaFactor = maxValues[numColorComponents];
+ short sComponents[] = null;
+ short sTransparentComponents[] = new short[numComponents];
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ sComponents = (short[]) raster.getDataElements(x, minY,
+ sComponents);
+ if (sComponents[numColorComponents] == 0) {
+ raster.setDataElements(x, minY,
+ sTransparentComponents);
+ } else {
+ float alpha =
+ sComponents[numColorComponents] /
+ sAlphaFactor;
+ for (int n = 0; n < numColorComponents; n++) {
+ sComponents[n] =
+ (byte) (sComponents[n] /
+ alpha + 0.5f);
+ }
+ raster.setDataElements(x, minY, sComponents);
+ }
+ }
+
+ }
+ break;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fComponents[] = null;
+ float fTransparentComponents[] = new float[numComponents];
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ fComponents = raster.getPixel(x, minY, fComponents);
+ if (fComponents[numColorComponents] == 0.0f) {
+ raster.setDataElements(x, minY,
+ fTransparentComponents);
+ } else {
+ float alpha = fComponents[numColorComponents];
+ for (int n = 0; n < numColorComponents; n++) {
+ fComponents[n] = fComponents[n] / alpha;
+ }
+ raster.setPixel(x, minY, fComponents);
+ }
+ }
+
+ }
+ break;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double dComponents[] = null;
+ double dTransparentComponents[] = new double[numComponents];
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ dComponents = raster.getPixel(x, minY, dComponents);
+ if (dComponents[numColorComponents] == 0.0) {
+ raster.setPixel(x, minY, dTransparentComponents);
+ } else {
+ double alpha = dComponents[numColorComponents];
+ for (int n = 0; n < numColorComponents; n++) {
+ dComponents[n] = dComponents[n] / alpha;
+ }
+ raster.setPixel(x, minY, dComponents);
+ }
+ }
+
+ }
+ break;
+ default:
+ // awt.219=This transferType is not supported by this color model
+ throw new UnsupportedOperationException(Messages.getString("awt.219")); //$NON-NLS-1$
+ }
+ }
+
+ if (!signed) {
+ return new ComponentColorModel(cs, bits, hasAlpha,
+ isAlphaPremultiplied, transparency, transferType);
+ }
+
+ return new ComponentColorModel(cs, null, hasAlpha,
+ isAlphaPremultiplied, transparency, transferType);
+ }
+
+ @Override
+ public int[] getComponents(Object pixel, int[] components, int offset) {
+ if (donotSupportUnnormalized) {
+ // awt.213=This ComponentColorModel does not support the unnormalized form
+ throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
+ }
+
+ if (components == null) {
+ components = new int[offset + numComponents];
+ } else if (offset + numComponents > components.length) {
+ // awt.218=The components array is not large enough to hold all the color and alpha components
+ throw new IllegalArgumentException(Messages.getString("awt.218")); //$NON-NLS-1$
+ }
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) pixel;
+
+ for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
+ components[idx] = ba[i] & 0xff;
+ }
+ return components;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = (short[]) pixel;
+ for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
+ components[idx] = sa[i] & 0xffff;
+ }
+ return components;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) pixel;
+ for (int i = 0, idx = offset; i < numComponents; i++, idx++) {
+ components[idx] = ia[i];
+ }
+ return components;
+
+ default:
+ // awt.217=The transfer type of this ComponentColorModel is not one
+ // of the following transfer types: DataBuffer.TYPE_BYTE,
+ // DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT
+ throw new UnsupportedOperationException(Messages
+ .getString("awt.217")); //$NON-NLS-1$
+ }
+
+ }
+
+ @Override
+ public float[] getNormalizedComponents(Object pixel,
+ float normComponents[], int normOffset) {
+
+ if (normComponents == null) {
+ normComponents = new float[numComponents + normOffset];
+ }
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) pixel;
+ for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
+ normComponents[idx] = (ba[i] & 0xff) * scaleFactors[i];
+ }
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short usa[] = (short[]) pixel;
+ for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
+ normComponents[idx] = (usa[i] & 0xffff)
+ * scaleFactors[i];
+ }
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) pixel;
+ for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
+ normComponents[idx] = ia[i] * scaleFactors[i];
+ }
+ break;
+
+ case DataBuffer.TYPE_SHORT:
+ short sa[] = (short[]) pixel;
+ for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
+ normComponents[idx] = sa[i] * scaleFactors[i];
+ }
+ break;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fa[] = (float[]) pixel;
+ for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
+ normComponents[idx] = fa[i];
+ }
+ break;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double da[] = (double[]) pixel;
+ for (int i = 0, idx = normOffset; i < numComponents; i++, idx++) {
+ normComponents[idx] = (float) da[i];
+ }
+ break;
+
+ default:
+ // awt.21A=This ComponentColorModel does not support this transferType
+ throw new IllegalArgumentException(Messages.getString("awt.21A")); //$NON-NLS-1$
+ }
+
+ if (needAlphaDivide) {
+ float alpha = normComponents[normOffset + numColorComponents];
+ for (int i = 0, idx = normOffset; i < numColorComponents;
+ i++, idx++) {
+ normComponents[idx] /= alpha;
+ }
+ }
+
+ if (needScale) {
+ for (int i = 0, idx = normOffset; i < numColorComponents;
+ i++, idx++) {
+ normComponents[idx] = minVals[i] +
+ ranges[i] * normComponents[idx];
+ }
+ }
+ return normComponents;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (!(obj instanceof ComponentColorModel)) {
+ return false;
+ }
+ return super.equals(obj);
+ }
+
+ @Override
+ public int getRed(Object inData) {
+ return getRGBComponent(inData, 0);
+ }
+
+ @Override
+ public int getRGB(Object inData) {
+ int alpha = getAlpha(inData);
+ if (cs.getType() == ColorSpace.TYPE_GRAY) {
+ int gray = getRed(inData);
+ return (alpha << 24 | gray << 16 | gray << 8 | gray);
+ }
+ return (alpha << 24 | getRed(inData) << 16 | getGreen(inData) << 8 |
+ getBlue(inData));
+ }
+
+ @Override
+ public int getGreen(Object inData) {
+ return getRGBComponent(inData, 1);
+ }
+
+ @Override
+ public int getBlue(Object inData) {
+ return getRGBComponent(inData, 2);
+ }
+
+ @Override
+ public int getAlpha(Object inData) {
+ if (!hasAlpha) {
+ return 255;
+ }
+ int alpha = 0;
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE: {
+ byte ba[] = (byte[]) inData;
+ alpha = ba[numColorComponents] & 0xff;
+ if (bits[numColorComponents] != 8) {
+ return alphaLUT[alpha] & 0xff;
+ }
+ return alpha;
+ }
+ case DataBuffer.TYPE_USHORT: {
+ short usa[] = (short[]) inData;
+ alpha = usa[numColorComponents] & 0xffff;
+ if (bits[numColorComponents] != 8) {
+ return alphaLUT[alpha] & 0xff;
+ }
+ return alpha;
+ }
+ case DataBuffer.TYPE_INT: {
+ int ia[] = (int[]) inData;
+ alpha = ia[numColorComponents];
+ if (bits[numColorComponents] != 8) {
+ return alphaLUT[alpha] & 0xff;
+ }
+ return alpha;
+ }
+ case DataBuffer.TYPE_SHORT: {
+ short sa[] = (short[]) inData;
+ alpha = sa[numColorComponents];
+ if (bits[numColorComponents] != 8) {
+ return alphaLUT[alpha] & 0xff;
+ }
+ return alpha;
+ }
+ case DataBuffer.TYPE_FLOAT: {
+ float fa[] = (float[]) inData;
+ return (int) (fa[numColorComponents] * 255.0f + 0.5f);
+ }
+ case DataBuffer.TYPE_DOUBLE: {
+ double da[] = (double[]) inData;
+ return (int) (da[numColorComponents] * 255.0 + 0.5);
+ }
+ default: {
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+ }
+ }
+
+ @Override
+ public WritableRaster createCompatibleWritableRaster(int w, int h) {
+ SampleModel sm = createCompatibleSampleModel(w, h);
+ DataBuffer db = sm.createDataBuffer();
+ return Raster.createWritableRaster(sm, db, null);
+ }
+
+ @Override
+ public boolean isCompatibleSampleModel(SampleModel sm) {
+ if (!(sm instanceof ComponentSampleModel)) {
+ return false;
+ }
+ if (numComponents != sm.getNumBands()) {
+ return false;
+ }
+ if (transferType != sm.getTransferType()) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public SampleModel createCompatibleSampleModel(int w, int h) {
+ int bandOffsets[] = new int[numComponents];
+ for (int i = 0; i < numComponents; i++) {
+ bandOffsets[i] = i;
+ }
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ case DataBuffer.TYPE_USHORT:
+ return new PixelInterleavedSampleModel(transferType, w, h,
+ numComponents, w * numComponents, bandOffsets);
+
+ default:
+ return new ComponentSampleModel(transferType, w, h, numComponents,
+ w * numComponents, bandOffsets);
+ }
+ }
+
+ @Override
+ public boolean isCompatibleRaster(Raster raster) {
+ SampleModel sm = raster.getSampleModel();
+ if (!(sm instanceof ComponentSampleModel)) {
+ return false;
+ }
+
+ if (sm.getNumBands() != numComponents) {
+ return false;
+ }
+ if (raster.getTransferType() != transferType) {
+ return false;
+ }
+
+ int sampleSizes[] = sm.getSampleSize();
+ for (int i = 0; i < numComponents; i++) {
+ if (bits[i] != sampleSizes[i]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public float[] getNormalizedComponents(int components[], int offset,
+ float normComponents[], int normOffset) {
+ if (donotSupportUnnormalized) {
+ // awt.213=This ComponentColorModel does not support the unnormalized form
+ throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
+ }
+
+ return super.getNormalizedComponents(components, offset,
+ normComponents, normOffset);
+ }
+
+ @Override
+ public int getDataElement(int[] components, int offset) {
+ if (numComponents > 1) {
+ // awt.212=There is more than one component in this ColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
+ }
+ if (donotSupportUnnormalized) {
+ // awt.213=This ComponentColorModel does not support the unnormalized form
+ throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
+ }
+ return components[offset];
+ }
+
+ @Override
+ public int[] getUnnormalizedComponents(float[] normComponents,
+ int normOffset, int[] components, int offset) {
+
+ if (donotSupportUnnormalized) {
+ // awt.213=This ComponentColorModel does not support the unnormalized form
+ throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
+ }
+
+ if (normComponents.length - normOffset < numComponents) {
+ // awt.21B=The length of normComponents minus normOffset is less than numComponents
+ throw new IllegalArgumentException(Messages.getString("awt.21B")); //$NON-NLS-1$
+ }
+
+ return super.getUnnormalizedComponents(normComponents, normOffset,
+ components, offset);
+ }
+
+ @Override
+ public int getDataElement(float normComponents[], int normOffset) {
+ if (numComponents > 1) {
+ // awt.212=There is more than one component in this ColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
+ }
+ if (signed) {
+ // awt.210=The component value for this ColorModel is signed
+ throw new IllegalArgumentException(Messages.getString("awt.210")); //$NON-NLS-1$
+ }
+
+ Object pixel = getDataElements(normComponents, normOffset, null);
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) pixel;
+ return ba[0] & 0xff;
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = (short[]) pixel;
+ return sa[0] & 0xffff;
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) pixel;
+ return ia[0];
+ default:
+ // awt.211=Pixel values for this ColorModel are not conveniently
+ // representable as a single int
+ throw new IllegalArgumentException(Messages.getString("awt.211")); //$NON-NLS-1$
+ }
+ }
+
+ @Override
+ public int[] getComponents(int pixel, int components[], int offset) {
+ if (numComponents > 1) {
+ // awt.212=There is more than one component in this ColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
+ }
+ if (donotSupportUnnormalized) {
+ // awt.213=This ComponentColorModel does not support the unnormalized form
+ throw new IllegalArgumentException(Messages.getString("awt.213")); //$NON-NLS-1$
+ }
+
+ if (components == null) {
+ components = new int[offset + 1];
+ }
+
+ components[offset] = pixel & maxValues[0];
+ return components;
+ }
+
+ @Override
+ public int getRed(int pixel) {
+ float rgb[] = toRGB(pixel);
+ return (int) (rgb[0] * 255.0f + 0.5f);
+ }
+
+ @Override
+ public int getRGB(int pixel) {
+ return (getAlpha(pixel) << 24) | (getRed(pixel) << 16) |
+ (getGreen(pixel) << 8) | getBlue(pixel);
+ }
+
+ @Override
+ public int getGreen(int pixel) {
+ float rgb[] = toRGB(pixel);
+ return (int) (rgb[1] * 255.0f + 0.5f);
+ }
+
+ @Override
+ public int getBlue(int pixel) {
+ float rgb[] = toRGB(pixel);
+ return (int) (rgb[2] * 255.0f + 0.5f);
+ }
+
+ @Override
+ public int getAlpha(int pixel) {
+
+ // This method throw IllegalArgumentException according to
+ // Java API Spacification
+ if (signed) {
+ // awt.210=The component value for this ColorModel is signed
+ throw new IllegalArgumentException(Messages.getString("awt.210")); //$NON-NLS-1$
+ }
+
+ if (numComponents > 1) {
+ // awt.212=There is more than one component in this ColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
+ }
+
+ return 255;
+ }
+
+ /**
+ * Initialization of Lookup tables.
+ */
+ private void initLUTs() {
+ is_sRGB = cs.isCS_sRGB();
+ is_LINEAR_RGB = (cs == LUTColorConverter.LINEAR_RGB_CS);
+
+ if (hasAlpha && bits[numColorComponents] != 8 && integral) {
+ alphaLUT = new byte[maxValues[numColorComponents] + 1];
+ for (int i = 0; i <= maxValues[numColorComponents]; i++) {
+ alphaLUT[i] = (byte) (scaleFactors[numColorComponents] * i +
+ 0.5f);
+ }
+ }
+
+ if (is_LINEAR_RGB) {
+ if (maxBitLength > 8) {
+ LINEAR_RGB_Length = 16;
+ from_LINEAR_RGB_LUT =
+ LUTColorConverter.getFrom16lRGBtosRGB_LUT();
+ to_LINEAR_16RGB_LUT =
+ LUTColorConverter.getFromsRGBto16lRGB_LUT();
+ } else {
+ LINEAR_RGB_Length = 8;
+ from_LINEAR_RGB_LUT =
+ LUTColorConverter.getFrom8lRGBtosRGB_LUT();
+ to_LINEAR_8RGB_LUT =
+ LUTColorConverter.getFromsRGBto8lRGB_LUT();
+ }
+ fFactor = ((1 << LINEAR_RGB_Length) - 1);
+ } else {
+ fFactor = 255.0f;
+ }
+
+ if (!isAlphaPremultiplied && integral) {
+ colorLUTs = new byte[3][];
+
+ if (is_sRGB) {
+ for (int i = 0; i < numColorComponents; i++) {
+ if (bits[i] != 8) {
+ for (int j = 0; j < i; j++) {
+ if (bits[i] == bits[j]) {
+ colorLUTs[i] = colorLUTs[j];
+ break;
+ }
+ }
+ colorLUTs[i] = new byte[maxValues[i] + 1];
+ for (int j = 0; j <= maxValues[0]; j++) {
+ colorLUTs[i][j] =
+ (byte) (scaleFactors[i] * j + 0.5f);
+ }
+ }
+ }
+ }
+
+ if (is_LINEAR_RGB) {
+
+ for (int i = 0; i < numColorComponents; i++) {
+ if (bits[i] != LINEAR_RGB_Length) {
+ for (int j = 0; j < i; j++) {
+ if (bits[i] == bits[j]) {
+ colorLUTs[i] = colorLUTs[j];
+ break;
+ }
+ }
+ colorLUTs[i] = new byte[maxValues[i] + 1];
+ for (int j = 0; j <= maxValues[0]; j++) {
+ int idx;
+ if (LINEAR_RGB_Length == 8) {
+ idx = (int) (scaleFactors[i] * j + 0.5f);
+ } else {
+ idx = (int) (scaleFactors[i] * j * 257.0f +
+ 0.5f);
+ }
+ colorLUTs[i][j] = from_LINEAR_RGB_LUT[idx];
+ }
+ }
+ }
+ }
+
+ }
+ }
+
+ /**
+ * To rgb.
+ *
+ * @param pixel - int representation of pixel
+ *
+ * @return - array of normalized sRGB components
+ */
+ private float[] toRGB(int pixel) {
+
+ // This method throw IllegalArgumentException according to
+ // Java API Spacification
+ if (signed) {
+ // awt.210=The component value for this ColorModel is signed
+ throw new IllegalArgumentException(Messages.getString("awt.210")); //$NON-NLS-1$
+ }
+
+ if (numComponents > 1) {
+ // awt.212=There is more than one component in this ColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.212")); //$NON-NLS-1$
+ }
+
+ Object obj = null;
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = new byte[1];
+ ba[0] = (byte) pixel;
+ obj = ba;
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = new short[1];
+ sa[0] = (short) pixel;
+ obj = sa;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = new int[1];
+ ia[0] = pixel;
+ obj = ia;
+ break;
+
+ }
+
+ return cs.toRGB(getNormalizedComponents(obj, null, 0));
+ }
+
+ /**
+ * Gets the rgb component.
+ *
+ * @param pixel - pixel
+ * @param idx - index of component
+ *
+ * @return - RGB value from 0 to 255 pixel's component
+ */
+ private int getRGBComponent(Object pixel, int idx) {
+ if (is_sRGB) {
+ int comp = getDefComponent(pixel, idx);
+ if (calcValue || bits[idx] == 8) {
+ return comp;
+ }
+ return colorLUTs[idx][comp] & 0xff;
+ } else if (is_LINEAR_RGB) {
+ int comp = getDefComponent(pixel, idx);
+ if (calcValue || bits[idx] == LINEAR_RGB_Length) {
+ return from_LINEAR_RGB_LUT[comp] & 0xff;
+ }
+ return colorLUTs[idx][comp] & 0xff;
+ }
+
+ float normComp[] = getNormalizedComponents(pixel, null, 0);
+ float rgbComp[] = cs.toRGB(normComp);
+ return (int) (rgbComp[idx] * 255.0f + 0.5f);
+ }
+
+ /**
+ * Gets the def component.
+ *
+ * @param pixel - pixel
+ * @param idx - index of component
+ *
+ * @return - tentative value of the pixel component
+ */
+ private int getDefComponent(Object pixel, int idx) {
+ int comp = 0;
+ calcValue = false;
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) pixel;
+ comp = ba[idx] & 0xff;
+ if (needAlphaDivide) {
+ int alpha = ba[numColorComponents] & 0xff;
+ if (alpha == 0) {
+ comp = 0;
+ } else {
+ float normAlpha = scaleFactors[numColorComponents] * alpha;
+ comp = (int) (comp * fFactor / normAlpha + 0.5f);
+ }
+ calcValue = true;
+ }
+ return comp;
+
+ case DataBuffer.TYPE_USHORT:
+ short usa[] = (short[]) pixel;
+ comp = usa[idx] & 0xffff;
+ if (needAlphaDivide) {
+ int alpha = usa[numColorComponents] & 0xffff;
+ if (alpha == 0) {
+ comp = 0;
+ } else {
+ float normAlpha = scaleFactors[numColorComponents] * alpha;
+ comp = (int) (comp * fFactor / normAlpha + 0.5f);
+ }
+ calcValue = true;
+ }
+ return comp;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) pixel;
+ comp = ia[idx];
+ if (needAlphaDivide) {
+ int alpha = ia[numColorComponents];
+ if (alpha == 0) {
+ comp = 0;
+ } else {
+ float normAlpha = scaleFactors[numColorComponents] * alpha;
+ comp = (int) (comp * fFactor / normAlpha + 0.5f);
+ }
+ calcValue = true;
+ }
+ return comp;
+
+ case DataBuffer.TYPE_SHORT:
+ short sa[] = (short[]) pixel;
+ comp = sa[idx];
+ if (needAlphaDivide) {
+ int alpha = sa[numColorComponents];
+ if (alpha == 0) {
+ comp = 0;
+ } else {
+ float normAlpha = scaleFactors[numColorComponents] * alpha;
+ comp = (int) (comp * fFactor / normAlpha + 0.5f);
+ }
+ calcValue = true;
+ }
+ return comp;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fa[] = (float[]) pixel;
+ if (needAlphaDivide) {
+ float alpha = fa[numColorComponents];
+ if (fa[numColorComponents] == 0.0f) {
+ comp = 0;
+ } else {
+ comp = (int) (fa[idx] * fFactor / alpha + 0.5f);
+ }
+ } else {
+ comp = (int) (fa[idx] * fFactor + 0.5f);
+ }
+ calcValue = true;
+ return comp;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double da[] = (double[]) pixel;
+ if (needAlphaDivide) {
+ if (da[numColorComponents] == 0.0) {
+ comp = 0;
+ } else {
+ comp = (int) (da[idx] * fFactor / da[numColorComponents] +
+ 0.5);
+ }
+ } else {
+ comp = (int) (da[idx] * fFactor + 0.5);
+ }
+ calcValue = true;
+ return comp;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+ }
+
+}
+
diff --git a/awt/java/awt/image/ComponentSampleModel.java b/awt/java/awt/image/ComponentSampleModel.java
new file mode 100644
index 0000000..2ff4f1a
--- /dev/null
+++ b/awt/java/awt/image/ComponentSampleModel.java
@@ -0,0 +1,690 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.util.Arrays;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The ComponentSampleModel class represents a set of image data whose
+ * each element - the sample of a pixel - takes one data element of
+ * the DataBuffer.
+ * <p>
+ * The Bank indices denote the correspondence between the bank of data
+ * buffers and a band of image data. The Pixel stride is the number of data
+ * array elements between two samples for the same band on the same
+ * scanline. The pixel stride for a BandedSampleModel is one. The Scanline
+ * stride represents the number of data array elements between a
+ * specified sample and the corresponding sample in the same column in
+ * the next scanline. The array of band offsets gives the starting
+ * offsets within each data banks of the in the DataBuffer. The bank
+ * indices represents the indices within each bank of the DataBuffer
+ * corresponding to a band of image data.
+ */
+public class ComponentSampleModel extends SampleModel {
+
+ /** The band offsets array of this ComponentSampleModel. */
+ protected int bandOffsets[];
+
+ /** The bank indices array of this ComponentSampleModel. */
+ protected int bankIndices[];
+
+ /** The number of bands in this ComponentSampleModel. */
+ protected int numBands;
+
+ /** The number banks of this ComponentSampleModel. */
+ protected int numBanks;
+
+ /** The scanline stride of this ComponentSampleModel. */
+ protected int scanlineStride;
+
+ /** The pixel stride of this ComponentSampleModel. */
+ protected int pixelStride;
+
+ /**
+ * Instantiates a new ComponentSampleModel with the specified
+ * properties.
+ *
+ * @param dataType the data type of samples.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param pixelStride the pixel stride of the image data.
+ * @param scanlineStride the scanline stride of the image data.
+ * @param bankIndices the array of the bank indices.
+ * @param bandOffsets the array of the band offsets.
+ */
+ public ComponentSampleModel(int dataType, int w, int h, int pixelStride,
+ int scanlineStride, int bankIndices[], int bandOffsets[]) {
+
+ super(dataType, w, h, bandOffsets.length);
+
+ if (pixelStride < 0) {
+ // awt.24B=Pixel stride must be >= 0
+ throw new IllegalArgumentException(Messages.getString("awt.24B")); //$NON-NLS-1$
+ }
+
+ if (scanlineStride < 0) {
+ // awt.24C=Scanline stride must be >= 0
+ throw new IllegalArgumentException(Messages.getString("awt.24C")); //$NON-NLS-1$
+ }
+
+ if (bankIndices.length != bandOffsets.length) {
+ // awt.24D=Bank Indices length must be equal Bank Offsets length
+ throw new IllegalArgumentException(Messages.getString("awt.24D")); //$NON-NLS-1$
+ }
+
+ this.pixelStride = pixelStride;
+ this.scanlineStride = scanlineStride;
+ this.bandOffsets = bandOffsets.clone();
+ this.bankIndices = bankIndices.clone();
+ this.numBands = bandOffsets.length;
+
+ int maxBank = 0;
+ for (int i = 0; i < bankIndices.length; i++) {
+ if (bankIndices[i] < 0) {
+ // awt.24E=Index of {0} bank must be >= 0
+ throw new IllegalArgumentException(Messages.getString("awt.24E", i)); //$NON-NLS-1$
+ }
+ if (bankIndices[i] > maxBank) {
+ maxBank = bankIndices[i];
+ }
+ }
+ this.numBanks = maxBank + 1;
+
+ }
+
+ /**
+ * Instantiates a new ComponentSampleModel with the specified
+ * properties.
+ *
+ * @param dataType the data type of the samples.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param pixelStride the pixel stride of the image data.
+ * @param scanlineStride the scanline stride of the image data.
+ * @param bandOffsets the band offsets.
+ */
+ public ComponentSampleModel(int dataType, int w, int h, int pixelStride,
+ int scanlineStride, int bandOffsets[]) {
+
+ super(dataType, w, h, bandOffsets.length);
+ if (pixelStride < 0) {
+ // awt.24B=Pixel stride must be >= 0
+ throw new IllegalArgumentException(Messages.getString("awt.24B")); //$NON-NLS-1$
+ }
+
+ if (scanlineStride < 0) {
+ // awt.24C=Scanline stride must be >= 0
+ throw new IllegalArgumentException(Messages.getString("awt.24C")); //$NON-NLS-1$
+ }
+
+ this.pixelStride = pixelStride;
+ this.scanlineStride = scanlineStride;
+ this.bandOffsets = bandOffsets.clone();
+ this.numBands = bandOffsets.length;
+ this.numBanks = 1;
+
+ this.bankIndices = new int[numBands];
+ for (int i = 0; i < numBands; i++) {
+ bankIndices[i] = 0;
+ }
+ }
+
+ @Override
+ public Object getDataElements(int x, int y, Object obj, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ byte bdata[];
+ if (obj == null) {
+ bdata = new byte[numBands];
+ } else {
+ bdata = (byte[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ bdata[i] = (byte) getSample(x, y, i, data);
+ }
+
+ obj = bdata;
+ break;
+
+ case DataBuffer.TYPE_SHORT:
+ case DataBuffer.TYPE_USHORT:
+ short sdata[];
+ if (obj == null) {
+ sdata = new short[numBands];
+ } else {
+ sdata = (short[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ sdata[i] = (short) getSample(x, y, i, data);
+ }
+
+ obj = sdata;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int idata[];
+ if (obj == null) {
+ idata = new int[numBands];
+ } else {
+ idata = (int[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ idata[i] = getSample(x, y, i, data);
+ }
+
+ obj = idata;
+ break;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fdata[];
+ if (obj == null) {
+ fdata = new float[numBands];
+ } else {
+ fdata = (float[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ fdata[i] = getSampleFloat(x, y, i, data);
+ }
+
+ obj = fdata;
+ break;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double ddata[];
+ if (obj == null) {
+ ddata = new double[numBands];
+ } else {
+ ddata = (double[]) obj;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ ddata[i] = getSampleDouble(x, y, i, data);
+ }
+
+ obj = ddata;
+ break;
+ }
+
+ return obj;
+ }
+
+ @Override
+ public void setDataElements(int x, int y, Object obj, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ byte barr[] = (byte[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, barr[i] & 0xff, data);
+ }
+ break;
+
+ case DataBuffer.TYPE_SHORT:
+ case DataBuffer.TYPE_USHORT:
+ short sarr[] = (short[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, sarr[i] & 0xffff, data);
+ }
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int iarr[] = (int[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, iarr[i], data);
+ }
+ break;
+
+ case DataBuffer.TYPE_FLOAT:
+ float farr[] = (float[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, farr[i], data);
+ }
+ break;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double darr[] = (double[]) obj;
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, darr[i], data);
+ }
+ break;
+ }
+ }
+
+ /**
+ * Compares this ComponentSampleModel with the specified Object.
+ *
+ * @param o the Object.
+ *
+ * @return true, if the object is a ComponentSampleModel with
+ * identical data values to this ComponentSampleModel, false otherwise.
+ */
+ @Override
+ public boolean equals(Object o) {
+ if ((o == null) || !(o instanceof ComponentSampleModel)) {
+ return false;
+ }
+ ComponentSampleModel model = (ComponentSampleModel) o;
+ return this.width == model.width && this.height == model.height &&
+ this.numBands == model.numBands &&
+ this.dataType == model.dataType &&
+ Arrays.equals(this.bandOffsets, model.bandOffsets) &&
+ Arrays.equals(this.bankIndices, model.bankIndices) &&
+ this.numBands == model.numBands &&
+ this.numBanks == model.numBanks &&
+ this.scanlineStride == model.scanlineStride &&
+ this.pixelStride == model.pixelStride;
+ }
+
+ /**
+ * @see java.awt.image.SampleModel#createSubsetSampleModel(int[])
+ */
+ @Override
+ public SampleModel createSubsetSampleModel(int bands[]) {
+ if (bands.length > this.numBands) {
+ // awt.64=The number of the bands in the subset is greater than the number of bands in the sample model
+ throw new RasterFormatException(Messages.getString("awt.64")); //$NON-NLS-1$
+ }
+
+ int indices[] = new int[bands.length];
+ int offsets[] = new int[bands.length];
+
+ for (int i = 0; i < bands.length; i++) {
+ indices[i] = bankIndices[bands[i]];
+ offsets[i] = bandOffsets[bands[i]];
+ }
+
+ return new ComponentSampleModel(dataType, width, height, pixelStride,
+ scanlineStride, indices, offsets);
+
+ }
+
+ @Override
+ public SampleModel createCompatibleSampleModel(int w, int h) {
+ return new ComponentSampleModel(dataType, w, h, pixelStride,
+ pixelStride * w, bankIndices, bandOffsets);
+ }
+
+ @Override
+ public int[] getPixel(int x, int y, int iArray[], DataBuffer data) {
+ int pixel[];
+
+ if (iArray == null) {
+ pixel = new int[numBands];
+ } else {
+ pixel = iArray;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ pixel[i] = getSample(x, y, i, data);
+ }
+
+ return pixel;
+ }
+
+ @Override
+ public void setPixel(int x, int y, int iArray[], DataBuffer data) {
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, iArray[i], data);
+ }
+ }
+
+ @Override
+ public int getSample(int x, int y, int b, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ return data.getElem(bankIndices[b], y * scanlineStride +
+ x * pixelStride + bandOffsets[b]);
+ }
+
+ @Override
+ public float getSampleFloat(int x, int y, int b, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ return data.getElemFloat(bankIndices[b], y * scanlineStride +
+ x * pixelStride + bandOffsets[b]);
+ }
+
+ @Override
+ public double getSampleDouble(int x, int y, int b, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ return data.getElemDouble(bankIndices[b], y * scanlineStride +
+ x * pixelStride + bandOffsets[b]);
+ }
+
+ @Override
+ public int[] getPixels(int x, int y, int w, int h, int iArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x > this.width || x + w > this.width
+ || y > this.height || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int pixels[] = null;
+ int idx = 0;
+
+ if (iArray == null) {
+ pixels = new int[w * h * numBands];
+ } else {
+ pixels = iArray;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numBands; n++) {
+ pixels[idx++] = getSample(j, i, n, data);
+ }
+ }
+ }
+
+ return pixels;
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h, int iArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int idx = 0;
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numBands; n++) {
+ setSample(j, i, n, iArray[idx++], data);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void setSample(int x, int y, int b, int s, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ data.setElem(bankIndices[b], y * scanlineStride + x * pixelStride
+ + bandOffsets[b], s);
+ }
+
+ @Override
+ public int[] getSamples(int x, int y, int w, int h, int b, int iArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int samples[];
+ int idx = 0;
+
+ if (iArray == null) {
+ samples = new int[w * h];
+ } else {
+ samples = iArray;
+ }
+
+ if (data == null) {
+ // awt.295=data is null
+ throw new NullPointerException(Messages.getString("awt.295")); //$NON-NLS-1$
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ samples[idx++] = getSample(j, i, b, data);
+ }
+ }
+
+ return samples;
+ }
+
+ @Override
+ public void setSamples(int x, int y, int w, int h, int b, int iArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int idx = 0;
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ setSample(j, i, b, iArray[idx++], data);
+ }
+ }
+ }
+
+ @Override
+ public void setSample(int x, int y, int b, float s, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ data.setElemFloat(bankIndices[b], y * scanlineStride +
+ x * pixelStride + bandOffsets[b], s);
+ }
+
+ @Override
+ public void setSample(int x, int y, int b, double s, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ data.setElemDouble(bankIndices[b], y * scanlineStride +
+ x * pixelStride + bandOffsets[b], s);
+ }
+
+ @Override
+ public DataBuffer createDataBuffer() {
+ DataBuffer data = null;
+
+ int maxOffset = bandOffsets[0];
+ for (int i = 1; i < bandOffsets.length; i++) {
+ if (bandOffsets[i] > maxOffset) {
+ maxOffset = bandOffsets[i];
+ }
+ }
+ int size = (height - 1) * scanlineStride +
+ (width - 1) * pixelStride + maxOffset + 1;
+
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ data = new DataBufferByte(size, numBanks);
+ break;
+ case DataBuffer.TYPE_SHORT:
+ data = new DataBufferShort(size, numBanks);
+ break;
+ case DataBuffer.TYPE_USHORT:
+ data = new DataBufferUShort(size, numBanks);
+ break;
+ case DataBuffer.TYPE_INT:
+ data = new DataBufferInt(size, numBanks);
+ break;
+ case DataBuffer.TYPE_FLOAT:
+ data = new DataBufferFloat(size, numBanks);
+ break;
+ case DataBuffer.TYPE_DOUBLE:
+ data = new DataBufferDouble(size, numBanks);
+ break;
+ }
+
+ return data;
+
+ }
+
+ /**
+ * Gets the offset of the specified band of the specified pixel.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the band.
+ *
+ * @return the offset of the specified band of the specified pixel.
+ */
+ public int getOffset(int x, int y, int b) {
+ return y * scanlineStride + x * pixelStride + bandOffsets[b];
+ }
+
+ /**
+ * Gets the offset of the first band of the specified pixel.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ *
+ * @return the offset of the first band of the specified pixel.
+ */
+ public int getOffset(int x, int y) {
+ return y * scanlineStride + x * pixelStride + bandOffsets[0];
+ }
+
+ @Override
+ public final int getSampleSize(int band) {
+ return DataBuffer.getDataTypeSize(dataType);
+ }
+
+ @Override
+ public final int[] getSampleSize() {
+ int sampleSizes[] = new int[numBands];
+ int size = DataBuffer.getDataTypeSize(dataType);
+
+ for (int i = 0; i < numBands; i++) {
+ sampleSizes[i] = size;
+ }
+ return sampleSizes;
+ }
+
+ /**
+ * Gets an array of bank indices corresponding to this
+ * ComponentSampleModel.
+ *
+ * @return the array of bank indices.
+ */
+ public final int[] getBankIndices() {
+ return bankIndices.clone();
+ }
+
+ /**
+ * Gets an array of the band offsets corresponding to this
+ * ComponentSampleModel.
+ *
+ * @return the array of band offsets.
+ */
+ public final int[] getBandOffsets() {
+ return bandOffsets.clone();
+ }
+
+ /**
+ * Gets a hash code of this ComponentSampleModel object.
+ *
+ * @return a hash code of this ComponentSampleModel object.
+ */
+ @Override
+ public int hashCode() {
+ int hash = 0;
+ int tmp = 0;
+
+ hash = width;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= height;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= numBands;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= dataType;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ for (int element : bandOffsets) {
+ hash ^= element;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ }
+ for (int element : bankIndices) {
+ hash ^= element;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ }
+ hash ^= pixelStride;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+
+ hash ^= scanlineStride;
+ return hash;
+ }
+
+ /**
+ * Gets the scanline stride of this ComponentSampleModel.
+ *
+ * @return the scanline stride of this ComponentSampleModel.
+ */
+ public final int getScanlineStride() {
+ return scanlineStride;
+ }
+
+ /**
+ * Gets the pixel stride.
+ *
+ * @return the pixel stride
+ */
+ public final int getPixelStride() {
+ return pixelStride;
+ }
+
+ @Override
+ public final int getNumDataElements() {
+ return numBands;
+ }
+
+}
+
+
+
diff --git a/awt/java/awt/image/ConvolveOp.java b/awt/java/awt/image/ConvolveOp.java
new file mode 100644
index 0000000..bb588bc
--- /dev/null
+++ b/awt/java/awt/image/ConvolveOp.java
@@ -0,0 +1,545 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ *
+ * @date: Sep 29, 2005
+ */
+
+package java.awt.image;
+
+import java.awt.*;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.util.Arrays;
+
+import org.apache.harmony.awt.gl.AwtImageBackdoorAccessor;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The ConvolveOp class convolves from the source data
+ * to the destination using a convolution kernel.
+ * Each output pixel is represented as the result of multiplying
+ * the kernel and the surround of the input pixel.
+ */
+public class ConvolveOp implements BufferedImageOp, RasterOp {
+
+ /**
+ * The Constant EDGE_ZERO_FILL indicates that pixels at the edge of
+ * the destination image are set to zero.
+ */
+ public static final int EDGE_ZERO_FILL = 0;
+
+ /**
+ * The Constant EDGE_NO_OP indicates that pixels at the edge of
+ * the source image are converted to the edge pixels in the
+ * destination without modification.
+ */
+ public static final int EDGE_NO_OP = 1;
+
+ /** The kernel. */
+ private Kernel kernel;
+
+ /** The edge cond. */
+ private int edgeCond;
+
+ /** The rhs. */
+ private RenderingHints rhs = null;
+
+ static {
+ // TODO
+ //System.loadLibrary("imageops");
+ }
+
+ /**
+ * Instantiates a new ConvolveOp object with the specified Kernel
+ * and specified edges condition.
+ *
+ * @param kernel the specified Kernel.
+ * @param edgeCondition the specified edge condition.
+ * @param hints the RenderingHints object, or null.
+ */
+ public ConvolveOp(Kernel kernel, int edgeCondition, RenderingHints hints) {
+ this.kernel = kernel;
+ this.edgeCond = edgeCondition;
+ this.rhs = hints;
+ }
+
+ /**
+ * Instantiates a new ConvolveOp object with the specified Kernel
+ * and EDGE_ZERO_FILL edge condition.
+ *
+ * @param kernel the specified Kernel.
+ */
+ public ConvolveOp(Kernel kernel) {
+ this.kernel = kernel;
+ this.edgeCond = EDGE_ZERO_FILL;
+ }
+
+ /**
+ * Gets the Kernel object of this ConvolveOp.
+ *
+ * @return the Kernel object of this ConvolveOp.
+ */
+ public final Kernel getKernel() {
+ return (Kernel) kernel.clone();
+ }
+
+ public final RenderingHints getRenderingHints() {
+ return rhs;
+ }
+
+ /**
+ * Gets the edge condition of this ConvolveOp.
+ *
+ * @return the edge condition: EDGE_NO_OP or EDGE_ZERO_FILL.
+ */
+ public int getEdgeCondition() {
+ return edgeCond;
+ }
+
+ public final Rectangle2D getBounds2D(Raster src) {
+ return src.getBounds();
+ }
+
+ public final Rectangle2D getBounds2D(BufferedImage src) {
+ return getBounds2D(src.getRaster());
+ }
+
+ public final Point2D getPoint2D(Point2D srcPt, Point2D dstPt) {
+ if (dstPt == null) {
+ dstPt = new Point2D.Float();
+ }
+
+ dstPt.setLocation(srcPt);
+ return dstPt;
+ }
+
+ public WritableRaster createCompatibleDestRaster(Raster src) {
+ return src.createCompatibleWritableRaster();
+ }
+
+ public BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel dstCM) {
+ if (dstCM == null) {
+ dstCM = src.getColorModel();
+ }
+
+ if (dstCM instanceof IndexColorModel) {
+ dstCM = ColorModel.getRGBdefault();
+ }
+
+ WritableRaster r =
+ dstCM.isCompatibleSampleModel(src.getSampleModel()) ?
+ src.getRaster().createCompatibleWritableRaster(src.getWidth(), src.getHeight()) :
+ dstCM.createCompatibleWritableRaster(src.getWidth(), src.getHeight());
+
+ return new BufferedImage(
+ dstCM,
+ r,
+ dstCM.isAlphaPremultiplied(),
+ null
+ );
+ }
+
+ public final WritableRaster filter(Raster src, WritableRaster dst) {
+ if (src == null) { // Should throw according to spec
+ // awt.256=Source raster is null
+ throw new NullPointerException(Messages.getString("awt.256")); //$NON-NLS-1$
+ }
+
+ if (src == dst){
+ // awt.257=Source raster is equal to destination
+ throw new IllegalArgumentException(Messages.getString("awt.257")); //$NON-NLS-1$
+ }
+
+ if (dst == null) {
+ dst = createCompatibleDestRaster(src);
+ } else if (src.getNumBands() != dst.getNumBands()) {
+ // awt.258=Number of source bands ({0}) is not equal to number of destination bands ({1})
+ throw new IllegalArgumentException(
+ Messages.getString("awt.258", src.getNumBands(), dst.getNumBands())); //$NON-NLS-1$
+ }
+
+ // TODO
+ //if (ippFilter(src, dst, BufferedImage.TYPE_CUSTOM) != 0)
+ if (slowFilter(src, dst) != 0) {
+ // awt.21F=Unable to transform source
+ throw new ImagingOpException (Messages.getString("awt.21F")); //$NON-NLS-1$
+ }
+
+ return dst;
+ }
+
+ /**
+ * Slow filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ *
+ * @return the int
+ */
+ private int slowFilter(Raster src, WritableRaster dst) {
+ try {
+ SampleModel sm = src.getSampleModel();
+
+ int numBands = src.getNumBands();
+ int srcHeight = src.getHeight();
+ int srcWidth = src.getWidth();
+
+ int xOrigin = kernel.getXOrigin();
+ int yOrigin = kernel.getYOrigin();
+ int kWidth = kernel.getWidth();
+ int kHeight = kernel.getHeight();
+ float[] data = kernel.getKernelData(null);
+
+ int srcMinX = src.getMinX();
+ int srcMinY = src.getMinY();
+ int dstMinX = dst.getMinX();
+ int dstMinY = dst.getMinY();
+
+ int srcConvMaxX = srcWidth - (kWidth - xOrigin - 1);
+ int srcConvMaxY = srcHeight - (kHeight - yOrigin - 1);
+
+ int[] maxValues = new int[numBands];
+ int[] masks = new int[numBands];
+ int[] sampleSizes = sm.getSampleSize();
+
+ for (int i=0; i < numBands; i++){
+ maxValues[i] = (1 << sampleSizes[i]) - 1;
+ masks[i] = ~(maxValues[i]);
+ }
+
+ // Processing bounds
+ float[] pixels = null;
+ pixels = src.getPixels(srcMinX, srcMinY, srcWidth, srcHeight, pixels);
+ float[] newPixels = new float[pixels.length];
+ int rowLength = srcWidth*numBands;
+ if (this.edgeCond == ConvolveOp.EDGE_NO_OP){
+ // top
+ int start = 0;
+ int length = yOrigin*rowLength;
+ System.arraycopy(pixels, start, newPixels, start, length);
+ // bottom
+ start = (srcHeight - (kHeight - yOrigin - 1))*rowLength;
+ length = (kHeight - yOrigin - 1)*rowLength;
+ System.arraycopy(pixels, start, newPixels, start, length);
+ // middle
+ length = xOrigin*numBands;
+ int length1 = (kWidth - xOrigin - 1)*numBands;
+ start = yOrigin*rowLength;
+ int start1 = (yOrigin+1)*rowLength - length1;
+ for (int i = yOrigin; i < (srcHeight - (kHeight - yOrigin - 1)); i ++) {
+ System.arraycopy(pixels, start, newPixels, start, length);
+ System.arraycopy(pixels, start1, newPixels, start1, length1);
+ start +=rowLength;
+ start1 +=rowLength;
+ }
+
+ }
+
+ // Cycle over pixels to be calculated
+ for (int i = yOrigin; i < srcConvMaxY; i++){
+ for (int j = xOrigin; j < srcConvMaxX; j++){
+
+ // Take kernel data in backward direction, convolution
+ int kernelIdx = data.length - 1;
+
+ int pixelIndex = i * rowLength + j * numBands;
+ for (int hIdx = 0, rasterHIdx = i - yOrigin;
+ hIdx < kHeight;
+ hIdx++, rasterHIdx++
+ ){
+ for (int wIdx = 0, rasterWIdx = j - xOrigin;
+ wIdx < kWidth;
+ wIdx++, rasterWIdx++
+ ){
+ int curIndex = rasterHIdx * rowLength + rasterWIdx * numBands;
+ for (int idx=0; idx < numBands; idx++){
+ newPixels[pixelIndex+idx] += data[kernelIdx] * pixels[curIndex+idx];
+ }
+ kernelIdx--;
+ }
+ }
+
+ // Check for overflow now
+ for (int idx=0; idx < numBands; idx++){
+ if (((int)newPixels[pixelIndex+idx] & masks[idx]) != 0) {
+ if (newPixels[pixelIndex+idx] < 0) {
+ newPixels[pixelIndex+idx] = 0;
+ } else {
+ newPixels[pixelIndex+idx] = maxValues[idx];
+ }
+ }
+ }
+ }
+ }
+
+ dst.setPixels(dstMinX, dstMinY, srcWidth, srcHeight, newPixels);
+ } catch (Exception e) { // Something goes wrong, signal error
+ return 1;
+ }
+ return 0;
+ }
+
+ public final BufferedImage filter(BufferedImage src, BufferedImage dst) {
+ if (src == null) {
+ // awt.259=Source image is null
+ throw new NullPointerException(Messages.getString("awt.259")); //$NON-NLS-1$
+ }
+
+ if (src == dst){
+ // awt.25A=Source equals to destination
+ throw new IllegalArgumentException(Messages.getString("awt.25A")); //$NON-NLS-1$
+ }
+
+ ColorModel srcCM = src.getColorModel();
+ BufferedImage finalDst = null;
+
+ if (srcCM instanceof IndexColorModel) {
+ src = ((IndexColorModel)srcCM).convertToIntDiscrete(src.getRaster(), true);
+ srcCM = src.getColorModel();
+ }
+
+ if (dst == null) {
+ dst = createCompatibleDestImage(src, srcCM);
+ } else {
+ if (!srcCM.equals(dst.getColorModel())) {
+ // Treat BufferedImage.TYPE_INT_RGB and BufferedImage.TYPE_INT_ARGB as same
+ if (
+ !((src.getType() == BufferedImage.TYPE_INT_RGB ||
+ src.getType() == BufferedImage.TYPE_INT_ARGB) &&
+ (dst.getType() == BufferedImage.TYPE_INT_RGB ||
+ dst.getType() == BufferedImage.TYPE_INT_ARGB))
+ ) {
+ finalDst = dst;
+ dst = createCompatibleDestImage(src, srcCM);
+ }
+ }
+ }
+
+ // Skip alpha channel for TYPE_INT_RGB images
+ // TODO
+ //if (ippFilter(src.getRaster(), dst.getRaster(), src.getType()) != 0)
+ if (slowFilter(src.getRaster(), dst.getRaster()) != 0) {
+ // awt.21F=Unable to transform source
+ throw new ImagingOpException (Messages.getString("awt.21F")); //$NON-NLS-1$
+ }
+
+ if (finalDst != null) {
+ Graphics2D g = finalDst.createGraphics();
+ g.setComposite(AlphaComposite.Src);
+ g.drawImage(dst, 0, 0, null);
+ } else {
+ finalDst = dst;
+ }
+
+ return finalDst;
+ }
+
+ // TODO remove when this method is used
+ /**
+ * Ipp filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ * @param imageType the image type
+ *
+ * @return the int
+ */
+ @SuppressWarnings("unused")
+ private int ippFilter(Raster src, WritableRaster dst, int imageType) {
+ int srcStride, dstStride;
+ boolean skipChannel = false;
+ int channels;
+ int offsets[] = null;
+
+ switch (imageType) {
+ case BufferedImage.TYPE_INT_RGB:
+ case BufferedImage.TYPE_INT_BGR: {
+ channels = 4;
+ srcStride = src.getWidth()*4;
+ dstStride = dst.getWidth()*4;
+ skipChannel = true;
+ break;
+ }
+
+ case BufferedImage.TYPE_INT_ARGB:
+ case BufferedImage.TYPE_INT_ARGB_PRE:
+ case BufferedImage.TYPE_4BYTE_ABGR:
+ case BufferedImage.TYPE_4BYTE_ABGR_PRE: {
+ channels = 4;
+ srcStride = src.getWidth()*4;
+ dstStride = dst.getWidth()*4;
+ break;
+ }
+
+ case BufferedImage.TYPE_BYTE_GRAY: {
+ channels = 1;
+ srcStride = src.getWidth();
+ dstStride = dst.getWidth();
+ break;
+ }
+
+ case BufferedImage.TYPE_3BYTE_BGR: {
+ channels = 3;
+ srcStride = src.getWidth()*3;
+ dstStride = dst.getWidth()*3;
+ break;
+ }
+
+ case BufferedImage.TYPE_USHORT_GRAY: // TODO - could be done in native code?
+ case BufferedImage.TYPE_USHORT_565_RGB:
+ case BufferedImage.TYPE_USHORT_555_RGB:
+ case BufferedImage.TYPE_BYTE_BINARY: {
+ return slowFilter(src, dst);
+ }
+
+ default: {
+ SampleModel srcSM = src.getSampleModel();
+ SampleModel dstSM = dst.getSampleModel();
+
+ if (
+ srcSM instanceof PixelInterleavedSampleModel &&
+ dstSM instanceof PixelInterleavedSampleModel
+ ) {
+ // Check PixelInterleavedSampleModel
+ if (
+ srcSM.getDataType() != DataBuffer.TYPE_BYTE ||
+ dstSM.getDataType() != DataBuffer.TYPE_BYTE
+ ) {
+ return slowFilter(src, dst);
+ }
+
+ channels = srcSM.getNumBands(); // Have IPP functions for 1, 3 and 4 channels
+ if (!(channels == 1 || channels == 3 || channels == 4)) {
+ return slowFilter(src, dst);
+ }
+
+ srcStride = ((ComponentSampleModel) srcSM).getScanlineStride();
+ dstStride = ((ComponentSampleModel) dstSM).getScanlineStride();
+ } else if (
+ srcSM instanceof SinglePixelPackedSampleModel &&
+ dstSM instanceof SinglePixelPackedSampleModel
+ ) {
+ // Check SinglePixelPackedSampleModel
+ SinglePixelPackedSampleModel sppsm1 = (SinglePixelPackedSampleModel) srcSM;
+ SinglePixelPackedSampleModel sppsm2 = (SinglePixelPackedSampleModel) dstSM;
+
+ channels = sppsm1.getNumBands();
+
+ // TYPE_INT_RGB, TYPE_INT_ARGB...
+ if (
+ sppsm1.getDataType() != DataBuffer.TYPE_INT ||
+ sppsm2.getDataType() != DataBuffer.TYPE_INT ||
+ !(channels == 3 || channels == 4)
+ ) {
+ return slowFilter(src, dst);
+ }
+
+ // Check compatibility of sample models
+ if (
+ !Arrays.equals(sppsm1.getBitOffsets(), sppsm2.getBitOffsets()) ||
+ !Arrays.equals(sppsm1.getBitMasks(), sppsm2.getBitMasks())
+ ) {
+ return slowFilter(src, dst);
+ }
+
+ for (int i=0; i<channels; i++) {
+ if (sppsm1.getSampleSize(i) != 8) {
+ return slowFilter(src, dst);
+ }
+ }
+
+ if (channels == 3) { // Cannot skip channel, don't know which is alpha...
+ channels = 4;
+ }
+
+ srcStride = sppsm1.getScanlineStride() * 4;
+ dstStride = sppsm2.getScanlineStride() * 4;
+ } else {
+ return slowFilter(src, dst);
+ }
+
+ // Fill offsets if there's a child raster
+ if (src.getParent() != null || dst.getParent() != null) {
+ if (
+ src.getSampleModelTranslateX() != 0 ||
+ src.getSampleModelTranslateY() != 0 ||
+ dst.getSampleModelTranslateX() != 0 ||
+ dst.getSampleModelTranslateY() != 0
+ ) {
+ offsets = new int[4];
+ offsets[0] = -src.getSampleModelTranslateX() + src.getMinX();
+ offsets[1] = -src.getSampleModelTranslateY() + src.getMinY();
+ offsets[2] = -dst.getSampleModelTranslateX() + dst.getMinX();
+ offsets[3] = -dst.getSampleModelTranslateY() + dst.getMinY();
+ }
+ }
+ }
+ }
+
+ Object srcData, dstData;
+ AwtImageBackdoorAccessor dbAccess = AwtImageBackdoorAccessor.getInstance();
+ try {
+ srcData = dbAccess.getData(src.getDataBuffer());
+ dstData = dbAccess.getData(dst.getDataBuffer());
+ } catch (IllegalArgumentException e) {
+ return -1; // Unknown data buffer type
+ }
+
+ return ippFilter32f(
+ kernel.data, kernel.getWidth(), kernel.getHeight(),
+ kernel.getXOrigin(), kernel.getYOrigin(), edgeCond,
+ srcData, src.getWidth(), src.getHeight(), srcStride,
+ dstData, dst.getWidth(), dst.getHeight(), dstStride,
+ channels, skipChannel, offsets
+ );
+ }
+
+ /**
+ * Ipp filter32f.
+ *
+ * @param kernel the kernel
+ * @param kWidth the k width
+ * @param kHeight the k height
+ * @param anchorX the anchor x
+ * @param anchorY the anchor y
+ * @param borderType the border type
+ * @param src the src
+ * @param srcWidth the src width
+ * @param srcHeight the src height
+ * @param srcStride the src stride
+ * @param dst the dst
+ * @param dstWidth the dst width
+ * @param dstHeight the dst height
+ * @param dstStride the dst stride
+ * @param channels the channels
+ * @param skipChannel the skip channel
+ * @param offsets the offsets
+ *
+ * @return the int
+ */
+ private native int ippFilter32f(
+ float kernel[], int kWidth, int kHeight,
+ int anchorX, int anchorY, int borderType,
+ Object src, int srcWidth, int srcHeight, int srcStride,
+ Object dst, int dstWidth, int dstHeight, int dstStride,
+ int channels, boolean skipChannel, int offsets[]
+ );
+}
+
diff --git a/awt/java/awt/image/CropImageFilter.java b/awt/java/awt/image/CropImageFilter.java
new file mode 100644
index 0000000..e90c44a
--- /dev/null
+++ b/awt/java/awt/image/CropImageFilter.java
@@ -0,0 +1,193 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.util.Hashtable;
+
+/**
+ * The CropImageFilter class crops a rectangular region of an source
+ * Image and provides a source for a new image containing the extracted
+ * region.
+ */
+public class CropImageFilter extends ImageFilter {
+
+ /** The HEIGHT. */
+ private final int X, Y, WIDTH, HEIGHT;
+
+ /**
+ * Instantiates a new CropImageFilter object with the specified
+ * rectangular area.
+ *
+ * @param x the X coordinate of rectangular area.
+ * @param y the Y coordinate of rectangular area.
+ * @param w the width of rectangular area.
+ * @param h the height of rectangular area.
+ */
+ public CropImageFilter(int x, int y, int w, int h) {
+ X = x;
+ Y = y;
+ WIDTH = w;
+ HEIGHT = h;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public void setProperties(Hashtable<?, ?> props) {
+ Hashtable<Object, Object> fprops;
+ if(props == null) {
+ fprops = new Hashtable<Object, Object>();
+ } else {
+ fprops = (Hashtable<Object, Object>) props.clone();
+ }
+ String propName = "Crop Filters"; //$NON-NLS-1$
+ String prop = "x=" + X + "; y=" + Y + "; width=" + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ WIDTH + "; height=" + HEIGHT; //$NON-NLS-1$
+ Object o = fprops.get(propName);
+ if(o != null){
+ if(o instanceof String){
+ prop = (String)o + "; " + prop; //$NON-NLS-1$
+ }else{
+ prop = o.toString() + "; " + prop; //$NON-NLS-1$
+ }
+ }
+ fprops.put(propName, prop);
+ consumer.setProperties(fprops);
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h, ColorModel model, int[] pixels, int off, int scansize) {
+
+ if(x + w < X || X + WIDTH < x ||
+ y + h < Y || Y + HEIGHT < y) {
+ return;
+ }
+
+ int destX, destY, destWidth, destHeight, endX, endY,
+ srcEndX, srcEndY;
+
+ int newOffset = off;
+
+ endX = X + WIDTH;
+ endY = Y + HEIGHT;
+
+ srcEndX = x + w;
+ srcEndY = y + h;
+
+ if(x <= X){
+ destX = 0;
+ newOffset += X;
+ if(endX >= srcEndX){
+ destWidth = srcEndX - X;
+ }else{
+ destWidth = WIDTH;
+ }
+ }else{
+ destX = x - X;
+ if(endX >= srcEndX){
+ destWidth = w;
+ }else{
+ destWidth = endX - x;
+ }
+ }
+
+
+ if(y <= Y){
+ newOffset += scansize * (Y - y);
+ destY = 0;
+ if(endY >= srcEndY){
+ destHeight = srcEndY - Y;
+ }else{
+ destHeight = HEIGHT;
+ }
+ }else{
+ destY = y - Y;
+ if(endY >= srcEndY){
+ destHeight = h;
+ }else{
+ destHeight = endY - y;
+ }
+ }
+ consumer.setPixels(destX, destY, destWidth, destHeight, model, pixels, newOffset, scansize);
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h, ColorModel model, byte[] pixels, int off, int scansize) {
+
+ if(x + w < X || X + WIDTH < x ||
+ y + h < Y || Y + HEIGHT < y) {
+ return;
+ }
+
+ int destX, destY, destWidth, destHeight, endX, endY,
+ srcEndX, srcEndY;
+
+ int newOffset = off;
+
+ endX = X + WIDTH;
+ endY = Y + HEIGHT;
+
+ srcEndX = x + w;
+ srcEndY = y + h;
+
+ if(x <= X){
+ destX = 0;
+ newOffset += X;
+ if(endX >= srcEndX){
+ destWidth = srcEndX - X;
+ }else{
+ destWidth = WIDTH;
+ }
+ }else{
+ destX = x - X;
+ if(endX >= srcEndX){
+ destWidth = w;
+ }else{
+ destWidth = endX - x;
+ }
+ }
+
+
+ if(y <= Y){
+ newOffset += scansize * (Y - y);
+ destY = 0;
+ if(endY >= srcEndY){
+ destHeight = srcEndY - Y;
+ }else{
+ destHeight = HEIGHT;
+ }
+ }else{
+ destY = y - Y;
+ if(endY >= srcEndY){
+ destHeight = h;
+ }else{
+ destHeight = endY - y;
+ }
+ }
+ consumer.setPixels(destX, destY, destWidth, destHeight, model, pixels, newOffset, scansize);
+ }
+
+ @Override
+ public void setDimensions(int w, int h) {
+ consumer.setDimensions(WIDTH, HEIGHT);
+ }
+
+}
+
diff --git a/awt/java/awt/image/DataBuffer.java b/awt/java/awt/image/DataBuffer.java
new file mode 100644
index 0000000..6856aee
--- /dev/null
+++ b/awt/java/awt/image/DataBuffer.java
@@ -0,0 +1,442 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import org.apache.harmony.awt.gl.image.DataBufferListener;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class DataBuffer is a wrapper class for a data array
+ * to be used for the situation where a suite of functionality
+ * acts on a set of data in a consistent way even though the
+ * primitive type of the data may vary from one use to the next.
+ */
+public abstract class DataBuffer {
+
+ /** The Constant TYPE_BYTE. */
+ public static final int TYPE_BYTE = 0;
+
+ /** The Constant TYPE_USHORT. */
+ public static final int TYPE_USHORT = 1;
+
+ /** The Constant TYPE_SHORT. */
+ public static final int TYPE_SHORT = 2;
+
+ /** The Constant TYPE_INT. */
+ public static final int TYPE_INT = 3;
+
+ /** The Constant TYPE_FLOAT. */
+ public static final int TYPE_FLOAT = 4;
+
+ /** The Constant TYPE_DOUBLE. */
+ public static final int TYPE_DOUBLE = 5;
+
+ /** The Constant TYPE_UNDEFINED. */
+ public static final int TYPE_UNDEFINED = 32;
+
+ /** The data type indicates the primitive type of the
+ * data in this DataBuffer. */
+ protected int dataType;
+
+ /** The number of data arrays in this DataBuffer. */
+ protected int banks;
+
+ /** The starting index for reading the
+ * data from the first (or only) internal data array. */
+ protected int offset;
+
+ /** The length (number of elements) of the data arrays. */
+ protected int size;
+
+ /** The starting indices for reading the
+ * data from the internal data arrays. */
+ protected int offsets[];
+
+ /** The data changed. */
+ boolean dataChanged = true;
+
+ /** The data taken. */
+ boolean dataTaken = false;
+
+ /** The listener. */
+ DataBufferListener listener;
+
+ static {
+ AwtImageBackdoorAccessorImpl.init();
+ }
+
+ /**
+ * Instantiates a new data buffer.
+ *
+ * @param dataType the data type
+ * @param size the length (number of elements) of the data arrays
+ * @param numBanks the number of data arrays to create
+ * @param offsets the starting indices for reading the
+ * data from the internal data arrays
+ */
+ protected DataBuffer(int dataType, int size, int numBanks, int[] offsets) {
+ this.dataType = dataType;
+ this.size = size;
+ this.banks = numBanks;
+ this.offsets = offsets.clone();
+ this.offset = offsets[0];
+ }
+
+ /**
+ * Instantiates a new data buffer with all of the
+ * data arrays starting at the same index.
+ *
+ * @param dataType the data type
+ * @param size the length (number of elements) of the data arrays
+ * @param numBanks the number of data arrays to create
+ * @param offset the offset to use for all of the data arrays
+ */
+ protected DataBuffer(int dataType, int size, int numBanks, int offset) {
+ this.dataType = dataType;
+ this.size = size;
+ this.banks = numBanks;
+ this.offset = offset;
+ this.offsets = new int[numBanks];
+ int i = 0;
+ while (i < numBanks) {
+ offsets[i++] = offset;
+ }
+ }
+
+ /**
+ * Instantiates a new data buffer with all of the
+ * data arrays read from the beginning (at offset zero).
+ *
+ * @param dataType the data type
+ * @param size the length (number of elements) of the data arrays
+ * @param numBanks the number of data arrays to create
+ */
+ protected DataBuffer(int dataType, int size, int numBanks) {
+ this.dataType = dataType;
+ this.size = size;
+ this.banks = numBanks;
+ this.offset = 0;
+ this.offsets = new int[numBanks];
+ }
+
+ /**
+ * Instantiates a new data buffer with one internal data array
+ * read from the beginning (at offset zero).
+ *
+ * @param dataType the data type
+ * @param size the length (number of elements) of the data arrays
+ */
+ protected DataBuffer(int dataType, int size) {
+ this.dataType = dataType;
+ this.size = size;
+ this.banks = 1;
+ this.offset = 0;
+ this.offsets = new int[1];
+ }
+
+ /**
+ * Sets the data value in the specified array at the
+ * specified index.
+ *
+ * @param bank the internal array to the data to
+ * @param i the index within the array where the data
+ * should be written
+ * @param val the value to write into the array
+ */
+ public abstract void setElem(int bank, int i, int val);
+
+ /**
+ * Sets the float data value in the specified array at the
+ * specified index.
+ *
+ * @param bank the internal array to the data to
+ * @param i the index within the array where the data
+ * should be written
+ * @param val the value to write into the array
+ */
+ public void setElemFloat(int bank, int i, float val) {
+ setElem(bank, i, (int) val);
+ }
+
+ /**
+ * Sets the double data value in the specified array at the
+ * specified index.
+ *
+ * @param bank the internal array to the data to
+ * @param i the index within the array where the data
+ * should be written
+ * @param val the value to write into the array
+ */
+ public void setElemDouble(int bank, int i, double val) {
+ setElem(bank, i, (int) val);
+ }
+
+ /**
+ * Sets the data value in the first array at the
+ * specified index.
+ *
+ * @param i the index within the array where the data
+ * should be written
+ * @param val the value to write into the array
+ */
+ public void setElem(int i, int val) {
+ setElem(0, i, val);
+ }
+
+ /**
+ * Gets the data value from the specified data array at the
+ * specified index.
+ *
+ * @param bank the data array to read from
+ * @param i the index within the array where the data
+ * should be read
+ *
+ * @return the data element
+ */
+ public abstract int getElem(int bank, int i);
+
+ /**
+ * Gets the float-type data value from the specified
+ * data array at the specified index.
+ *
+ * @param bank the data array to read from
+ * @param i the index within the array where the data
+ * should be read
+ *
+ * @return the data element
+ */
+ public float getElemFloat(int bank, int i) {
+ return getElem(bank, i);
+ }
+
+ /**
+ * Gets the double-type data value from the specified
+ * data array at the specified index.
+ *
+ * @param bank the data array to read from
+ * @param i the index within the array where the data
+ * should be read
+ *
+ * @return the data element
+ */
+ public double getElemDouble(int bank, int i) {
+ return getElem(bank, i);
+ }
+
+ /**
+ * Sets the float data value in the first array at the
+ * specified index.
+ *
+ * @param i the index within the array where the data
+ * should be written
+ * @param val the value to write into the array
+ */
+ public void setElemFloat(int i, float val) {
+ setElemFloat(0, i, val);
+ }
+
+ /**
+ * Sets the double data value in the first array at the
+ * specified index.
+ *
+ * @param i the index within the array where the data
+ * should be written
+ * @param val the value to write into the array
+ */
+ public void setElemDouble(int i, double val) {
+ setElemDouble(0, i, val);
+ }
+
+ /**
+ * Gets the data value from the first
+ * data array at the specified index and returns it
+ * as an int.
+ *
+ * @param i the index within the array where the data
+ * should be read
+ *
+ * @return the data element
+ */
+ public int getElem(int i) {
+ return getElem(0, i);
+ }
+
+ /**
+ * Gets the data value from the first
+ * data array at the specified index and returns it
+ * as a float.
+ *
+ * @param i the index within the array where the data
+ * should be read
+ *
+ * @return the data element
+ */
+ public float getElemFloat(int i) {
+ return getElem(0, i);
+ }
+
+ /**
+ * Gets the data value from the first
+ * data array at the specified index and returns it
+ * as a double.
+ *
+ * @param i the index within the array where the data
+ * should be read
+ *
+ * @return the data element
+ */
+ public double getElemDouble(int i) {
+ return getElem(i);
+ }
+
+ /**
+ * Gets the array giving the offsets corresponding
+ * to the internal data arrays.
+ *
+ * @return the array of offsets
+ */
+ public int[] getOffsets() {
+ return offsets;
+ }
+
+ /**
+ * Gets the size in bits of the primitive data type.
+ *
+ * @return the size in bits of the primitive data type
+
+ */
+ public int getSize() {
+ return size;
+ }
+
+ /**
+ * Gets the offset corresponding to the first internal
+ * data array.
+ *
+ * @return the offset
+ */
+ public int getOffset() {
+ return offset;
+ }
+
+ /**
+ * Gets the number of data arrays in this DataBuffer.
+ *
+ * @return the number of data arrays
+ */
+ public int getNumBanks() {
+ return banks;
+ }
+
+ /**
+ * Gets the primitive type of this buffer's data.
+ *
+ * @return the data type
+ */
+ public int getDataType() {
+ return this.dataType;
+ }
+
+ /**
+ * Gets the size in bits of the primitive data type.
+ *
+ * @param type the primitive type
+ *
+ * @return the size in bits of the primitive data type
+ */
+ public static int getDataTypeSize(int type) {
+ switch (type) {
+
+ case TYPE_BYTE:
+ return 8;
+
+ case TYPE_USHORT:
+ case TYPE_SHORT:
+ return 16;
+
+ case TYPE_INT:
+ case TYPE_FLOAT:
+ return 32;
+
+ case TYPE_DOUBLE:
+ return 64;
+
+ default:
+ // awt.22C=Unknown data type {0}
+ throw new IllegalArgumentException(Messages.getString("awt.22C", type)); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Notifies the listener that the data has changed.
+ */
+ void notifyChanged(){
+ if(listener != null && !dataChanged){
+ dataChanged = true;
+ listener.dataChanged();
+ }
+ }
+
+ /**
+ * Notifies the listener that the data has been released.
+ */
+ void notifyTaken(){
+ if(listener != null && !dataTaken){
+ dataTaken = true;
+ listener.dataTaken();
+ }
+ }
+
+ /**
+ * Release the data.
+ */
+ void releaseData(){
+ if(listener != null && dataTaken){
+ dataTaken = false;
+ listener.dataReleased();
+ }
+ }
+
+ /**
+ * Adds the data buffer listener.
+ *
+ * @param listener the listener
+ */
+ void addDataBufferListener(DataBufferListener listener){
+ this.listener = listener;
+ }
+
+ /**
+ * Removes the data buffer listener.
+ */
+ void removeDataBufferListener(){
+ listener = null;
+ }
+
+ /**
+ * Validate.
+ */
+ void validate(){
+ dataChanged = false;
+ }
+
+}
+
diff --git a/awt/java/awt/image/DataBufferByte.java b/awt/java/awt/image/DataBufferByte.java
new file mode 100644
index 0000000..4d29c9c
--- /dev/null
+++ b/awt/java/awt/image/DataBufferByte.java
@@ -0,0 +1,171 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+/**
+ * The Class DataBufferByte is the subclass of DataBuffer
+ * for the case where the underlying data is of type byte.
+ */
+public final class DataBufferByte extends DataBuffer {
+
+ /** The data. */
+ byte data[][];
+
+ /**
+ * Instantiates a new data buffer of type unsigned short.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param offsets the starting indices for reading the
+ * data from the internal data arrays
+ */
+ public DataBufferByte(byte dataArrays[][], int size, int offsets[]) {
+ super(TYPE_BYTE, size, dataArrays.length, offsets);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type unsigned short.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ */
+ public DataBufferByte(byte dataArrays[][], int size) {
+ super(TYPE_BYTE, size, dataArrays.length);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type unsigned short
+ * with a single underlying array of data.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ * @param offset the starting index to use when reading the data
+ */
+ public DataBufferByte(byte dataArray[], int size, int offset) {
+ super(TYPE_BYTE, size, 1, offset);
+ data = new byte[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new data buffer of type unsigned short
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferByte(byte dataArray[], int size) {
+ super(TYPE_BYTE, size);
+ data = new byte[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type unsigned short
+ * with offsets equal to zero.
+ *
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param numBanks the number of data arrays to create
+ */
+ public DataBufferByte(int size, int numBanks) {
+ super(TYPE_BYTE, size, numBanks);
+ data = new byte[numBanks][];
+ int i = 0;
+ while (i < numBanks) {
+ data[i++] = new byte[size];
+ }
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type unsigned short
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferByte(int size) {
+ super(TYPE_BYTE, size);
+ data = new byte[1][];
+ data[0] = new byte[size];
+ }
+
+ @Override
+ public void setElem(int bank, int i, int val) {
+ data[bank][offsets[bank] + i] = (byte) val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElem(int i, int val) {
+ data[0][offset + i] = (byte) val;
+ notifyChanged();
+ }
+
+ @Override
+ public int getElem(int bank, int i) {
+ return (data[bank][offsets[bank] + i]) & 0xff;
+ }
+
+ /**
+ * Gets the data of the specified internal data array.
+ *
+ * @param bank the index of the desired data array
+ *
+ * @return the data
+ */
+ public byte[] getData(int bank) {
+ notifyTaken();
+ return data[bank];
+ }
+
+ @Override
+ public int getElem(int i) {
+ return (data[0][offset + i]) & 0xff;
+ }
+
+ /**
+ * Gets the bank data.
+ *
+ * @return the bank data
+ */
+ public byte[][] getBankData() {
+ notifyTaken();
+ return data.clone();
+ }
+
+ /**
+ * Gets the data of the first data array.
+ *
+ * @return the data
+ */
+ public byte[] getData() {
+ notifyTaken();
+ return data[0];
+ }
+
+}
+
diff --git a/awt/java/awt/image/DataBufferDouble.java b/awt/java/awt/image/DataBufferDouble.java
new file mode 100644
index 0000000..fa3d324
--- /dev/null
+++ b/awt/java/awt/image/DataBufferDouble.java
@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+/**
+ * The Class DataBufferDouble is the subclass of DataBuffer
+ * for the case where the underlying data is of type double.
+ */
+public final class DataBufferDouble extends DataBuffer {
+
+ /** The data. */
+ double data[][];
+
+ /**
+ * Instantiates a new data buffer of type double.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param offsets the starting indices for reading the
+ * data from the internal data arrays
+ */
+ public DataBufferDouble(double dataArrays[][], int size, int offsets[]) {
+ super(TYPE_DOUBLE, size, dataArrays.length, offsets);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type double.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ */
+ public DataBufferDouble(double dataArrays[][], int size) {
+ super(TYPE_DOUBLE, size, dataArrays.length);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type double
+ * with a single underlying array of data.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ * @param offset the starting index to use when reading the data
+ */
+ public DataBufferDouble(double dataArray[], int size, int offset) {
+ super(TYPE_DOUBLE, size, 1, offset);
+ data = new double[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new data buffer of type double
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferDouble(double dataArray[], int size) {
+ super(TYPE_DOUBLE, size);
+ data = new double[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type double
+ * with offsets equal to zero.
+ *
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param numBanks the number of data arrays to create
+ */
+ public DataBufferDouble(int size, int numBanks) {
+ super(TYPE_DOUBLE, size, numBanks);
+ data = new double[numBanks][];
+ int i = 0;
+ while (i < numBanks) {
+ data[i++] = new double[size];
+ }
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type double
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferDouble(int size) {
+ super(TYPE_DOUBLE, size);
+ data = new double[1][];
+ data[0] = new double[size];
+ }
+
+ @Override
+ public void setElem(int bank, int i, int val) {
+ data[bank][offsets[bank] + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElemFloat(int bank, int i, float val) {
+ data[bank][offsets[bank] + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElemDouble(int bank, int i, double val) {
+ data[bank][offsets[bank] + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElem(int i, int val) {
+ data[0][offset + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public int getElem(int bank, int i) {
+ return (int) (data[bank][offsets[bank] + i]);
+ }
+
+ @Override
+ public float getElemFloat(int bank, int i) {
+ return (float) (data[bank][offsets[bank] + i]);
+ }
+
+ @Override
+ public double getElemDouble(int bank, int i) {
+ return data[bank][offsets[bank] + i];
+ }
+
+ @Override
+ public void setElemFloat(int i, float val) {
+ data[0][offset + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElemDouble(int i, double val) {
+ data[0][offset + i] = val;
+ notifyChanged();
+ }
+
+ /**
+ * Gets the data of the specified internal data array.
+ *
+ * @param bank the index of the desired data array
+ *
+ * @return the data
+ */
+ public double[] getData(int bank) {
+ notifyTaken();
+ return data[bank];
+ }
+
+ @Override
+ public int getElem(int i) {
+ return (int) (data[0][offset + i]);
+ }
+
+ @Override
+ public float getElemFloat(int i) {
+ return (float) (data[0][offset + i]);
+ }
+
+ @Override
+ public double getElemDouble(int i) {
+ return data[0][offset + i];
+ }
+
+ /**
+ * Gets the bank data.
+ *
+ * @return the bank data
+ */
+ public double[][] getBankData() {
+ notifyTaken();
+ return data.clone();
+ }
+
+ /**
+ * Gets the data of the first data array.
+ *
+ * @return the data
+ */
+ public double[] getData() {
+ notifyTaken();
+ return data[0];
+ }
+}
+
diff --git a/awt/java/awt/image/DataBufferFloat.java b/awt/java/awt/image/DataBufferFloat.java
new file mode 100644
index 0000000..e34245c
--- /dev/null
+++ b/awt/java/awt/image/DataBufferFloat.java
@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+/**
+ * The Class DataBufferFloat is the subclass of DataBuffer
+ * for the case where the underlying data is float.
+ */
+public final class DataBufferFloat extends DataBuffer {
+
+ /** The data. */
+ float data[][];
+
+ /**
+ * Instantiates a new data buffer of type float.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param offsets the starting indices for reading the
+ * data from the internal data arrays
+ */
+ public DataBufferFloat(float dataArrays[][], int size, int offsets[]) {
+ super(TYPE_FLOAT, size, dataArrays.length, offsets);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type float.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ */
+ public DataBufferFloat(float dataArrays[][], int size) {
+ super(TYPE_FLOAT, size, dataArrays.length);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type float
+ * with a single underlying array of data.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ * @param offset the starting index to use when reading the data
+ */
+ public DataBufferFloat(float dataArray[], int size, int offset) {
+ super(TYPE_FLOAT, size, 1, offset);
+ data = new float[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new data buffer of type float
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferFloat(float dataArray[], int size) {
+ super(TYPE_FLOAT, size);
+ data = new float[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type float
+ * with offsets equal to zero.
+ *
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param numBanks the number of data arrays to create
+ */
+ public DataBufferFloat(int size, int numBanks) {
+ super(TYPE_FLOAT, size, numBanks);
+ data = new float[numBanks][];
+ int i = 0;
+ while (i < numBanks) {
+ data[i++] = new float[size];
+ }
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type float
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferFloat(int size) {
+ super(TYPE_FLOAT, size);
+ data = new float[1][];
+ data[0] = new float[size];
+ }
+
+ @Override
+ public void setElem(int bank, int i, int val) {
+ data[bank][offsets[bank] + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElemFloat(int bank, int i, float val) {
+ data[bank][offsets[bank] + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElemDouble(int bank, int i, double val) {
+ data[bank][offsets[bank] + i] = (float) val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElem(int i, int val) {
+ data[0][offset + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public int getElem(int bank, int i) {
+ return (int) (data[bank][offsets[bank] + i]);
+ }
+
+ @Override
+ public float getElemFloat(int bank, int i) {
+ return data[bank][offsets[bank] + i];
+ }
+
+ @Override
+ public double getElemDouble(int bank, int i) {
+ return data[bank][offsets[bank] + i];
+ }
+
+ @Override
+ public void setElemFloat(int i, float val) {
+ data[0][offset + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElemDouble(int i, double val) {
+ data[0][offset + i] = (float) val;
+ notifyChanged();
+ }
+
+ /**
+ * Gets the data of the specified internal data array.
+ *
+ * @param bank the index of the desired array
+ *
+ * @return the data
+ */
+ public float[] getData(int bank) {
+ notifyTaken();
+ return data[bank];
+ }
+
+ @Override
+ public int getElem(int i) {
+ return (int) (data[0][offset + i]);
+ }
+
+ @Override
+ public float getElemFloat(int i) {
+ return data[0][offset + i];
+ }
+
+ @Override
+ public double getElemDouble(int i) {
+ return data[0][offset + i];
+ }
+
+ /**
+ * Gets the bank data.
+ *
+ * @return the bank data
+ */
+ public float[][] getBankData() {
+ notifyTaken();
+ return data.clone();
+ }
+
+ /**
+ * Gets the data of the first data array.
+ *
+ * @return the data
+ */
+ public float[] getData() {
+ notifyTaken();
+ return data[0];
+ }
+}
+
diff --git a/awt/java/awt/image/DataBufferInt.java b/awt/java/awt/image/DataBufferInt.java
new file mode 100644
index 0000000..43dc188
--- /dev/null
+++ b/awt/java/awt/image/DataBufferInt.java
@@ -0,0 +1,170 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+/**
+ * The Class DataBufferInt is the subclass of DataBuffer
+ * for the case where the underlying data is of type int.
+ */
+public final class DataBufferInt extends DataBuffer {
+
+ /** The data. */
+ int data[][];
+
+ /**
+ * Instantiates a new data buffer of type int.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param offsets the starting indices for reading the
+ * data from the internal data arrays
+ */
+ public DataBufferInt(int dataArrays[][], int size, int offsets[]) {
+ super(TYPE_INT, size, dataArrays.length, offsets);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type int.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ */
+ public DataBufferInt(int dataArrays[][], int size) {
+ super(TYPE_INT, size, dataArrays.length);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type int
+ * with a single underlying array of data.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ * @param offset the starting index to use when reading the data
+ */
+ public DataBufferInt(int dataArray[], int size, int offset) {
+ super(TYPE_INT, size, 1, offset);
+ data = new int[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new data buffer of type int
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferInt(int dataArray[], int size) {
+ super(TYPE_INT, size);
+ data = new int[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type int
+ * with offsets equal to zero.
+ *
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param numBanks the number of data arrays to create
+ */
+ public DataBufferInt(int size, int numBanks) {
+ super(TYPE_INT, size, numBanks);
+ data = new int[numBanks][];
+ int i = 0;
+ while (i < numBanks) {
+ data[i++] = new int[size];
+ }
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type int
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferInt(int size) {
+ super(TYPE_INT, size);
+ data = new int[1][];
+ data[0] = new int[size];
+ }
+
+ @Override
+ public void setElem(int bank, int i, int val) {
+ data[bank][offsets[bank] + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElem(int i, int val) {
+ data[0][offset + i] = val;
+ notifyChanged();
+ }
+
+ @Override
+ public int getElem(int bank, int i) {
+ return data[bank][offsets[bank] + i];
+ }
+
+ /**
+ * Gets the data of the specified internal data array.
+ *
+ * @param bank the index of the desired data array
+ *
+ * @return the data
+ */
+ public int[] getData(int bank) {
+ notifyTaken();
+ return data[bank];
+ }
+
+ @Override
+ public int getElem(int i) {
+ return data[0][offset + i];
+ }
+
+ /**
+ * Gets the bank data.
+ *
+ * @return the bank data
+ */
+ public int[][] getBankData() {
+ notifyTaken();
+ return data.clone();
+ }
+
+ /**
+ * Gets the data of the first data array.
+ *
+ * @return the data
+ */
+ public int[] getData() {
+ notifyTaken();
+ return data[0];
+ }
+}
+
diff --git a/awt/java/awt/image/DataBufferShort.java b/awt/java/awt/image/DataBufferShort.java
new file mode 100644
index 0000000..819ba4a
--- /dev/null
+++ b/awt/java/awt/image/DataBufferShort.java
@@ -0,0 +1,172 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+/**
+ * The Class DataBufferShort is the subclass of DataBuffer
+ * for the case where the underlying data is short.
+ */
+public final class DataBufferShort extends DataBuffer {
+
+ /** The data. */
+ short data[][];
+
+ /**
+ * Instantiates a new data buffer of type short.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param offsets the starting indices for reading the
+ * data from the internal data arrays
+ */
+ public DataBufferShort(short dataArrays[][], int size, int offsets[]) {
+ super(TYPE_SHORT, size, dataArrays.length, offsets);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type short.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ */
+ public DataBufferShort(short dataArrays[][], int size) {
+ super(TYPE_SHORT, size, dataArrays.length);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type short
+ * with a single underlying array of data.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ * @param offset the starting index to use when reading the data
+
+ */
+ public DataBufferShort(short dataArray[], int size, int offset) {
+ super(TYPE_SHORT, size, 1, offset);
+ data = new short[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new data buffer of type short
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+
+ */
+ public DataBufferShort(short dataArray[], int size) {
+ super(TYPE_SHORT, size);
+ data = new short[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new data buffer of type short
+ * with offsets equal to zero.
+ *
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param numBanks the number of data arrays to create
+ */
+ public DataBufferShort(int size, int numBanks) {
+ super(TYPE_SHORT, size, numBanks);
+ data = new short[numBanks][];
+ int i = 0;
+ while (i < numBanks) {
+ data[i++] = new short[size];
+ }
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type short
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferShort(int size) {
+ super(TYPE_SHORT, size);
+ data = new short[1][];
+ data[0] = new short[size];
+ }
+
+ @Override
+ public void setElem(int bank, int i, int val) {
+ data[bank][offsets[bank] + i] = (short) val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElem(int i, int val) {
+ data[0][offset + i] = (short) val;
+ notifyChanged();
+ }
+
+ @Override
+ public int getElem(int bank, int i) {
+ return (data[bank][offsets[bank] + i]);
+ }
+
+ /**
+ * Gets the data of the specified internal data array.
+ *
+ * @param bank the index of the desired data array
+ *
+ * @return the data
+ */
+ public short[] getData(int bank) {
+ notifyTaken();
+ return data[bank];
+ }
+
+ @Override
+ public int getElem(int i) {
+ return (data[0][offset + i]);
+ }
+
+ /**
+ * Gets the bank data.
+ *
+ * @return the bank data
+ */
+ public short[][] getBankData() {
+ notifyTaken();
+ return data.clone();
+ }
+
+ /**
+ * Gets the data of the first data array.
+ *
+ * @return the data
+ */
+ public short[] getData() {
+ notifyTaken();
+ return data[0];
+ }
+}
+
diff --git a/awt/java/awt/image/DataBufferUShort.java b/awt/java/awt/image/DataBufferUShort.java
new file mode 100644
index 0000000..7982678
--- /dev/null
+++ b/awt/java/awt/image/DataBufferUShort.java
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class DataBufferUShort is the subclass of DataBuffer
+ * for the case where the underlying data is unsigned short.
+ */
+public final class DataBufferUShort extends DataBuffer {
+
+ /** The data. */
+ short data[][];
+
+ /**
+ * Instantiates a new data buffer of type unsigned short.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param offsets the starting indices for reading the
+ * data from the internal data arrays
+ */
+ public DataBufferUShort(short dataArrays[][], int size, int offsets[]) {
+ super(TYPE_USHORT, size, dataArrays.length, offsets);
+ for(int i = 0; i < dataArrays.length; i++){
+ if(dataArrays[i].length < offsets[i] + size){
+ // awt.28d=Length of dataArray[{0}] is less than size + offset[{1}]
+ throw new IllegalArgumentException(Messages.getString("awt.28D", i, i)); //$NON-NLS-1$
+ }
+ }
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type unsigned short.
+ *
+ * @param dataArrays the data arrays to copy the data from
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ */
+ public DataBufferUShort(short dataArrays[][], int size) {
+ super(TYPE_USHORT, size, dataArrays.length);
+ data = dataArrays.clone();
+ }
+
+ /**
+ * Instantiates a new data buffer of type unsigned short
+ * with a single underlying array of data.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ * @param offset the starting index to use when reading the data
+ */
+ public DataBufferUShort(short dataArray[], int size, int offset) {
+ super(TYPE_USHORT, size, 1, offset);
+ if(dataArray.length < size + offset){
+ // awt.28E=Length of dataArray is less than size + offset
+ throw new IllegalArgumentException(Messages.getString("awt.28E")); //$NON-NLS-1$
+ }
+ data = new short[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new data buffer of type unsigned short
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param dataArray the data array to copy the data from
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferUShort(short dataArray[], int size) {
+ super(TYPE_USHORT, size);
+ data = new short[1][];
+ data[0] = dataArray;
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type unsigned short
+ * with offsets equal to zero.
+ *
+ * @param size the length (number of elements) to use
+ * from the data arrays
+ * @param numBanks the number of data arrays to create
+ */
+ public DataBufferUShort(int size, int numBanks) {
+ super(TYPE_USHORT, size, numBanks);
+ data = new short[numBanks][];
+ int i= 0;
+ while( i < numBanks) {
+ data[i++] = new short[size];
+ }
+ }
+
+ /**
+ * Instantiates a new empty data buffer of type unsigned short
+ * with a single underlying array of data starting at
+ * index 0.
+ *
+ * @param size the length (number of elements) to use
+ */
+ public DataBufferUShort(int size) {
+ super(TYPE_USHORT, size);
+ data = new short[1][];
+ data[0] = new short[size];
+ }
+
+ @Override
+ public void setElem(int bank, int i, int val) {
+ data[bank][offsets[bank] + i] = (short)val;
+ notifyChanged();
+ }
+
+ @Override
+ public void setElem(int i, int val) {
+ data[0][offset + i] = (short)val;
+ notifyChanged();
+ }
+
+ @Override
+ public int getElem(int bank, int i) {
+ return (data[bank][offsets[bank] + i]) & 0xffff;
+ }
+
+ /**
+ * Gets the data of the specified internal data array.
+ *
+ * @param bank the index of the desired data array
+ *
+ * @return the data
+ */
+ public short[] getData(int bank) {
+ notifyTaken();
+ return data[bank];
+ }
+
+ @Override
+ public int getElem(int i) {
+ return (data[0][offset + i]) & 0xffff;
+ }
+
+ /**
+ * Gets the bank data.
+ *
+ * @return the bank data
+ */
+ public short[][] getBankData() {
+ notifyTaken();
+ return data.clone();
+ }
+
+ /**
+ * Gets the data of the first data array.
+ *
+ * @return the data
+ */
+ public short[] getData() {
+ notifyTaken();
+ return data[0];
+ }
+}
+
diff --git a/awt/java/awt/image/DirectColorModel.java b/awt/java/awt/image/DirectColorModel.java
new file mode 100644
index 0000000..7a287c0
--- /dev/null
+++ b/awt/java/awt/image/DirectColorModel.java
@@ -0,0 +1,862 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.color.ColorSpace;
+import java.awt.Transparency;
+import java.util.Arrays;
+
+import org.apache.harmony.awt.gl.color.LUTColorConverter;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class DirectColorModel represents a standard (packed) RGB
+ * color model with additional support for converting between sRGB
+ * color space and 8 or 16 bit linear RGB color space using lookup tables.
+ */
+public class DirectColorModel extends PackedColorModel {
+
+ /** The from_ linea r_ rg b_ lut. */
+ private byte from_LINEAR_RGB_LUT[]; // Lookup table for conversion from
+ // Linear RGB Color Space into sRGB
+
+ /** The to_ linea r_8 rg b_ lut. */
+ private byte to_LINEAR_8RGB_LUT[]; // Lookup table for conversion from
+ // sRGB Color Space into Linear RGB
+ // 8 bit
+
+ /** The to_ linea r_16 rg b_ lut. */
+ private short to_LINEAR_16RGB_LUT[]; // Lookup table for conversion from
+ // sRGB Color Space into Linear RGB
+ // 16 bit
+
+ /** The alpha lut. */
+ private byte alphaLUT[]; // Lookup table for scale alpha value
+
+ /** The color lu ts. */
+ private byte colorLUTs[][]; // Lookup tables for scale color values
+
+ /** The is_s rgb. */
+ private boolean is_sRGB; // ColorModel has sRGB ColorSpace
+
+ /** The is_ linea r_ rgb. */
+ private boolean is_LINEAR_RGB; // Color Model has Linear RGB Color
+ // Space
+
+ /** The LINEA r_ rg b_ length. */
+ private int LINEAR_RGB_Length; // Linear RGB bit length
+
+ /** The factor. */
+ private float fFactor; // Scale factor
+
+ /**
+ * Instantiates a new direct color model.
+ *
+ * @param space the color space
+ * @param bits the array of component masks
+ * @param rmask the bitmask corresponding to the red band
+ * @param gmask the bitmask corresponding to the green band
+ * @param bmask the bitmask corresponding to the blue band
+ * @param amask the bitmask corresponding to the alpha band
+ * @param isAlphaPremultiplied whether the alpha is premultiplied in this color model
+ * @param transferType the transfer type (primitive java type
+ * to use for the components)
+ *
+ * @throws IllegalArgumentException if the number of bits in the combined
+ * bitmasks for the color bands is less than one or greater than 32
+ */
+ public DirectColorModel(ColorSpace space, int bits, int rmask, int gmask,
+ int bmask, int amask, boolean isAlphaPremultiplied,
+ int transferType) {
+
+ super(space, bits, rmask, gmask, bmask, amask, isAlphaPremultiplied,
+ (amask == 0 ? Transparency.OPAQUE : Transparency.TRANSLUCENT),
+ transferType);
+
+ initLUTs();
+ }
+
+ /**
+ * Instantiates a new direct color model, determining the transfer
+ * type from the bits array, the transparency from the alpha mask,
+ * and the default color space {@link ColorSpace#CS_sRGB}.
+ *
+ * @param bits the array of component masks
+ * @param rmask the bitmask corresponding to the red band
+ * @param gmask the bitmask corresponding to the green band
+ * @param bmask the bitmask corresponding to the blue band
+ * @param amask the bitmask corresponding to the alpha band
+ */
+ public DirectColorModel(int bits, int rmask, int gmask, int bmask,
+ int amask) {
+
+ super(ColorSpace.getInstance(ColorSpace.CS_sRGB), bits, rmask, gmask,
+ bmask, amask, false,
+ (amask == 0 ? Transparency.OPAQUE : Transparency.TRANSLUCENT),
+ ColorModel.getTransferType(bits));
+
+ initLUTs();
+ }
+
+ /**
+ * Instantiates a new direct color model with no alpha channel,
+ * determining the transfer type from the bits array,
+ * the default color space {@link ColorSpace#CS_sRGB},
+ * and with the transparency set to {@link Transparency#OPAQUE}.
+ *
+ * @param bits the array of component masks
+ * @param rmask the bitmask corresponding to the red band
+ * @param gmask the bitmask corresponding to the green band
+ * @param bmask the bitmask corresponding to the blue band
+ */
+ public DirectColorModel(int bits, int rmask, int gmask, int bmask) {
+ this(bits, rmask, gmask, bmask, 0);
+ }
+
+ @Override
+ public Object getDataElements(int components[], int offset, Object obj) {
+ int pixel = 0;
+ for (int i = 0; i < numComponents; i++) {
+ pixel |= (components[offset + i] << offsets[i]) & componentMasks[i];
+ }
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[];
+ if (obj == null) {
+ ba = new byte[1];
+ } else {
+ ba = (byte[]) obj;
+ }
+ ba[0] = (byte) pixel;
+ obj = ba;
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[];
+ if (obj == null) {
+ sa = new short[1];
+ } else {
+ sa = (short[]) obj;
+ }
+ sa[0] = (short) pixel;
+ obj = sa;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ia[];
+ if (obj == null) {
+ ia = new int[1];
+ } else {
+ ia = (int[]) obj;
+ }
+ ia[0] = pixel;
+ obj = ia;
+ break;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+
+ return obj;
+ }
+
+ @Override
+ public Object getDataElements(int rgb, Object pixel) {
+ if (equals(ColorModel.getRGBdefault())) {
+ int ia[];
+ if (pixel == null) {
+ ia = new int[1];
+ } else {
+ ia = (int[]) pixel;
+ }
+ ia[0] = rgb;
+ return ia;
+ }
+
+ int alpha = (rgb >> 24) & 0xff;
+ int red = (rgb >> 16) & 0xff;
+ int green = (rgb >> 8) & 0xff;
+ int blue = rgb & 0xff;
+
+ float comp[] = new float[numColorComponents];
+ float normComp[] = null;
+
+ if (is_sRGB || is_LINEAR_RGB) {
+ if (is_LINEAR_RGB) {
+ if (LINEAR_RGB_Length == 8) {
+ red = to_LINEAR_8RGB_LUT[red] & 0xff;
+ green = to_LINEAR_8RGB_LUT[green] & 0xff;
+ blue = to_LINEAR_8RGB_LUT[blue] & 0xff;
+ } else {
+ red = to_LINEAR_16RGB_LUT[red] & 0xffff;
+ green = to_LINEAR_16RGB_LUT[green] & 0xffff;
+ blue = to_LINEAR_16RGB_LUT[blue] & 0xffff;
+ }
+ }
+ comp[0] = red / fFactor;
+ comp[1] = green / fFactor;
+ comp[2] = blue / fFactor;
+ if (!hasAlpha) {
+ normComp = comp;
+ } else {
+ float normAlpha = alpha / 255.0f;
+ normComp = new float[numComponents];
+ for (int i = 0; i < numColorComponents; i++) {
+ normComp[i] = comp[i];
+ }
+ normComp[numColorComponents] = normAlpha;
+ }
+ } else {
+ comp[0] = red / fFactor;
+ comp[1] = green / fFactor;
+ comp[2] = blue / fFactor;
+ float rgbComp[] = cs.fromRGB(comp);
+ if (!hasAlpha) {
+ normComp = rgbComp;
+ } else {
+ float normAlpha = alpha / 255.0f;
+ normComp = new float[numComponents];
+ for (int i = 0; i < numColorComponents; i++) {
+ normComp[i] = rgbComp[i];
+ }
+ normComp[numColorComponents] = normAlpha;
+ }
+ }
+
+ int pxl = 0;
+ if (hasAlpha) {
+ float normAlpha = normComp[numColorComponents];
+ alpha = (int) (normAlpha * maxValues[numColorComponents] + 0.5f);
+ if (isAlphaPremultiplied) {
+ red = (int) (normComp[0] * normAlpha * maxValues[0] + 0.5f);
+ green = (int) (normComp[1] * normAlpha * maxValues[1] + 0.5f);
+ blue = (int) (normComp[2] * normAlpha * maxValues[2] + 0.5f);
+ } else {
+ red = (int) (normComp[0] * maxValues[0] + 0.5f);
+ green = (int) (normComp[1] * maxValues[1] + 0.5f);
+ blue = (int) (normComp[2] * maxValues[2] + 0.5f);
+ }
+ pxl = (alpha << offsets[3]) & componentMasks[3];
+ } else {
+ red = (int) (normComp[0] * maxValues[0] + 0.5f);
+ green = (int) (normComp[1] * maxValues[1] + 0.5f);
+ blue = (int) (normComp[2] * maxValues[2] + 0.5f);
+ }
+
+ pxl |= ((red << offsets[0]) & componentMasks[0]) |
+ ((green << offsets[1]) & componentMasks[1]) |
+ ((blue << offsets[2]) & componentMasks[2]);
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[];
+ if (pixel == null) {
+ ba = new byte[1];
+ } else {
+ ba = (byte[]) pixel;
+ }
+ ba[0] = (byte) pxl;
+ return ba;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[];
+ if (pixel == null) {
+ sa = new short[1];
+ } else {
+ sa = (short[]) pixel;
+ }
+ sa[0] = (short) pxl;
+ return sa;
+
+ case DataBuffer.TYPE_INT:
+ int ia[];
+ if (pixel == null) {
+ ia = new int[1];
+ } else {
+ ia = (int[]) pixel;
+ }
+ ia[0] = pxl;
+ return ia;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+ }
+
+ @Override
+ public final ColorModel coerceData(WritableRaster raster,
+ boolean isAlphaPremultiplied) {
+
+ if (!hasAlpha || this.isAlphaPremultiplied == isAlphaPremultiplied) {
+ return this;
+ }
+
+ int minX = raster.getMinX();
+ int minY = raster.getMinY();
+ int w = raster.getWidth();
+ int h = raster.getHeight();
+
+ int components[] = null;
+ int transparentComponents[] = new int[numComponents];
+
+ float alphaFactor = maxValues[numColorComponents];
+
+ if (isAlphaPremultiplied) {
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ case DataBuffer.TYPE_USHORT:
+ case DataBuffer.TYPE_INT:
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ components = raster.getPixel(x, minY, components);
+ if (components[numColorComponents] == 0) {
+ raster.setPixel(x, minY, transparentComponents);
+ } else {
+ float alpha =
+ components[numColorComponents] /
+ alphaFactor;
+ for (int n = 0; n < numColorComponents; n++) {
+ components[n] =
+ (int) (alpha * components[n] + 0.5f);
+ }
+ raster.setPixel(x, minY, components);
+ }
+ }
+
+ }
+ break;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+ } else {
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ case DataBuffer.TYPE_USHORT:
+ case DataBuffer.TYPE_INT:
+ for (int i = 0; i < h; i++, minY++) {
+ for (int j = 0, x = minX; j < w; j++, x++) {
+ components = raster.getPixel(x, minY, components);
+ if (components[numColorComponents] != 0) {
+ float alpha =
+ alphaFactor / components[numColorComponents];
+ for (int n = 0; n < numColorComponents; n++) {
+ components[n] =
+ (int) (alpha * components[n] + 0.5f);
+ }
+ raster.setPixel(x, minY, components);
+ }
+ }
+
+ }
+ break;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+
+ }
+
+ return new DirectColorModel(cs, pixel_bits, componentMasks[0],
+ componentMasks[1], componentMasks[2], componentMasks[3],
+ isAlphaPremultiplied, transferType);
+ }
+
+ @Override
+ public String toString() {
+ // The output format based on 1.5 release behaviour.
+ // It could be reveled such way:
+ // BufferedImage bi = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
+ // ColorModel cm = bi.getColorModel();
+ // System.out.println(cm.toString());
+ String str = "DirectColorModel:" + " rmask = " + //$NON-NLS-1$ //$NON-NLS-2$
+ Integer.toHexString(componentMasks[0]) + " gmask = " + //$NON-NLS-1$
+ Integer.toHexString(componentMasks[1]) + " bmask = " + //$NON-NLS-1$
+ Integer.toHexString(componentMasks[2]) + " amask = " + //$NON-NLS-1$
+ (!hasAlpha ? "0" : Integer.toHexString(componentMasks[3])); //$NON-NLS-1$
+
+ return str;
+ }
+
+ @Override
+ public final int[] getComponents(Object pixel, int components[],
+ int offset) {
+
+ if (components == null) {
+ components = new int[numComponents + offset];
+ }
+
+ int intPixel = 0;
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) pixel;
+ intPixel = ba[0] & 0xff;
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = (short[]) pixel;
+ intPixel = sa[0] & 0xffff;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) pixel;
+ intPixel = ia[0];
+ break;
+
+ default:
+ // awt.22D=This transferType ( {0} ) is not supported by this color model
+ throw new UnsupportedOperationException(Messages.getString("awt.22D", //$NON-NLS-1$
+ transferType));
+ }
+
+ return getComponents(intPixel, components, offset);
+ }
+
+ @Override
+ public int getRed(Object inData) {
+ int pixel = 0;
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) inData;
+ pixel = ba[0] & 0xff;
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = (short[]) inData;
+ pixel = sa[0] & 0xffff;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) inData;
+ pixel = ia[0];
+ break;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+ return getRed(pixel);
+ }
+
+ @Override
+ public int getRGB(Object inData) {
+ int pixel = 0;
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) inData;
+ pixel = ba[0] & 0xff;
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = (short[]) inData;
+ pixel = sa[0] & 0xffff;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) inData;
+ pixel = ia[0];
+ break;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+ return getRGB(pixel);
+ }
+
+ @Override
+ public int getGreen(Object inData) {
+ int pixel = 0;
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) inData;
+ pixel = ba[0] & 0xff;
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = (short[]) inData;
+ pixel = sa[0] & 0xffff;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) inData;
+ pixel = ia[0];
+ break;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+ return getGreen(pixel);
+ }
+
+ @Override
+ public int getBlue(Object inData) {
+ int pixel = 0;
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) inData;
+ pixel = ba[0] & 0xff;
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = (short[]) inData;
+ pixel = sa[0] & 0xffff;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) inData;
+ pixel = ia[0];
+ break;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+ return getBlue(pixel);
+ }
+
+ @Override
+ public int getAlpha(Object inData) {
+ int pixel = 0;
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) inData;
+ pixel = ba[0] & 0xff;
+ break;
+
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = (short[]) inData;
+ pixel = sa[0] & 0xffff;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ia[] = (int[]) inData;
+ pixel = ia[0];
+ break;
+
+ default:
+ // awt.214=This Color Model doesn't support this transferType
+ throw new UnsupportedOperationException(Messages.getString("awt.214")); //$NON-NLS-1$
+ }
+ return getAlpha(pixel);
+ }
+
+ @Override
+ public final WritableRaster createCompatibleWritableRaster(int w, int h) {
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new IllegalArgumentException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ int bandMasks[] = componentMasks.clone();
+
+ if (pixel_bits > 16) {
+ return Raster.createPackedRaster(DataBuffer.TYPE_INT, w, h,
+ bandMasks, null);
+ } else if (pixel_bits > 8) {
+ return Raster.createPackedRaster(DataBuffer.TYPE_USHORT, w, h,
+ bandMasks, null);
+ } else {
+ return Raster.createPackedRaster(DataBuffer.TYPE_BYTE, w, h,
+ bandMasks, null);
+ }
+ }
+
+ @Override
+ public boolean isCompatibleRaster(Raster raster) {
+ SampleModel sm = raster.getSampleModel();
+ if (!(sm instanceof SinglePixelPackedSampleModel)) {
+ return false;
+ }
+
+ SinglePixelPackedSampleModel sppsm = (SinglePixelPackedSampleModel) sm;
+
+ if (sppsm.getNumBands() != numComponents) {
+ return false;
+ }
+ if (raster.getTransferType() != transferType) {
+ return false;
+ }
+
+ int maskBands[] = sppsm.getBitMasks();
+ return Arrays.equals(maskBands, componentMasks);
+ }
+
+ @Override
+ public int getDataElement(int components[], int offset) {
+ int pixel = 0;
+ for (int i = 0; i < numComponents; i++) {
+ pixel |= (components[offset + i] << offsets[i]) & componentMasks[i];
+ }
+ return pixel;
+ }
+
+ @Override
+ public final int[] getComponents(int pixel, int components[], int offset) {
+ if (components == null) {
+ components = new int[numComponents + offset];
+ }
+ for (int i = 0; i < numComponents; i++) {
+ components[offset + i] = (pixel & componentMasks[i]) >> offsets[i];
+ }
+ return components;
+ }
+
+ @Override
+ public final int getRed(int pixel) {
+ if (is_sRGB) {
+ return getComponentFrom_sRGB(pixel, 0);
+ }
+ if (is_LINEAR_RGB) {
+ return getComponentFrom_LINEAR_RGB(pixel, 0);
+ }
+ return getComponentFrom_RGB(pixel, 0);
+ }
+
+ @Override
+ public final int getRGB(int pixel) {
+ return (getAlpha(pixel) << 24) | (getRed(pixel) << 16) |
+ (getGreen(pixel) << 8) | getBlue(pixel);
+ }
+
+ @Override
+ public final int getGreen(int pixel) {
+ if (is_sRGB) {
+ return getComponentFrom_sRGB(pixel, 1);
+ }
+ if (is_LINEAR_RGB) {
+ return getComponentFrom_LINEAR_RGB(pixel, 1);
+ }
+ return getComponentFrom_RGB(pixel, 1);
+ }
+
+ @Override
+ public final int getBlue(int pixel) {
+ if (is_sRGB) {
+ return getComponentFrom_sRGB(pixel, 2);
+ }
+ if (is_LINEAR_RGB) {
+ return getComponentFrom_LINEAR_RGB(pixel, 2);
+ }
+ return getComponentFrom_RGB(pixel, 2);
+ }
+
+ @Override
+ public final int getAlpha(int pixel) {
+ if (!hasAlpha) {
+ return 255;
+ }
+ int a = (pixel & componentMasks[3]) >>> offsets[3];
+ if (bits[3] == 8) {
+ return a;
+ }
+ return alphaLUT[a] & 0xff;
+ }
+
+ /**
+ * Gets the red mask.
+ *
+ * @return the red mask
+ */
+ public final int getRedMask() {
+ return componentMasks[0];
+ }
+
+ /**
+ * Gets the green mask.
+ *
+ * @return the green mask
+ */
+ public final int getGreenMask() {
+ return componentMasks[1];
+ }
+
+ /**
+ * Gets the blue mask.
+ *
+ * @return the blue mask
+ */
+ public final int getBlueMask() {
+ return componentMasks[2];
+ }
+
+ /**
+ * Gets the alpha mask.
+ *
+ * @return the alpha mask
+ */
+ public final int getAlphaMask() {
+ if (hasAlpha) {
+ return componentMasks[3];
+ }
+ return 0;
+ }
+
+ /**
+ * Initialization of Lookup tables.
+ */
+ private void initLUTs() {
+ is_sRGB = cs.isCS_sRGB();
+ is_LINEAR_RGB = (cs == LUTColorConverter.LINEAR_RGB_CS);
+
+ if (is_LINEAR_RGB) {
+ if (maxBitLength > 8) {
+ LINEAR_RGB_Length = 16;
+ from_LINEAR_RGB_LUT =
+ LUTColorConverter.getFrom16lRGBtosRGB_LUT();
+ to_LINEAR_16RGB_LUT =
+ LUTColorConverter.getFromsRGBto16lRGB_LUT();
+ } else {
+ LINEAR_RGB_Length = 8;
+ from_LINEAR_RGB_LUT =
+ LUTColorConverter.getFrom8lRGBtosRGB_LUT();
+ to_LINEAR_8RGB_LUT =
+ LUTColorConverter.getFromsRGBto8lRGB_LUT();
+ }
+ fFactor = ((1 << LINEAR_RGB_Length) - 1);
+ } else {
+ fFactor = 255.0f;
+ }
+
+ if (hasAlpha && bits[3] != 8) {
+ alphaLUT = new byte[maxValues[3] + 1];
+ for (int i = 0; i <= maxValues[3]; i++) {
+ alphaLUT[i] = (byte) (scales[3] * i + 0.5f);
+ }
+
+ }
+
+ if (!isAlphaPremultiplied) {
+ colorLUTs = new byte[3][];
+
+ if (is_sRGB) {
+ for (int i = 0; i < numColorComponents; i++) {
+ if (bits[i] != 8) {
+ for (int j = 0; j < i; j++) {
+ if (bits[i] == bits[j]) {
+ colorLUTs[i] = colorLUTs[j];
+ break;
+ }
+ }
+ colorLUTs[i] = new byte[maxValues[i] + 1];
+ for (int j = 0; j <= maxValues[i]; j++) {
+ colorLUTs[i][j] = (byte) (scales[i] * j + 0.5f);
+ }
+ }
+ }
+ }
+
+ if (is_LINEAR_RGB) {
+ for (int i = 0; i < numColorComponents; i++) {
+ if (bits[i] != LINEAR_RGB_Length) {
+ for (int j = 0; j < i; j++) {
+ if (bits[i] == bits[j]) {
+ colorLUTs[i] = colorLUTs[j];
+ break;
+ }
+ }
+ colorLUTs[i] = new byte[maxValues[i] + 1];
+ for (int j = 0; j <= maxValues[0]; j++) {
+ int idx;
+ if (LINEAR_RGB_Length == 8) {
+ idx = (int) (scales[i] * j + 0.5f);
+ } else {
+ idx = (int) (scales[i] * j * 257.0f + 0.5f);
+ }
+ colorLUTs[i][j] = from_LINEAR_RGB_LUT[idx];
+ }
+ }
+ }
+ }
+
+ }
+ }
+
+ /**
+ * This method return RGB component value if Color Model has
+ * sRGB ColorSpace.
+ *
+ * @param pixel - INT representation of pixel
+ * @param idx - index of pixel component
+ *
+ * @return - value of the pixel component scaled fro 0 to 255
+ */
+ private int getComponentFrom_sRGB(int pixel, int idx) {
+ int comp = (pixel & componentMasks[idx]) >> offsets[idx];
+ if (isAlphaPremultiplied) {
+ int alpha = (pixel & componentMasks[3]) >>> offsets[3];
+ comp = alpha == 0 ? 0 : (int) (scales[idx] * comp * 255.0f /
+ (scales[3] * alpha) + 0.5f);
+ } else if (bits[idx] != 8) {
+ comp = colorLUTs[idx][comp] & 0xff;
+ }
+ return comp;
+ }
+
+ /**
+ * This method return RGB component value if Color Model has
+ * Linear RGB ColorSpace.
+ *
+ * @param pixel - INT representation of pixel
+ * @param idx - index of pixel component
+ *
+ * @return - value of the pixel component scaled fro 0 to 255
+ */
+ private int getComponentFrom_LINEAR_RGB(int pixel, int idx) {
+ int comp = (pixel & componentMasks[idx]) >> offsets[idx];
+ if (isAlphaPremultiplied) {
+ float factor = ((1 << LINEAR_RGB_Length) - 1);
+ int alpha = (pixel & componentMasks[3]) >> offsets[3];
+ comp = alpha == 0 ? 0 : (int) (scales[idx] * comp * factor /
+ (scales[3] * alpha) + 0.5f);
+ } else if (bits[idx] != LINEAR_RGB_Length) {
+ comp = colorLUTs[idx][comp] & 0xff;
+ } else {
+ comp = from_LINEAR_RGB_LUT[comp] & 0xff;
+ }
+ return comp;
+ }
+
+ /**
+ * This method return RGB component value if Color Model has
+ * arbitrary RGB ColorSapce.
+ *
+ * @param pixel - INT representation of pixel
+ * @param idx - index of pixel component
+ *
+ * @return - value of the pixel component scaled fro 0 to 255
+ */
+ private int getComponentFrom_RGB(int pixel, int idx) {
+ int components[] = getComponents(pixel, null, 0);
+ float[] normComponents = getNormalizedComponents(components, 0, null, 0);
+ float[] sRGBcomponents = cs.toRGB(normComponents);
+ return (int) (sRGBcomponents[idx] * 255.0f + 0.5f);
+ }
+
+}
+
diff --git a/awt/java/awt/image/FilteredImageSource.java b/awt/java/awt/image/FilteredImageSource.java
new file mode 100644
index 0000000..6a41fa7
--- /dev/null
+++ b/awt/java/awt/image/FilteredImageSource.java
@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.util.Hashtable;
+
+
+/**
+ * The FilteredImageSource class is used for producing image data for a new
+ * filtered version of the original image using the specified filter object.
+ */
+public class FilteredImageSource implements ImageProducer {
+
+ /** The source. */
+ private final ImageProducer source;
+
+ /** The filter. */
+ private final ImageFilter filter;
+
+ /** The cons table. */
+ private final Hashtable<ImageConsumer, ImageConsumer> consTable = new Hashtable<ImageConsumer, ImageConsumer>();
+
+ /**
+ * Instantiates a new FilteredImageSource object with
+ * the specified ImageProducer and the ImageFilter objects.
+ *
+ * @param orig the specified ImageProducer.
+ * @param imgf the specified ImageFilter.
+ */
+ public FilteredImageSource(ImageProducer orig, ImageFilter imgf) {
+ source = orig;
+ filter = imgf;
+ }
+
+ public synchronized boolean isConsumer(ImageConsumer ic) {
+ if(ic != null) {
+ return consTable.containsKey(ic);
+ }
+ return false;
+ }
+
+ public void startProduction(ImageConsumer ic) {
+ addConsumer(ic);
+ ImageConsumer fic = consTable.get(ic);
+ source.startProduction(fic);
+ }
+
+ public void requestTopDownLeftRightResend(ImageConsumer ic) {
+ if(ic != null && isConsumer(ic)){
+ ImageFilter fic = (ImageFilter) consTable.get(ic);
+ fic.resendTopDownLeftRight(source);
+ }
+ }
+
+ public synchronized void removeConsumer(ImageConsumer ic) {
+ if(ic != null && isConsumer(ic)){
+ ImageConsumer fic = consTable.get(ic);
+ source.removeConsumer(fic);
+ consTable.remove(ic);
+ }
+ }
+
+ public synchronized void addConsumer(ImageConsumer ic) {
+ if(ic != null && !isConsumer(ic)){
+ ImageConsumer fic = filter.getFilterInstance(ic);
+ source.addConsumer(fic);
+ consTable.put(ic, fic);
+ }
+ }
+}
diff --git a/awt/java/awt/image/ImageConsumer.java b/awt/java/awt/image/ImageConsumer.java
new file mode 100644
index 0000000..2eba290
--- /dev/null
+++ b/awt/java/awt/image/ImageConsumer.java
@@ -0,0 +1,165 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.util.Hashtable;
+
+/**
+ * The ImageConsumer interface provides the data about the image
+ * and about how its data is delivered. A ImageProducer provides
+ * all of the information about the image using
+ * the methods defined in this interface.
+ */
+public interface ImageConsumer {
+
+ /**
+ * The Constant RANDOMPIXELORDER indicates that the pixels are
+ * delivered in a random order.
+ */
+ public static final int RANDOMPIXELORDER = 1;
+
+ /**
+ * The Constant TOPDOWNLEFTRIGHT indicates that the pixels are
+ * delivered in top-down, left-to-right order.
+ */
+ public static final int TOPDOWNLEFTRIGHT = 2;
+
+ /**
+ * The Constant COMPLETESCANLINES indicates that the pixels are
+ * delivered in complete scanline.
+ */
+ public static final int COMPLETESCANLINES = 4;
+
+ /**
+ * The Constant SINGLEPASS indicates that pixels are delivered
+ * in a single pass.
+ */
+ public static final int SINGLEPASS = 8;
+
+ /**
+ * The Constant SINGLEFRAME indicates that image consists of
+ * single frame.
+ */
+ public static final int SINGLEFRAME = 16;
+
+ /**
+ * The Constant IMAGEERROR indicates an image error during image producing.
+ */
+ public static final int IMAGEERROR = 1;
+
+ /**
+ * The Constant SINGLEFRAMEDONE indicates that only one of the
+ * image's frames is completed.
+ */
+ public static final int SINGLEFRAMEDONE = 2;
+
+ /**
+ * The Constant STATICIMAGEDONE indicates that the image is completed.
+ */
+ public static final int STATICIMAGEDONE = 3;
+
+ /**
+ * The Constant IMAGEABORTED indicates that the image producing
+ * process is aborted.
+ */
+ public static final int IMAGEABORTED = 4;
+
+ /**
+ * Sets the properties for the image associated with this ImageConsumer.
+ *
+ * @param props the properties for the image associated with
+ * this ImageConsumer.
+ */
+ public void setProperties(Hashtable<?, ?> props);
+
+ /**
+ * Sets the ColorModel object.
+ *
+ * @param model the new ColorModel.
+ */
+ public void setColorModel(ColorModel model);
+
+ /**
+ * Sets the pixels for the specified rectangular area of the image.
+ *
+ * @param x the X coordinate of rectangular area.
+ * @param y the Y coordinate of rectangular area.
+ * @param w the width of rectangular area.
+ * @param h the height of rectangular area.
+ * @param model the specified ColorModel to be used for pixels
+ * converting.
+ * @param pixels the array of pixels.
+ * @param off the offset of pixels array.
+ * @param scansize the distance from the one row of pixels
+ * to the next row in the specified array.
+ */
+ public void setPixels(int x, int y, int w, int h, ColorModel model,
+ int[] pixels, int off, int scansize);
+
+ /**
+ * Sets the pixels for the specified rectangular area of the image.
+ *
+ * @param x the X coordinate of rectangular area.
+ * @param y the Y coordinate of rectangular area.
+ * @param w the width of rectangular area.
+ * @param h the height of rectangular area.
+ * @param model the specified ColorModel to be used for pixels
+ * converting.
+ * @param pixels the array of pixels.
+ * @param off the offset of pixels array.
+ * @param scansize the distance from the one row of pixels
+ * to the next row in the specified array.
+ */
+ public void setPixels(int x, int y, int w, int h, ColorModel model,
+ byte[] pixels, int off, int scansize);
+
+ /**
+ * Sets the dimensions of a source image.
+ *
+ * @param width the width of the image.
+ * @param height the height of the image.
+ */
+ public void setDimensions(int width, int height);
+
+ /**
+ * Sets the hint flags of pixels order, which is used by
+ * the ImageConsumer for obtaining pixels from the ImageProducer
+ * for which this ImageConsumer is added.
+ *
+ * @param hintflags the mask of hint flags.
+ */
+ public void setHints(int hintflags);
+
+ /**
+ * THis method is called in the one of the following cases:
+ * <ul>
+ * <li>The ImageProducer (for which this ImageConsumer is added)
+ * has been delivered all pixels of the source image. </li>
+ * <li>A one frame of an animation has been completed. </li>
+ * <li> An error while loading or producing of the image has occured.
+ * </ul>
+ *
+ * @param status the status of image producing.
+ */
+ public void imageComplete(int status);
+
+}
+
diff --git a/awt/java/awt/image/ImageFilter.java b/awt/java/awt/image/ImageFilter.java
new file mode 100644
index 0000000..e386d65
--- /dev/null
+++ b/awt/java/awt/image/ImageFilter.java
@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.util.Hashtable;
+
+/**
+ * The ImageFilter class provides a filter for delivering image data
+ * from an ImageProducer to an ImageConsumer.
+ */
+public class ImageFilter implements ImageConsumer, Cloneable {
+
+ /** The consumer. */
+ protected ImageConsumer consumer;
+
+ /**
+ * Instantiates a new ImageFilter.
+ */
+ public ImageFilter() {
+ super();
+ }
+
+ /**
+ * Gets an instance of an ImageFilter object which performs
+ * the filtering for the specified ImageConsumer.
+ *
+ * @param ic the specified ImageConsumer.
+ *
+ * @return an ImageFilter used to perform the filtering for
+ * the specified ImageConsumer.
+ */
+ public ImageFilter getFilterInstance(ImageConsumer ic) {
+ ImageFilter filter = (ImageFilter) clone();
+ filter.consumer = ic;
+ return filter;
+ }
+
+ @SuppressWarnings("unchecked")
+ public void setProperties(Hashtable<?, ?> props) {
+ Hashtable<Object, Object> fprops;
+ if (props == null) {
+ fprops = new Hashtable<Object, Object>();
+ } else {
+ fprops = (Hashtable<Object, Object>) props.clone();
+ }
+ String propName = "Filters"; //$NON-NLS-1$
+ String prop = "Null filter"; //$NON-NLS-1$
+ Object o = fprops.get(propName);
+ if (o != null) {
+ if (o instanceof String) {
+ prop = (String) o + "; " + prop; //$NON-NLS-1$
+ } else {
+ prop = o.toString() + "; " + prop; //$NON-NLS-1$
+ }
+ }
+ fprops.put(propName, prop);
+ consumer.setProperties(fprops);
+ }
+
+ /**
+ * Returns a copy of this ImageFilter.
+ *
+ * @return a copy of this ImageFilter.
+ */
+ @Override
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ return null;
+ }
+ }
+
+ /**
+ * Responds to a request for a Top-Down-Left-Right ordered
+ * resend of the pixel data from an ImageConsumer.
+ *
+ * @param ip the ImageProducer that provides this instance of
+ * the filter.
+ */
+ public void resendTopDownLeftRight(ImageProducer ip) {
+ ip.requestTopDownLeftRightResend(this);
+ }
+
+ public void setColorModel(ColorModel model) {
+ consumer.setColorModel(model);
+ }
+
+ public void setPixels(int x, int y, int w, int h, ColorModel model, int[] pixels, int off,
+ int scansize) {
+ consumer.setPixels(x, y, w, h, model, pixels, off, scansize);
+ }
+
+ public void setPixels(int x, int y, int w, int h, ColorModel model, byte[] pixels, int off,
+ int scansize) {
+ consumer.setPixels(x, y, w, h, model, pixels, off, scansize);
+ }
+
+ public void setDimensions(int width, int height) {
+ consumer.setDimensions(width, height);
+ }
+
+ public void setHints(int hints) {
+ consumer.setHints(hints);
+ }
+
+ public void imageComplete(int status) {
+ consumer.imageComplete(status);
+ }
+
+}
diff --git a/awt/java/awt/image/ImageObserver.java b/awt/java/awt/image/ImageObserver.java
new file mode 100644
index 0000000..418bd07
--- /dev/null
+++ b/awt/java/awt/image/ImageObserver.java
@@ -0,0 +1,99 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Image;
+
+/**
+ * the ImageObserver interface is an asynchronous update interface
+ * for receiving notifications about Image construction status.
+ */
+public interface ImageObserver {
+
+ /**
+ * The Constant WIDTH indicates that the width of the image is
+ * available.
+ */
+ public static final int WIDTH = 1;
+
+ /**
+ * The Constant HEIGHT indicates that the width of the image is
+ * available.
+ */
+ public static final int HEIGHT = 2;
+
+ /**
+ * The Constant PROPERTIES indicates that the properties of the image
+ * are available.
+ */
+ public static final int PROPERTIES = 4;
+
+ /**
+ * The Constant SOMEBITS indicates that more bits needed for
+ * drawing a scaled variation of the image pixels are available.
+ */
+ public static final int SOMEBITS = 8;
+
+ /**
+ * The Constant FRAMEBITS indicates that complete frame of
+ * a image which was previously drawn is now available
+ * for drawing again.
+ */
+ public static final int FRAMEBITS = 16;
+
+ /**
+ * The Constant ALLBITS indicates that an image which
+ * was previously drawn is now complete and can be drawn again.
+ */
+ public static final int ALLBITS = 32;
+
+ /**
+ * The Constant ERROR indicates that error occured.
+ */
+ public static final int ERROR = 64;
+
+ /**
+ * The Constant ABORT indicates that the image producing is
+ * aborted.
+ */
+ public static final int ABORT = 128;
+
+ /**
+ * This method is called when information about an Image
+ * interface becomes available. This method returns true
+ * if further updates are needed, false if not.
+ *
+ * @param img the image to be observed.
+ * @param infoflags the bitwise OR combination of information flags:
+ * ABORT, ALLBITS, ERROR, FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS,
+ * WIDTH.
+ * @param x the X coordinate.
+ * @param y the Y coordinate.
+ * @param width the width.
+ * @param height the height.
+ *
+ * @return true if further updates are needed, false if not.
+ */
+ public boolean imageUpdate(Image img, int infoflags, int x, int y,
+ int width, int height);
+
+}
+
diff --git a/awt/java/awt/image/ImageProducer.java b/awt/java/awt/image/ImageProducer.java
new file mode 100644
index 0000000..557ae08
--- /dev/null
+++ b/awt/java/awt/image/ImageProducer.java
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+
+/**
+ * The ImageProducer provides an interface for objects which produce
+ * the image data. ImageProducer is used for reconstructing the
+ * image. Each image contains an ImageProducer.
+ */
+public interface ImageProducer {
+
+ /**
+ * Checks if the specified ImageConsumer is registered with this
+ * ImageProvider or not.
+ *
+ * @param ic the ImageConsumer to be checked.
+ *
+ * @return true, if the specified ImageConsumer is registered with this
+ * ImageProvider, false otherwise.
+ */
+ public boolean isConsumer(ImageConsumer ic);
+
+ /**
+ * Starts a reconstruction of the image data which will
+ * be delivered to this consumer. This method addes the
+ * specified ImageConsumer before reconstructing the image.
+ *
+ * @param ic the specified ImageConsumer.
+ */
+ public void startProduction(ImageConsumer ic);
+
+ /**
+ * Requests the ImageProducer to resend the image data
+ * in ImageConsumer.TOPDOWNLEFTRIGHT order.
+ *
+ * @param ic the specified ImageConsumer.
+ */
+ public void requestTopDownLeftRightResend(ImageConsumer ic);
+
+ /**
+ * Deregisters the specified ImageConsumer.
+ *
+ * @param ic the specified ImageConsumer.
+ */
+ public void removeConsumer(ImageConsumer ic);
+
+ /**
+ * Adds the specified ImageConsumer object to this ImageProducer.
+ *
+ * @param ic the specified ImageConsumer.
+ */
+ public void addConsumer(ImageConsumer ic);
+
+}
+
diff --git a/awt/java/awt/image/ImagingOpException.java b/awt/java/awt/image/ImagingOpException.java
new file mode 100644
index 0000000..ebcaba4
--- /dev/null
+++ b/awt/java/awt/image/ImagingOpException.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ *
+ * @date: Oct 5, 2005
+ */
+
+package java.awt.image;
+
+/**
+ * The ImagingOpException class provides error notification when
+ * the BufferedImageOp or RasterOp filter methods can not perform
+ * the desired filter operation.
+ */
+public class ImagingOpException extends RuntimeException {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 8026288481846276658L;
+
+ /**
+ * Instantiates a new ImagingOpException with a detail message.
+ *
+ * @param s the detail message.
+ */
+ public ImagingOpException(String s) {
+ super(s);
+ }
+}
diff --git a/awt/java/awt/image/IndexColorModel.java b/awt/java/awt/image/IndexColorModel.java
new file mode 100644
index 0000000..a7043f4
--- /dev/null
+++ b/awt/java/awt/image/IndexColorModel.java
@@ -0,0 +1,1020 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Transparency;
+import java.awt.color.ColorSpace;
+import java.math.BigInteger;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class IndexColorModel represents a color model in which the
+ * color values of the pixels are read from a palette.
+ */
+public class IndexColorModel extends ColorModel {
+
+ /** The color map. */
+ private int colorMap[]; // Color Map
+
+ /** The map size. */
+ private int mapSize; // Color Map size
+
+ /** The transparent index. */
+ private int transparentIndex; // Index of fully transparent pixel
+
+ /** The gray palette. */
+ private boolean grayPalette; // Color Model has Color Map with Gray Pallete
+
+ /** The valid bits. */
+ private BigInteger validBits; // Specify valid Color Map values
+
+ /** The Constant CACHESIZE. */
+ private static final int CACHESIZE = 20; // Cache size. Cache used for
+ // improving performace of selection
+ // nearest color in Color Map
+
+ /** The cachetable. */
+ private final int cachetable[] = new int[CACHESIZE * 2]; // Cache table - used for
+ // storing RGB values and that appropriate indices
+ // in the Color Map
+
+
+ /** The next insert idx. */
+ private int nextInsertIdx = 0; // Next index for insertion into Cache table
+
+ /** The total inserted. */
+ private int totalInserted = 0; // Number of inserted values into Cache table
+
+ /**
+ * Instantiates a new index color model.
+ *
+ * @param bits the array of component masks
+ * @param size the size of the color map
+ * @param cmap the array that gives the color mapping
+ * @param start the start index of the color mapping data within the cmap array
+ * @param transferType the transfer type (primitive java type
+ * to use for the components)
+ * @param validBits a list of which bits represent valid colormap
+ * values, or null if all are valid
+ *
+ * @throws IllegalArgumentException if the size of the color map is
+ * less than one
+ */
+ public IndexColorModel(int bits, int size, int cmap[], int start,
+ int transferType, BigInteger validBits) {
+
+ super(bits, IndexColorModel.createBits(true),
+ ColorSpace.getInstance(ColorSpace.CS_sRGB), true, false,
+ Transparency.OPAQUE, validateTransferType(transferType));
+
+ if (size < 1) {
+ // awt.264=Size of the color map is less than 1
+ throw new IllegalArgumentException(Messages.getString("awt.264")); //$NON-NLS-1$
+ }
+
+ mapSize = size;
+ colorMap = new int[mapSize];
+ transparentIndex = -1;
+
+ if (validBits != null) {
+ for (int i = 0; i < mapSize; i++) {
+ if (!validBits.testBit(i)) {
+ this.validBits = validBits;
+ }
+ break;
+ }
+ }
+
+ transparency = Transparency.OPAQUE;
+ int alphaMask = 0xff000000;
+ int alpha = 0;
+
+ for (int i = 0; i < mapSize; i++, start++) {
+ colorMap[i] = cmap[start];
+ alpha = cmap[start] & alphaMask;
+
+ if (alpha == alphaMask) {
+ continue;
+ }
+ if (alpha == 0) {
+ if (transparentIndex < 0) {
+ transparentIndex = i;
+ }
+ if (transparency == Transparency.OPAQUE) {
+ transparency = Transparency.BITMASK;
+ }
+ } else if (alpha != alphaMask &&
+ transparency != Transparency.TRANSLUCENT) {
+ transparency = Transparency.TRANSLUCENT;
+ }
+
+ }
+ checkPalette();
+
+ }
+
+ /**
+ * Instantiates a new index color model.
+ *
+ * @param bits the array of component masks
+ * @param size the size of the color map
+ * @param cmap the array that gives the color mapping
+ * @param start the start index of the color mapping data within the cmap array
+ * @param hasalpha whether this color model uses alpha
+ * @param trans the transparency supported, @see java.awt.Transparency
+ * @param transferType the transfer type (primitive java type
+ * to use for the components)
+ *
+ * @throws IllegalArgumentException if the size of the color map is
+ * less than one
+ */
+ public IndexColorModel(int bits, int size, int cmap[], int start,
+ boolean hasalpha, int trans, int transferType) {
+
+ super(bits, IndexColorModel.createBits(hasalpha || (trans >= 0)),
+ ColorSpace.getInstance(ColorSpace.CS_sRGB),
+ (hasalpha || (trans >= 0)), false, Transparency.OPAQUE,
+ validateTransferType(transferType));
+
+ if (size < 1) {
+ // awt.264=Size of the color map is less than 1
+ throw new IllegalArgumentException(Messages.getString("awt.264")); //$NON-NLS-1$
+ }
+
+ mapSize = size;
+ colorMap = new int[mapSize];
+ if (trans >= 0 && trans < mapSize) {
+ transparentIndex = trans;
+ transparency = Transparency.BITMASK;
+ } else {
+ transparentIndex = -1;
+ transparency = Transparency.OPAQUE;
+ }
+
+ int alphaMask = 0xff000000;
+ int alpha = 0;
+
+ for (int i = 0; i < mapSize; i++, start++) {
+ if (transparentIndex == i) {
+ colorMap[i] = cmap[start] & 0x00ffffff;
+ continue;
+ }
+ if (hasalpha) {
+ alpha = cmap[start] & alphaMask;
+ colorMap[i] = cmap[start];
+
+ if (alpha == alphaMask) {
+ continue;
+ }
+ if (alpha == 0) {
+ if (trans < 0) {
+ trans = i;
+ }
+ if (transparency == Transparency.OPAQUE) {
+ transparency = Transparency.BITMASK;
+ }
+ } else if (alpha != 0
+ && transparency != Transparency.TRANSLUCENT) {
+ transparency = Transparency.TRANSLUCENT;
+ }
+ } else {
+ colorMap[i] = alphaMask | cmap[start];
+ }
+ }
+ checkPalette();
+
+ }
+
+ /**
+ * Instantiates a new index color model by building the color map
+ * from arrays of red, green, blue, and alpha values.
+ *
+ * @param bits the array of component masks
+ * @param size the size of the color map
+ * @param r the array giving the red components of the entries in the color map
+ * @param g the array giving the green components of the entries in the color map
+ * @param b the array giving the blue components of the entries in the color map
+ * @param a the array giving the alpha components of the entries in the color map
+ *
+ * @throws IllegalArgumentException if the size of the color map is
+ * less than one
+ * @throws ArrayIndexOutOfBoundsException if the size of one of the
+ * component arrays is less than the size of the color map
+ */
+ public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[],
+ byte a[]) {
+
+ super(bits, IndexColorModel.createBits(true),
+ ColorSpace.getInstance(ColorSpace.CS_sRGB), true, false,
+ Transparency.OPAQUE,
+ validateTransferType(ColorModel.getTransferType(bits)));
+
+ createColorMap(size, r, g, b, a, -1);
+ checkPalette();
+ }
+
+ /**
+ * Instantiates a new index color model by building the color map
+ * from arrays of red, green, and blue values.
+ *
+ * @param bits the array of component masks
+ * @param size the size of the color map
+ * @param r the array giving the red components of the entries in the color map
+ * @param g the array giving the green components of the entries in the color map
+ * @param b the array giving the blue components of the entries in the color map
+ * @param trans the transparency supported, @see java.awt.Transparency
+ *
+ * @throws IllegalArgumentException if the size of the color map is
+ * less than one
+ * @throws ArrayIndexOutOfBoundsException if the size of one of the
+ * component arrays is less than the size of the color map
+ */
+ public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[],
+ int trans) {
+
+ super(bits, IndexColorModel.createBits((trans >= 0)),
+ ColorSpace.getInstance(ColorSpace.CS_sRGB), (trans >= 0), false,
+ Transparency.OPAQUE,
+ validateTransferType(ColorModel.getTransferType(bits)));
+
+ createColorMap(size, r, g, b, null, trans);
+ checkPalette();
+ }
+
+ /**
+ * Instantiates a new index color model by building the color map
+ * from arrays of red, green, and blue values.
+ *
+ * @param bits the array of component masks
+ * @param size the size of the color map
+ * @param r the array giving the red components of the entries in the color map
+ * @param g the array giving the green components of the entries in the color map
+ * @param b the array giving the blue components of the entries in the color map
+ *
+ * @throws IllegalArgumentException if the size of the color map is
+ * less than one
+ * @throws ArrayIndexOutOfBoundsException if the size of one of the
+ * component arrays is less than the size of the color map
+ */
+ public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[]) {
+ super(bits, IndexColorModel.createBits(false),
+ ColorSpace.getInstance(ColorSpace.CS_sRGB), false, false,
+ Transparency.OPAQUE,
+ validateTransferType(ColorModel.getTransferType(bits)));
+
+ createColorMap(size, r, g, b, null, -1);
+ checkPalette();
+ }
+
+ /**
+ * Instantiates a new index color model.
+ *
+ * @param bits the array of component masks
+ * @param size the size of the color map
+ * @param cmap the array that gives the color mapping
+ * @param start the start index of the color mapping data within the cmap array
+ * @param hasalpha whether this color model uses alpha
+ * @param trans the transparency supported, @see java.awt.Transparency
+ *
+ * @throws IllegalArgumentException if the size of the color map is
+ * less than one
+ */
+ public IndexColorModel(int bits, int size, byte cmap[], int start,
+ boolean hasalpha, int trans) {
+
+ super(bits, IndexColorModel.createBits(hasalpha || (trans >= 0)),
+ ColorSpace.getInstance(ColorSpace.CS_sRGB),
+ (hasalpha || (trans >= 0)), false, Transparency.OPAQUE,
+ validateTransferType(ColorModel.getTransferType(bits)));
+
+ if (size < 1) {
+ // awt.264=Size of the color map is less than 1
+ throw new IllegalArgumentException(Messages.getString("awt.264")); //$NON-NLS-1$
+ }
+
+ mapSize = size;
+ colorMap = new int[mapSize];
+ transparentIndex = -1;
+
+ transparency = Transparency.OPAQUE;
+ int alpha = 0xff000000;
+
+ for (int i = 0; i < mapSize; i++) {
+ colorMap[i] = (cmap[start++] & 0xff) << 16 |
+ (cmap[start++] & 0xff) << 8 | (cmap[start++] & 0xff);
+ if (trans == i) {
+ if (transparency == Transparency.OPAQUE) {
+ transparency = Transparency.BITMASK;
+ }
+ if(hasalpha) {
+ start++;
+ }
+ continue;
+ }
+ if (hasalpha) {
+ alpha = cmap[start++] & 0xff;
+ if (alpha == 0) {
+ if (transparency == Transparency.OPAQUE) {
+ transparency = Transparency.BITMASK;
+ if (trans < 0) {
+ trans = i;
+ }
+ }
+ } else {
+ if (alpha != 0xff &&
+ transparency != Transparency.TRANSLUCENT) {
+ transparency = Transparency.TRANSLUCENT;
+ }
+ }
+ alpha <<= 24;
+ }
+ colorMap[i] |= alpha;
+ }
+
+ if (trans >= 0 && trans < mapSize) {
+ transparentIndex = trans;
+ }
+ checkPalette();
+
+ }
+
+ /**
+ * Instantiates a new index color model.
+ *
+ * @param bits the array of component masks
+ * @param size the size of the color map
+ * @param cmap the array that gives the color mapping
+ * @param start the start index of the color mapping data within the cmap array
+ * @param hasalpha whether this color model uses alpha
+ *
+ * @throws IllegalArgumentException if the size of the color map is
+ * less than one
+ */
+ public IndexColorModel(int bits, int size, byte cmap[], int start,
+ boolean hasalpha) {
+
+ this(bits, size, cmap, start, hasalpha, -1);
+ }
+
+ @Override
+ public Object getDataElements(int[] components, int offset, Object pixel) {
+ int rgb = (components[offset] << 16) | (components[offset + 1]) << 8 |
+ components[offset + 2];
+ if (hasAlpha) {
+ rgb |= components[offset + 3] << 24;
+ } else {
+ rgb |= 0xff000000;
+ }
+ return getDataElements(rgb, pixel);
+ }
+
+ @Override
+ public synchronized Object getDataElements(int rgb, Object pixel) {
+ int red = (rgb >> 16) & 0xff;
+ int green = (rgb >> 8) & 0xff;
+ int blue = rgb & 0xff;
+ int alpha = rgb >>> 24;
+ int pixIdx = 0;
+
+ for (int i = 0; i < totalInserted; i++) {
+ int idx = i * 2;
+ if (rgb == cachetable[idx]) {
+ return createDataObject(cachetable[idx + 1], pixel);
+ }
+ }
+
+ if (!hasAlpha && grayPalette) {
+ int grey = (red * 77 + green * 150 + blue * 29 + 128) >>> 8;
+ int minError = 255;
+ int error = 0;
+
+ for (int i = 0; i < mapSize; i++) {
+ error = Math.abs((colorMap[i] & 0xff) - grey);
+ if (error < minError) {
+ pixIdx = i;
+ if (error == 0) {
+ break;
+ }
+ minError = error;
+ }
+ }
+ } else if (alpha == 0 && transparentIndex > -1) {
+ pixIdx = transparentIndex;
+ } else {
+ int minAlphaError = 255;
+ int minError = 195075; // 255^2 + 255^2 + 255^2
+ int alphaError;
+ int error = 0;
+
+ for (int i = 0; i < mapSize; i++) {
+ int pix = colorMap[i];
+ if (rgb == pix) {
+ pixIdx = i;
+ break;
+ }
+ alphaError = Math.abs(alpha - (pix >>> 24));
+ if (alphaError <= minAlphaError) {
+ minAlphaError = alphaError;
+
+ int buf = ((pix >> 16) & 0xff) - red;
+ error = buf * buf;
+
+ if (error < minError) {
+ buf = ((pix >> 8) & 0xff) - green;
+ error += buf * buf;
+
+ if (error < minError) {
+ buf = (pix & 0xff) - blue;
+ error += buf * buf;
+
+ if (error < minError) {
+ pixIdx = i;
+ minError = error;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ cachetable[nextInsertIdx] = rgb;
+ cachetable[nextInsertIdx + 1] = pixIdx;
+
+ nextInsertIdx = (nextInsertIdx + 2) % (CACHESIZE * 2);
+ if (totalInserted < CACHESIZE) {
+ totalInserted++;
+ }
+
+ return createDataObject(pixIdx, pixel);
+ }
+
+ /**
+ * Converts an image from indexed to RGB format.
+ *
+ * @param raster the raster containing the source image
+ * @param forceARGB whether to use the default RGB color model
+ *
+ * @return the buffered image
+ *
+ * @throws IllegalArgumentException if the raster is not compatible with
+ * this color model
+ */
+ public BufferedImage convertToIntDiscrete(Raster raster,
+ boolean forceARGB) {
+
+ if (!isCompatibleRaster(raster)) {
+ // awt.265=The raster argument is not compatible with this IndexColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.265")); //$NON-NLS-1$
+ }
+
+ ColorModel model;
+ if (forceARGB || transparency == Transparency.TRANSLUCENT) {
+ model = ColorModel.getRGBdefault();
+ } else if (transparency == Transparency.BITMASK) {
+ model = new DirectColorModel(25, 0x00ff0000, 0x0000ff00,
+ 0x000000ff, 0x01000000);
+ } else {
+ model = new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff);
+ }
+
+ int w = raster.getWidth();
+ int h = raster.getHeight();
+
+ WritableRaster distRaster = model.createCompatibleWritableRaster(w, h);
+
+ int minX = raster.getMinX();
+ int minY = raster.getMinY();
+
+ Object obj = null;
+ int pixels[] = null;
+
+ for (int i = 0; i < h; i++, minY++) {
+ obj = raster.getDataElements(minX, minY, w, 1, obj);
+ if (obj instanceof byte[]) {
+ byte ba[] = (byte[]) obj;
+ if (pixels == null) {
+ pixels = new int[ba.length];
+ }
+ for (int j = 0; j < ba.length; j++) {
+ pixels[j] = colorMap[ba[j] & 0xff];
+ }
+ } else if (obj instanceof short[]) {
+ short sa[] = (short[]) obj;
+ if (pixels == null) {
+ pixels = new int[sa.length];
+ }
+ for (int j = 0; j < sa.length; j++) {
+ pixels[j] = colorMap[sa[j] & 0xffff];
+ }
+ }
+ if (obj instanceof int[]) {
+ int ia[] = (int[]) obj;
+ if (pixels == null) {
+ pixels = new int[ia.length];
+ }
+ for (int j = 0; j < ia.length; j++) {
+ pixels[j] = colorMap[ia[j]];
+ }
+ }
+
+ distRaster.setDataElements(0, i, w, 1, pixels);
+ }
+
+ return new BufferedImage(model, distRaster, false, null);
+ }
+
+ /**
+ * Gets the valid pixels.
+ *
+ * @return the valid pixels
+ */
+ public BigInteger getValidPixels() {
+ return validBits;
+ }
+
+ @Override
+ public String toString() {
+ // The output format based on 1.5 release behaviour.
+ // It could be reveled such way:
+ // BufferedImage bi = new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_INDEXED);
+ // ColorModel cm = bi.getColorModel();
+ // System.out.println(cm.toString());
+ String str = "IndexColorModel: #pixel_bits = " + pixel_bits + //$NON-NLS-1$
+ " numComponents = " + numComponents + " color space = " + cs + //$NON-NLS-1$ //$NON-NLS-2$
+ " transparency = "; //$NON-NLS-1$
+
+ if (transparency == Transparency.OPAQUE) {
+ str = str + "Transparency.OPAQUE"; //$NON-NLS-1$
+ } else if (transparency == Transparency.BITMASK) {
+ str = str + "Transparency.BITMASK"; //$NON-NLS-1$
+ } else {
+ str = str + "Transparency.TRANSLUCENT"; //$NON-NLS-1$
+ }
+
+ str = str + " transIndex = " + transparentIndex + " has alpha = " + //$NON-NLS-1$ //$NON-NLS-2$
+ hasAlpha + " isAlphaPre = " + isAlphaPremultiplied; //$NON-NLS-1$
+
+ return str;
+ }
+
+ @Override
+ public int[] getComponents(Object pixel, int components[], int offset) {
+ int pixIdx = -1;
+ if (pixel instanceof byte[]) {
+ byte ba[] = (byte[]) pixel;
+ pixIdx = ba[0] & 0xff;
+ } else if (pixel instanceof short[]) {
+ short sa[] = (short[]) pixel;
+ pixIdx = sa[0] & 0xffff;
+ } else if (pixel instanceof int[]) {
+ int ia[] = (int[]) pixel;
+ pixIdx = ia[0];
+ } else {
+ // awt.219=This transferType is not supported by this color model
+ throw new UnsupportedOperationException(Messages.getString("awt.219")); //$NON-NLS-1$
+ }
+
+ return getComponents(pixIdx, components, offset);
+ }
+
+ @Override
+ public WritableRaster createCompatibleWritableRaster(int w, int h) {
+ WritableRaster raster;
+ if (pixel_bits == 1 || pixel_bits == 2 || pixel_bits == 4) {
+ raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, w, h, 1,
+ pixel_bits, null);
+ } else if (pixel_bits <= 8) {
+ raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, w, h,
+ 1, null);
+ } else if (pixel_bits <= 16) {
+ raster = Raster.createInterleavedRaster(DataBuffer.TYPE_USHORT, w,
+ h, 1, null);
+ } else {
+ // awt.266=The number of bits in a pixel is greater than 16
+ throw new UnsupportedOperationException(Messages.getString("awt.266")); //$NON-NLS-1$
+ }
+
+ return raster;
+ }
+
+ @Override
+ public boolean isCompatibleSampleModel(SampleModel sm) {
+ if (sm == null) {
+ return false;
+ }
+
+ if (!(sm instanceof MultiPixelPackedSampleModel)
+ && !(sm instanceof ComponentSampleModel)) {
+ return false;
+ }
+
+ if (sm.getTransferType() != transferType) {
+ return false;
+ }
+ if (sm.getNumBands() != 1) {
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public SampleModel createCompatibleSampleModel(int w, int h) {
+ if (pixel_bits == 1 || pixel_bits == 2 || pixel_bits == 4) {
+ return new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, w, h,
+ pixel_bits);
+ }
+ int bandOffsets[] = new int[1];
+ bandOffsets[0] = 0;
+ return new ComponentSampleModel(transferType, w, h, 1, w,
+ bandOffsets);
+
+ }
+
+ @Override
+ public boolean isCompatibleRaster(Raster raster) {
+ int sampleSize = raster.getSampleModel().getSampleSize(0);
+ return (raster.getTransferType() == transferType &&
+ raster.getNumBands() == 1 && (1 << sampleSize) >= mapSize);
+ }
+
+ @Override
+ public int getDataElement(int components[], int offset) {
+ int rgb = (components[offset] << 16) | (components[offset + 1]) << 8
+ | components[offset + 2];
+
+ if (hasAlpha) {
+ rgb |= components[offset + 3] << 24;
+ } else {
+ rgb |= 0xff000000;
+ }
+
+ int pixel;
+
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte ba[] = (byte[]) getDataElements(rgb, null);
+ pixel = ba[0] & 0xff;
+ break;
+ case DataBuffer.TYPE_USHORT:
+ short sa[] = (short[]) getDataElements(rgb, null);
+ pixel = sa[0] & 0xffff;
+ break;
+ default:
+ // awt.267=The transferType is invalid
+ throw new UnsupportedOperationException(Messages.getString("awt.267")); //$NON-NLS-1$
+ }
+
+ return pixel;
+ }
+
+ /**
+ * Gets the color map.
+ *
+ * @param rgb the destination array where the color map is written
+ */
+ public final void getRGBs(int rgb[]) {
+ System.arraycopy(colorMap, 0, rgb, 0, mapSize);
+ }
+
+ /**
+ * Gets the red component of the color map.
+ *
+ * @param r the destination array
+ */
+ public final void getReds(byte r[]) {
+ for (int i = 0; i < mapSize; i++) {
+ r[i] = (byte) (colorMap[i] >> 16);
+ }
+ }
+
+ /**
+ * Gets the green component of the color map.
+ *
+ * @param g the destination array
+ */
+ public final void getGreens(byte g[]) {
+ for (int i = 0; i < mapSize; i++) {
+ g[i] = (byte) (colorMap[i] >> 8);
+ }
+ }
+
+ /**
+ * Gets the blue component of the color map.
+ *
+ * @param b the destination array
+ */
+ public final void getBlues(byte b[]) {
+ for (int i = 0; i < mapSize; i++) {
+ b[i] = (byte) colorMap[i];
+ }
+ }
+
+ /**
+ * Gets the alpha component of the color map.
+ *
+ * @param a the destination array
+ */
+ public final void getAlphas(byte a[]) {
+ for (int i = 0; i < mapSize; i++) {
+ a[i] = (byte) (colorMap[i] >> 24);
+ }
+ }
+
+ @Override
+ public int[] getComponents(int pixel, int components[], int offset) {
+ if (components == null) {
+ components = new int[offset + numComponents];
+ }
+
+ components[offset + 0] = getRed(pixel);
+ components[offset + 1] = getGreen(pixel);
+ components[offset + 2] = getBlue(pixel);
+ if (hasAlpha && (components.length - offset) > 3) {
+ components[offset + 3] = getAlpha(pixel);
+ }
+
+ return components;
+ }
+
+ /**
+ * Checks if the specified pixel is valid for this color model.
+ *
+ * @param pixel the pixel
+ *
+ * @return true, if the pixel is valid
+ */
+ public boolean isValid(int pixel) {
+ if (validBits == null) {
+ return (pixel >= 0 && pixel < mapSize);
+ }
+ return (pixel < mapSize && validBits.testBit(pixel));
+ }
+
+ @Override
+ public final int getRed(int pixel) {
+ return (colorMap[pixel] >> 16) & 0xff;
+ }
+
+ @Override
+ public final int getRGB(int pixel) {
+ return colorMap[pixel];
+ }
+
+ @Override
+ public final int getGreen(int pixel) {
+ return (colorMap[pixel] >> 8) & 0xff;
+ }
+
+ @Override
+ public final int getBlue(int pixel) {
+ return colorMap[pixel] & 0xff;
+ }
+
+ @Override
+ public final int getAlpha(int pixel) {
+ return (colorMap[pixel] >> 24) & 0xff;
+ }
+
+ @Override
+ public int[] getComponentSize() {
+ return bits.clone();
+ }
+
+ /**
+ * Checks if this color model validates pixels.
+ *
+ * @return true, if all pixels are valid, otherwise false
+ */
+ public boolean isValid() {
+ return (validBits == null);
+ }
+
+ @Override
+ public void finalize() {
+ // TODO: implement
+ return;
+ }
+
+ /**
+ * Gets the index that represents the transparent pixel.
+ *
+ * @return the index that represents the transparent pixel
+ */
+ public final int getTransparentPixel() {
+ return transparentIndex;
+ }
+
+ @Override
+ public int getTransparency() {
+ return transparency;
+ }
+
+ /**
+ * Gets the size of the color map.
+ *
+ * @return the map size
+ */
+ public final int getMapSize() {
+ return mapSize;
+ }
+
+ /**
+ * Creates the color map.
+ *
+ * @param size the size
+ * @param r the r
+ * @param g the g
+ * @param b the b
+ * @param a the a
+ * @param trans the trans
+ */
+ private void createColorMap(int size, byte r[], byte g[], byte b[],
+ byte a[], int trans) {
+ if (size < 1) {
+ // awt.264=Size of the color map is less than 1
+ throw new IllegalArgumentException(Messages.getString("awt.264")); //$NON-NLS-1$
+ }
+
+ mapSize = size;
+ colorMap = new int[mapSize];
+ if (trans >= 0 && trans < mapSize) {
+ transparency = Transparency.BITMASK;
+ transparentIndex = trans;
+ } else {
+ transparency = Transparency.OPAQUE;
+ transparentIndex = -1;
+ }
+ int alpha = 0;
+
+ for (int i = 0; i < mapSize; i++) {
+ colorMap[i] = ((r[i] & 0xff) << 16) | ((g[i] & 0xff) << 8) |
+ (b[i] & 0xff);
+
+ if (trans == i) {
+ continue;
+ }
+
+ if (a == null) {
+ colorMap[i] |= 0xff000000;
+ } else {
+ alpha = a[i] & 0xff;
+ if (alpha == 0xff) {
+ colorMap[i] |= 0xff000000;
+ } else if (alpha == 0) {
+ if (transparency == Transparency.OPAQUE) {
+ transparency = Transparency.BITMASK;
+ }
+ if (transparentIndex < 0) {
+ transparentIndex = i;
+ }
+ } else {
+ colorMap[i] |= (a[i] & 0xff) << 24;
+ if (transparency != Transparency.TRANSLUCENT) {
+ transparency = Transparency.TRANSLUCENT;
+ }
+ }
+ }
+
+ }
+
+ }
+
+ /**
+ * This method checking, if Color Map has Gray Palette.
+ */
+ private void checkPalette() {
+ grayPalette = false;
+ if (transparency > Transparency.OPAQUE) {
+ return;
+ }
+ int rgb = 0;
+
+ for (int i = 0; i < mapSize; i++) {
+ rgb = colorMap[i];
+ if (((rgb >> 16) & 0xff) != ((rgb >> 8) & 0xff) ||
+ ((rgb >> 8) & 0xff) != (rgb & 0xff)) {
+ return;
+ }
+ }
+ grayPalette = true;
+ }
+
+ /**
+ * Construction an array pixel representation.
+ *
+ * @param colorMapIdx - index into Color Map
+ * @param pixel - pixel
+ *
+ * @return - an array pixel representation
+ */
+ private Object createDataObject(int colorMapIdx, Object pixel) {
+ if (pixel == null) {
+ switch (transferType) {
+ case DataBuffer.TYPE_BYTE:
+ byte[] ba = new byte[1];
+ ba[0] = (byte) colorMapIdx;
+ pixel = ba;
+ break;
+ case DataBuffer.TYPE_USHORT:
+ short[] sa = new short[1];
+ sa[0] = (short) colorMapIdx;
+ pixel = sa;
+ break;
+ default:
+ // awt.267=The transferType is invalid
+ throw new UnsupportedOperationException(Messages.getString("awt.267")); //$NON-NLS-1$
+ }
+ } else if (pixel instanceof byte[]
+ && transferType == DataBuffer.TYPE_BYTE) {
+ byte ba[] = (byte[]) pixel;
+ ba[0] = (byte) colorMapIdx;
+ pixel = ba;
+ } else if (pixel instanceof short[]&&
+ transferType == DataBuffer.TYPE_USHORT) {
+ short[] sa = (short[]) pixel;
+ sa[0] = (short) colorMapIdx;
+ pixel = sa;
+ } else if (pixel instanceof int[]) {
+ int ia[] = (int[]) pixel;
+ ia[0] = colorMapIdx;
+ pixel = ia;
+ } else {
+ // awt.268=The pixel is not a primitive array of type transferType
+ throw new ClassCastException(Messages.getString("awt.268")); //$NON-NLS-1$
+ }
+ return pixel;
+ }
+
+ /**
+ * Creates the bits.
+ *
+ * @param hasAlpha the has alpha
+ *
+ * @return the int[]
+ */
+ private static int[] createBits(boolean hasAlpha) {
+
+ int numChannels;
+ if (hasAlpha) {
+ numChannels = 4;
+ } else {
+ numChannels = 3;
+ }
+
+ int bits[] = new int[numChannels];
+ for (int i = 0; i < numChannels; i++) {
+ bits[i] = 8;
+ }
+
+ return bits;
+
+ }
+
+ /**
+ * Validate transfer type.
+ *
+ * @param transferType the transfer type
+ *
+ * @return the int
+ */
+ private static int validateTransferType(int transferType) {
+ if (transferType != DataBuffer.TYPE_BYTE &&
+ transferType != DataBuffer.TYPE_USHORT) {
+ // awt.269=The transferType is not one of DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT
+ throw new IllegalArgumentException(Messages.getString("awt.269")); //$NON-NLS-1$
+ }
+ return transferType;
+ }
+
+ /**
+ * Checks if is gray pallete.
+ *
+ * @return true, if is gray pallete
+ */
+ boolean isGrayPallete(){
+ return grayPalette;
+ }
+
+}
+
+
diff --git a/awt/java/awt/image/Kernel.java b/awt/java/awt/image/Kernel.java
new file mode 100644
index 0000000..c6f00e2
--- /dev/null
+++ b/awt/java/awt/image/Kernel.java
@@ -0,0 +1,138 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ *
+ * @date: Sep 28, 2005
+ */
+
+package java.awt.image;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Kernel class provides a matrix. This matrix is stored as a float array
+ * which describes how a specified pixel affects the value calculated for
+ * the pixel's position in the output image of a filtering operation.
+ * The X, Y origins indicate the kernel matrix element which corresponds to
+ * the pixel position for which an output value is being calculated.
+ */
+public class Kernel implements Cloneable {
+
+ /** The x origin. */
+ private final int xOrigin;
+
+ /** The y origin. */
+ private final int yOrigin;
+
+ /** The width. */
+ private int width;
+
+ /** The height. */
+ private int height;
+
+ /** The data. */
+ float data[];
+
+ /**
+ * Instantiates a new Kernel with the specified float array.
+ * The width*height elements of the data array are copied.
+ *
+ * @param width the width of the Kernel.
+ * @param height the height of the Kernel.
+ * @param data the data of Kernel.
+ */
+ public Kernel(int width, int height, float[] data) {
+ int dataLength = width*height;
+ if (data.length < dataLength) {
+ // awt.22B=Length of data should not be less than width*height
+ throw new IllegalArgumentException(Messages.getString("awt.22B")); //$NON-NLS-1$
+ }
+
+ this.width = width;
+ this.height = height;
+
+ this.data = new float[dataLength];
+ System.arraycopy(data, 0, this.data, 0, dataLength);
+
+ xOrigin = (width-1)/2;
+ yOrigin = (height-1)/2;
+ }
+
+ /**
+ * Gets the width of this Kernel.
+ *
+ * @return the width of this Kernel.
+ */
+ public final int getWidth() {
+ return width;
+ }
+
+ /**
+ * Gets the height of this Kernel.
+ *
+ * @return the height of this Kernel.
+ */
+ public final int getHeight() {
+ return height;
+ }
+
+ /**
+ * Gets the float data array of this Kernel.
+ *
+ * @param data the float array where the resulted data will be stored.
+ *
+ * @return the float data array of this Kernel.
+ */
+ public final float[] getKernelData(float[] data) {
+ if (data == null) {
+ data = new float[this.data.length];
+ }
+ System.arraycopy(this.data, 0, data, 0, this.data.length);
+
+ return data;
+ }
+
+ /**
+ * Gets the X origin of this Kernel.
+ *
+ * @return the X origin of this Kernel.
+ */
+ public final int getXOrigin() {
+ return xOrigin;
+ }
+
+ /**
+ * Gets the Y origin of this Kernel.
+ *
+ * @return the Y origin of this Kernel.
+ */
+ public final int getYOrigin() {
+ return yOrigin;
+ }
+
+ /**
+ * Returns a copy of this Kernel object.
+ *
+ * @return the copy of this Kernel object.
+ */
+ @Override
+ public Object clone() {
+ return new Kernel(width, height, data);
+ }
+}
diff --git a/awt/java/awt/image/LookupOp.java b/awt/java/awt/image/LookupOp.java
new file mode 100644
index 0000000..f9bd2c7
--- /dev/null
+++ b/awt/java/awt/image/LookupOp.java
@@ -0,0 +1,647 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ *
+ * @date: Oct 14, 2005
+ */
+
+package java.awt.image;
+
+import java.awt.*;
+import java.awt.geom.Rectangle2D;
+import java.awt.geom.Point2D;
+import java.util.Arrays;
+
+import org.apache.harmony.awt.gl.AwtImageBackdoorAccessor;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The LookupOp class perfoms a lookup operation which transforms a
+ * source image by filtering each band using a table of data.
+ * The table may contain a single array or it may contain a
+ * different data array for each band of the image.
+ */
+public class LookupOp implements BufferedImageOp, RasterOp {
+
+ /** The lut. */
+ private final LookupTable lut;
+
+ /** The hints. */
+ private RenderingHints hints;
+
+ // TODO remove when this field is used
+ /** The can use ipp. */
+ @SuppressWarnings("unused")
+ private final boolean canUseIpp;
+
+ // We don't create levels/values when it is possible to reuse old
+ /** The cached levels. */
+ private int cachedLevels[];
+
+ /** The cached values. */
+ private int cachedValues[];
+ // Number of channels for which cache is valid.
+ // If negative number of channels is same as positive but skipAlpha was specified
+ /** The valid for channels. */
+ private int validForChannels;
+
+ /** The level initializer. */
+ static int levelInitializer[] = new int[0x10000];
+
+ static {
+ // TODO
+ // System.loadLibrary("imageops");
+
+ for (int i=1; i<=0x10000; i++) {
+ levelInitializer[i-1] = i;
+ }
+ }
+
+ /**
+ * Instantiates a new LookupOp object from the specified
+ * LookupTable object and a RenderingHints object.
+ *
+ * @param lookup the specified LookupTable object.
+ * @param hints the RenderingHints object or null.
+ */
+ public LookupOp(LookupTable lookup, RenderingHints hints) {
+ if (lookup == null){
+ throw new NullPointerException(Messages.getString("awt.01", "lookup")); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ lut = lookup;
+ this.hints = hints;
+ canUseIpp = lut instanceof ByteLookupTable || lut instanceof ShortLookupTable;
+ }
+
+ /**
+ * Gets the LookupTable of the specified Object.
+ *
+ * @return the LookupTable of the specified Object.
+ */
+ public final LookupTable getTable() {
+ return lut;
+ }
+
+ public final RenderingHints getRenderingHints() {
+ return hints;
+ }
+
+ public final Point2D getPoint2D(Point2D srcPt, Point2D dstPt) {
+ if (dstPt == null) {
+ dstPt = new Point2D.Float();
+ }
+
+ dstPt.setLocation(srcPt);
+ return dstPt;
+ }
+
+ public final Rectangle2D getBounds2D(Raster src) {
+ return src.getBounds();
+ }
+
+ public final Rectangle2D getBounds2D(BufferedImage src) {
+ return getBounds2D(src.getRaster());
+ }
+
+ public WritableRaster createCompatibleDestRaster(Raster src) {
+ return src.createCompatibleWritableRaster();
+ }
+
+ public BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel dstCM) {
+ if (dstCM == null) {
+ dstCM = src.getColorModel();
+
+ // Sync transfer type with LUT for component color model
+ if (dstCM instanceof ComponentColorModel) {
+ int transferType = dstCM.getTransferType();
+ if (lut instanceof ByteLookupTable) {
+ transferType = DataBuffer.TYPE_BYTE;
+ } else if (lut instanceof ShortLookupTable) {
+ transferType = DataBuffer.TYPE_SHORT;
+ }
+
+ dstCM = new ComponentColorModel(
+ dstCM.cs,
+ dstCM.hasAlpha(),
+ dstCM.isAlphaPremultiplied,
+ dstCM.transparency,
+ transferType
+ );
+ }
+ }
+
+ WritableRaster r =
+ dstCM.isCompatibleSampleModel(src.getSampleModel()) ?
+ src.getRaster().createCompatibleWritableRaster(src.getWidth(), src.getHeight()) :
+ dstCM.createCompatibleWritableRaster(src.getWidth(), src.getHeight());
+
+ return new BufferedImage(
+ dstCM,
+ r,
+ dstCM.isAlphaPremultiplied(),
+ null
+ );
+ }
+
+ public final WritableRaster filter(Raster src, WritableRaster dst) {
+ if (dst == null) {
+ dst = createCompatibleDestRaster(src);
+ } else {
+ if (src.getNumBands() != dst.getNumBands()) {
+ throw new IllegalArgumentException(Messages.getString("awt.237")); //$NON-NLS-1$ }
+ }
+ if (src.getWidth() != dst.getWidth()){
+ throw new IllegalArgumentException(Messages.getString("awt.28F")); //$NON-NLS-1$ }
+ }
+ if (src.getHeight() != dst.getHeight()){
+ throw new IllegalArgumentException(Messages.getString("awt.290")); //$NON-NLS-1$ }
+ }
+ }
+
+ if (lut.getNumComponents() != 1 && lut.getNumComponents() != src.getNumBands()) {
+ // awt.238=The number of arrays in the LookupTable does not meet the restrictions
+ throw new IllegalArgumentException(Messages.getString("awt.238")); //$NON-NLS-1$
+ }
+
+ // TODO
+ // if (!canUseIpp || ippFilter(src, dst, BufferedImage.TYPE_CUSTOM, false) != 0)
+ if (slowFilter(src, dst, false) != 0) {
+ // awt.21F=Unable to transform source
+ throw new ImagingOpException (Messages.getString("awt.21F")); //$NON-NLS-1$
+ }
+
+ return dst;
+ }
+
+ public final BufferedImage filter(BufferedImage src, BufferedImage dst) {
+ ColorModel srcCM = src.getColorModel();
+
+ if (srcCM instanceof IndexColorModel) {
+ // awt.220=Source should not have IndexColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.220")); //$NON-NLS-1$
+ }
+
+ // Check if the number of scaling factors matches the number of bands
+ int nComponents = srcCM.getNumComponents();
+ int nLUTComponents = lut.getNumComponents();
+ boolean skipAlpha;
+ if (srcCM.hasAlpha()) {
+ if (nLUTComponents == 1 || nLUTComponents == nComponents-1) {
+ skipAlpha = true;
+ } else if (nLUTComponents == nComponents) {
+ skipAlpha = false;
+ } else {
+ // awt.229=Number of components in the LUT does not match the number of bands
+ throw new IllegalArgumentException(Messages.getString("awt.229")); //$NON-NLS-1$
+ }
+ } else if (nLUTComponents == 1 || nLUTComponents == nComponents) {
+ skipAlpha = false;
+ } else {
+ // awt.229=Number of components in the LUT does not match the number of bands
+ throw new IllegalArgumentException(Messages.getString("awt.229")); //$NON-NLS-1$
+ }
+
+ BufferedImage finalDst = null;
+ if (dst == null) {
+ finalDst = dst;
+ dst = createCompatibleDestImage(src, null);
+ } else {
+ if (src.getWidth() != dst.getWidth()){
+ throw new IllegalArgumentException(Messages.getString("awt.291")); //$NON-NLS-1$
+ }
+
+ if (src.getHeight() != dst.getHeight()){
+ throw new IllegalArgumentException(Messages.getString("awt.292")); //$NON-NLS-1$
+ }
+
+ if (!srcCM.equals(dst.getColorModel())) {
+ // Treat BufferedImage.TYPE_INT_RGB and
+ // BufferedImage.TYPE_INT_ARGB as same
+ if (!((src.getType() == BufferedImage.TYPE_INT_RGB || src
+ .getType() == BufferedImage.TYPE_INT_ARGB) && (dst
+ .getType() == BufferedImage.TYPE_INT_RGB || dst
+ .getType() == BufferedImage.TYPE_INT_ARGB))) {
+ finalDst = dst;
+ dst = createCompatibleDestImage(src, null);
+ }
+ }
+ }
+
+ // TODO
+ //if (!canUseIpp || ippFilter(src.getRaster(), dst.getRaster(), src.getType(), skipAlpha) != 0)
+ if (slowFilter(src.getRaster(), dst.getRaster(), skipAlpha) != 0) {
+ // awt.21F=Unable to transform source
+ throw new ImagingOpException (Messages.getString("awt.21F")); //$NON-NLS-1$
+ }
+
+ if (finalDst != null) {
+ Graphics2D g = finalDst.createGraphics();
+ g.setComposite(AlphaComposite.Src);
+ g.drawImage(dst, 0, 0, null);
+ } else {
+ finalDst = dst;
+ }
+
+ return dst;
+ }
+
+ /**
+ * Slow filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ * @param skipAlpha the skip alpha
+ *
+ * @return the int
+ */
+ private final int slowFilter(Raster src, WritableRaster dst, boolean skipAlpha) {
+ int minSrcX = src.getMinX();
+ int minDstX = dst.getMinX();
+ int minSrcY = src.getMinY();
+ int minDstY = dst.getMinY();
+
+ int skippingChannels = skipAlpha ? 1 : 0;
+ int numBands2Process = src.getNumBands() - skippingChannels;
+
+ int numBands = src.getNumBands();
+ int srcHeight = src.getHeight();
+ int srcWidth = src.getWidth();
+
+ int[] pixels = null;
+ int offset = lut.getOffset();
+
+ if (lut instanceof ByteLookupTable){
+ byte[][] byteData = ((ByteLookupTable)lut).getTable();
+ pixels = src.getPixels(minSrcX, minSrcY, srcWidth, srcHeight, pixels);
+
+ if (lut.getNumComponents() != 1){
+ for (int i=0; i < pixels.length; i+= numBands){
+ for (int b = 0; b < numBands2Process; b++){
+ pixels[i+b] = byteData[b][pixels[i+b]-offset] & 0xFF;
+ }
+ }
+ } else {
+ for (int i=0; i < pixels.length; i+= numBands){
+ for (int b = 0; b < numBands2Process; b++){
+ pixels[i+b] = byteData[0][pixels[i+b]-offset] & 0xFF;
+ }
+ }
+ }
+
+ dst.setPixels(minDstX, minDstY, srcWidth, srcHeight, pixels);
+ } else if (lut instanceof ShortLookupTable){
+ short[][] shortData = ((ShortLookupTable)lut).getTable();
+ pixels = src.getPixels(minSrcX, minSrcY, srcWidth, srcHeight, pixels);
+
+ if (lut.getNumComponents() != 1){
+ for (int i=0; i < pixels.length; i+= numBands){
+ for (int b = 0; b < numBands2Process; b++){
+ pixels[i+b] = shortData[b][pixels[i+b]-offset] & 0xFFFF;
+ }
+ }
+ } else {
+ for (int i=0; i < pixels.length; i+= numBands){
+ for (int b = 0; b < numBands2Process; b++){
+ pixels[i+b] = shortData[0][pixels[i+b]-offset] & 0xFFFF;
+ }
+ }
+ }
+
+ dst.setPixels(minDstX, minDstY, srcWidth, srcHeight, pixels);
+ } else {
+ int pixel[] = new int[src.getNumBands()];
+ int maxY = minSrcY + srcHeight;
+ int maxX = minSrcX + srcWidth;
+ for (int srcY=minSrcY, dstY = minDstY; srcY < maxY; srcY++, dstY++){
+ for (int srcX=minSrcX, dstX = minDstX; srcX < maxX; srcX++, dstX++){
+ src.getPixel(srcX, srcY, pixel);
+ lut.lookupPixel(pixel, pixel);
+ dst.setPixel(dstX, dstY, pixel);
+ }
+ }
+ }
+
+ return 0;
+ }
+
+ /**
+ * Creates the byte levels.
+ *
+ * @param channels the channels
+ * @param skipAlpha the skip alpha
+ * @param levels the levels
+ * @param values the values
+ * @param channelsOrder the channels order
+ */
+ private final void createByteLevels(
+ int channels, boolean skipAlpha,
+ int levels[], int values[], int channelsOrder[]
+ ) {
+ byte data[][] = ((ByteLookupTable)lut).getTable();
+ int nLevels = data[0].length;
+ int offset = lut.getOffset();
+
+ // Use one data array for all channels or use several data arrays
+ int dataIncrement = data.length > 1 ? 1 : 0;
+
+ for (int ch = 0, dataIdx = 0; ch<channels; dataIdx+=dataIncrement, ch++) {
+ int channelOffset = channelsOrder == null ? ch : channelsOrder[ch];
+ int channelBase = nLevels * channelOffset;
+
+ // Skip last channel if needed, zero values are OK -
+ // no changes to the channel information will be done in IPP
+ if ((channelOffset == channels-1 && skipAlpha) || (dataIdx >= data.length)) {
+ continue;
+ }
+
+ System.arraycopy(levelInitializer, offset, levels, channelBase, nLevels);
+ for (int from=0, to=channelBase; from<nLevels; from++, to++) {
+ values[to] = data[dataIdx][from] & 0xFF;
+ }
+ }
+ }
+
+ /**
+ * Creates the short levels.
+ *
+ * @param channels the channels
+ * @param skipAlpha the skip alpha
+ * @param levels the levels
+ * @param values the values
+ * @param channelsOrder the channels order
+ */
+ private final void createShortLevels(
+ int channels, boolean skipAlpha,
+ int levels[], int values[], int channelsOrder[]
+ ) {
+ short data[][] = ((ShortLookupTable)lut).getTable();
+ int nLevels = data[0].length;
+ int offset = lut.getOffset();
+
+ // Use one data array for all channels or use several data arrays
+ int dataIncrement = data.length > 1 ? 1 : 0;
+
+ for (int ch = 0, dataIdx = 0; ch<channels; dataIdx+=dataIncrement, ch++) {
+ int channelOffset = channelsOrder == null ? ch : channelsOrder[ch];
+
+ // Skip last channel if needed, zero values are OK -
+ // no changes to the channel information will be done in IPP
+ if ((channelOffset == channels-1 && skipAlpha) || (dataIdx >= data.length)) {
+ continue;
+ }
+
+ int channelBase = nLevels * channelOffset;
+ System.arraycopy(levelInitializer, offset, levels, channelBase, nLevels);
+ for (int from=0, to=channelBase; from<nLevels; from++, to++) {
+ values[to] = data[dataIdx][from] & 0xFFFF;
+ }
+ }
+ }
+
+ // TODO remove when this method is used
+ /**
+ * Ipp filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ * @param imageType the image type
+ * @param skipAlpha the skip alpha
+ *
+ * @return the int
+ */
+ @SuppressWarnings("unused")
+ private final int ippFilter(
+ Raster src, WritableRaster dst,
+ int imageType, boolean skipAlpha
+ ) {
+ int res;
+
+ int srcStride, dstStride;
+ int channels;
+ int offsets[] = null;
+ int channelsOrder[] = null;
+
+ switch (imageType) {
+ case BufferedImage.TYPE_INT_ARGB:
+ case BufferedImage.TYPE_INT_ARGB_PRE:
+ case BufferedImage.TYPE_INT_RGB: {
+ channels = 4;
+ srcStride = src.getWidth()*4;
+ dstStride = dst.getWidth()*4;
+ channelsOrder = new int[] {2, 1, 0, 3};
+ break;
+ }
+
+ case BufferedImage.TYPE_4BYTE_ABGR:
+ case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+ case BufferedImage.TYPE_INT_BGR: {
+ channels = 4;
+ srcStride = src.getWidth()*4;
+ dstStride = dst.getWidth()*4;
+ break;
+ }
+
+ case BufferedImage.TYPE_BYTE_GRAY: {
+ channels = 1;
+ srcStride = src.getWidth();
+ dstStride = dst.getWidth();
+ break;
+ }
+
+ case BufferedImage.TYPE_3BYTE_BGR: {
+ channels = 3;
+ srcStride = src.getWidth()*3;
+ dstStride = dst.getWidth()*3;
+ channelsOrder = new int[] {2, 1, 0};
+ break;
+ }
+
+ case BufferedImage.TYPE_USHORT_GRAY:
+ case BufferedImage.TYPE_USHORT_565_RGB:
+ case BufferedImage.TYPE_USHORT_555_RGB:
+ case BufferedImage.TYPE_BYTE_BINARY: {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ default: {
+ SampleModel srcSM = src.getSampleModel();
+ SampleModel dstSM = dst.getSampleModel();
+
+ if (
+ srcSM instanceof PixelInterleavedSampleModel &&
+ dstSM instanceof PixelInterleavedSampleModel
+ ) {
+ // Check PixelInterleavedSampleModel
+ if (
+ srcSM.getDataType() != DataBuffer.TYPE_BYTE ||
+ dstSM.getDataType() != DataBuffer.TYPE_BYTE
+ ) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ // Have IPP functions for 1, 3 and 4 channels
+ channels = srcSM.getNumBands();
+ if (!(channels == 1 || channels == 3 || channels == 4)) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ srcStride = ((ComponentSampleModel) srcSM).getScanlineStride();
+ dstStride = ((ComponentSampleModel) dstSM).getScanlineStride();
+
+ channelsOrder = ((ComponentSampleModel) srcSM).getBandOffsets();
+ } else if (
+ srcSM instanceof SinglePixelPackedSampleModel &&
+ dstSM instanceof SinglePixelPackedSampleModel
+ ) {
+ // Check SinglePixelPackedSampleModel
+ SinglePixelPackedSampleModel sppsm1 =
+ (SinglePixelPackedSampleModel) srcSM;
+ SinglePixelPackedSampleModel sppsm2 =
+ (SinglePixelPackedSampleModel) dstSM;
+
+ channels = sppsm1.getNumBands();
+
+ // TYPE_INT_RGB, TYPE_INT_ARGB...
+ if (
+ sppsm1.getDataType() != DataBuffer.TYPE_INT ||
+ sppsm2.getDataType() != DataBuffer.TYPE_INT ||
+ !(channels == 3 || channels == 4)
+ ) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ // Check compatibility of sample models
+ if (
+ !Arrays.equals(sppsm1.getBitOffsets(), sppsm2.getBitOffsets()) ||
+ !Arrays.equals(sppsm1.getBitMasks(), sppsm2.getBitMasks())
+ ) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ for (int i=0; i<channels; i++) {
+ if (sppsm1.getSampleSize(i) != 8) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+ }
+
+ channelsOrder = new int[channels];
+ int bitOffsets[] = sppsm1.getBitOffsets();
+ for (int i=0; i<channels; i++) {
+ channelsOrder[i] = bitOffsets[i] / 8;
+ }
+
+ if (channels == 3) { // Don't skip channel now, could be optimized
+ channels = 4;
+ }
+
+ srcStride = sppsm1.getScanlineStride() * 4;
+ dstStride = sppsm2.getScanlineStride() * 4;
+ } else {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ // Fill offsets if there's a child raster
+ if (src.getParent() != null || dst.getParent() != null) {
+ if (
+ src.getSampleModelTranslateX() != 0 ||
+ src.getSampleModelTranslateY() != 0 ||
+ dst.getSampleModelTranslateX() != 0 ||
+ dst.getSampleModelTranslateY() != 0
+ ) {
+ offsets = new int[4];
+ offsets[0] = -src.getSampleModelTranslateX() + src.getMinX();
+ offsets[1] = -src.getSampleModelTranslateY() + src.getMinY();
+ offsets[2] = -dst.getSampleModelTranslateX() + dst.getMinX();
+ offsets[3] = -dst.getSampleModelTranslateY() + dst.getMinY();
+ }
+ }
+ }
+ }
+
+ int levels[] = null, values[] = null;
+ int channelMultiplier = skipAlpha ? -1 : 1;
+ if (channelMultiplier*channels == validForChannels) { // use existing levels/values
+ levels = cachedLevels;
+ values = cachedValues;
+ } else { // create new levels/values
+ if (lut instanceof ByteLookupTable) {
+ byte data[][] = ((ByteLookupTable)lut).getTable();
+ levels = new int[channels*data[0].length];
+ values = new int[channels*data[0].length];
+ createByteLevels(channels, skipAlpha, levels, values, channelsOrder);
+ } else if (lut instanceof ShortLookupTable) {
+ short data[][] = ((ShortLookupTable)lut).getTable();
+ levels = new int[channels*data[0].length];
+ values = new int[channels*data[0].length];
+ createShortLevels(channels, skipAlpha, levels, values, channelsOrder);
+ }
+
+ // cache levels/values
+ validForChannels = channelMultiplier*channels;
+ cachedLevels = levels;
+ cachedValues = values;
+ }
+
+ Object srcData, dstData;
+ AwtImageBackdoorAccessor dbAccess = AwtImageBackdoorAccessor.getInstance();
+ try {
+ srcData = dbAccess.getData(src.getDataBuffer());
+ dstData = dbAccess.getData(dst.getDataBuffer());
+ } catch (IllegalArgumentException e) {
+ return -1; // Unknown data buffer type
+ }
+
+ res = ippLUT(
+ srcData, src.getWidth(), src.getHeight(), srcStride,
+ dstData, dst.getWidth(), dst.getHeight(), dstStride,
+ levels, values,
+ channels, offsets,
+ false
+ );
+
+ return res;
+ }
+
+ /**
+ * Ipp lut.
+ *
+ * @param src the src
+ * @param srcWidth the src width
+ * @param srcHeight the src height
+ * @param srcStride the src stride
+ * @param dst the dst
+ * @param dstWidth the dst width
+ * @param dstHeight the dst height
+ * @param dstStride the dst stride
+ * @param levels the levels
+ * @param values the values
+ * @param channels the channels
+ * @param offsets the offsets
+ * @param linear the linear
+ *
+ * @return the int
+ */
+ final static native int ippLUT(
+ Object src, int srcWidth, int srcHeight, int srcStride,
+ Object dst, int dstWidth, int dstHeight, int dstStride,
+ int levels[], int values[],
+ int channels, int offsets[],
+ boolean linear
+ );
+}
diff --git a/awt/java/awt/image/LookupTable.java b/awt/java/awt/image/LookupTable.java
new file mode 100644
index 0000000..d15f23c
--- /dev/null
+++ b/awt/java/awt/image/LookupTable.java
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ *
+ * @date: Oct 14, 2005
+ */
+
+package java.awt.image;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * This abstract LookupTable class represents lookup table which
+ * is defined with the number of components and offset value.
+ * ByteLookupTable and ShortLookupTable classes are subclasses of
+ * LookupTable which contains byte and short data tables as
+ * an input arrays for bands or components of image.
+ */
+public abstract class LookupTable {
+
+ /** The offset. */
+ private int offset;
+
+ /** The num components. */
+ private int numComponents;
+
+ /**
+ * Instantiates a new LookupTable with the specified offset value
+ * and number of components.
+ *
+ * @param offset the offset value.
+ * @param numComponents the number of components.
+ */
+ protected LookupTable(int offset, int numComponents) {
+ if (offset < 0) {
+ // awt.232=Offset should be not less than zero
+ throw new IllegalArgumentException(Messages.getString("awt.232")); //$NON-NLS-1$
+ }
+ if (numComponents < 1) {
+ // awt.233=Number of components should be positive
+ throw new IllegalArgumentException(Messages.getString("awt.233")); //$NON-NLS-1$
+ }
+
+ this.offset = offset;
+ this.numComponents = numComponents;
+ }
+
+ /**
+ * Gets the offset value of this Lookup table.
+ *
+ * @return the offset value of this Lookup table.
+ */
+ public int getOffset() {
+ return offset;
+ }
+
+ /**
+ * Gets the number of components of this Lookup table.
+ *
+ * @return the number components of this Lookup table.
+ */
+ public int getNumComponents() {
+ return numComponents;
+ }
+
+ /**
+ * Returns a int array which contains samples of the specified
+ * pixel which is translated with the lookup table of this
+ * LookupTable. The resulted array is stored to the dst array.
+ *
+ * @param src the source array.
+ * @param dst the destination array where the result can be stored.
+ *
+ * @return the int array of translated samples of a pixel.
+ */
+ public abstract int[] lookupPixel(int[] src, int[] dst);
+}
diff --git a/awt/java/awt/image/MemoryImageSource.java b/awt/java/awt/image/MemoryImageSource.java
new file mode 100644
index 0000000..983f19e
--- /dev/null
+++ b/awt/java/awt/image/MemoryImageSource.java
@@ -0,0 +1,512 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.util.Hashtable;
+import java.util.Vector;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The MemoryImageSource class is used to produces pixels of an image from
+ * an array. This class can manage a memory image which
+ * contains an animation or custom rendering.
+ */
+public class MemoryImageSource implements ImageProducer {
+
+ /** The width. */
+ int width;
+
+ /** The height. */
+ int height;
+
+ /** The cm. */
+ ColorModel cm;
+
+ /** The b data. */
+ byte bData[];
+
+ /** The i data. */
+ int iData[];
+
+ /** The offset. */
+ int offset;
+
+ /** The scanline. */
+ int scanline;
+
+ /** The properties. */
+ Hashtable<?, ?> properties;
+
+ /** The consumers. */
+ Vector<ImageConsumer> consumers;
+
+ /** The animated. */
+ boolean animated;
+
+ /** The fullbuffers. */
+ boolean fullbuffers;
+
+ /** The data type. */
+ int dataType;
+
+ /** The Constant DATA_TYPE_BYTE. */
+ static final int DATA_TYPE_BYTE = 0;
+
+ /** The Constant DATA_TYPE_INT. */
+ static final int DATA_TYPE_INT = 1;
+
+ /**
+ * Instantiates a new MemoryImageSource with the specified
+ * parameters.
+ *
+ * @param w the width of the rectangular area of pixels.
+ * @param h the height of the rectangular area of pixels.
+ * @param cm the specified ColorModel.
+ * @param pix the pixel array.
+ * @param off the offset in the pixel array.
+ * @param scan the distance from one pixel's row to the next
+ * in the pixel array.
+ * @param props the set of properties to be used for image
+ * processing.
+ */
+ public MemoryImageSource(int w, int h, ColorModel cm, int pix[],
+ int off, int scan, Hashtable<?, ?> props) {
+ init(w, h, cm, pix, off, scan, props);
+ }
+
+ /**
+ * Instantiates a new MemoryImageSource with the specified
+ * parameters.
+ *
+ * @param w the width of the rectangular area of pixels.
+ * @param h the height of the rectangular area of pixels.
+ * @param cm the specified ColorModel.
+ * @param pix the pixel array.
+ * @param off the offset in the pixel array.
+ * @param scan the distance from one pixel's row to the next
+ * in the pixel array.
+ * @param props the set of properties to be used for image
+ * processing.
+ */
+ public MemoryImageSource(int w, int h, ColorModel cm, byte pix[],
+ int off, int scan, Hashtable<?, ?> props) {
+ init(w, h, cm, pix, off, scan, props);
+ }
+
+ /**
+ * Instantiates a new MemoryImageSource with the specified
+ * parameters and default RGB ColorModel.
+ *
+ * @param w the width of the rectangular area of pixels.
+ * @param h the height of the rectangular area of pixels.
+ * @param pix the pixel array.
+ * @param off the offset in the pixel array.
+ * @param scan the distance from one pixel's row to the next
+ * in the pixel array.
+ * @param props the set of properties to be used for image
+ * processing.
+ */
+ public MemoryImageSource(int w, int h, int pix[], int off, int scan,
+ Hashtable<?, ?> props) {
+ init(w, h, ColorModel.getRGBdefault(), pix, off, scan, props);
+ }
+
+ /**
+ * Instantiates a new MemoryImageSource with the specified
+ * parameters.
+ *
+ * @param w the width of the rectangular area of pixels.
+ * @param h the height of the rectangular area of pixels.
+ * @param cm the specified ColorModel.
+ * @param pix the pixel array.
+ * @param off the offset in the pixel array.
+ * @param scan the distance from one pixel's row to the next
+ * in the pixel array.
+ */
+ public MemoryImageSource(int w, int h, ColorModel cm, int pix[],
+ int off, int scan) {
+ init(w, h, cm, pix, off, scan, null);
+ }
+
+ /**
+ * Instantiates a new MemoryImageSource with the specified
+ * parameters.
+ *
+ * @param w the width of the rectangular area of pixels.
+ * @param h the height of the rectangular area of pixels.
+ * @param cm the specified ColorModel.
+ * @param pix the pixel array.
+ * @param off the offset in the pixel array.
+ * @param scan the distance from one pixel's row to the next
+ * in the pixel array.
+ */
+ public MemoryImageSource(int w, int h, ColorModel cm, byte pix[],
+ int off, int scan) {
+ init(w, h, cm, pix, off, scan, null);
+ }
+
+ /**
+ * Instantiates a new MemoryImageSource with the specified
+ * parameters and default RGB ColorModel.
+ *
+ * @param w the width of the rectangular area of pixels.
+ * @param h the height of the rectangular area of pixels.
+ * @param pix the pixels array.
+ * @param off the offset in the pixel array.
+ * @param scan the distance from one pixel's row to the next
+ * in the pixel array.
+ */
+ public MemoryImageSource(int w, int h, int pix[], int off, int scan) {
+ init(w, h, ColorModel.getRGBdefault(), pix, off, scan, null);
+ }
+
+ public synchronized boolean isConsumer(ImageConsumer ic) {
+ return consumers.contains(ic);
+ }
+
+ public void startProduction(ImageConsumer ic) {
+ if(!isConsumer(ic) && ic != null) {
+ consumers.addElement(ic);
+ }
+ try{
+ setHeader(ic);
+ setPixels(ic, 0, 0, width, height);
+ if(animated){
+ ic.imageComplete(ImageConsumer.SINGLEFRAMEDONE);
+ }else{
+ ic.imageComplete(ImageConsumer.STATICIMAGEDONE);
+ if(isConsumer(ic)) {
+ removeConsumer(ic);
+ }
+ }
+ }catch(Exception e){
+ if(isConsumer(ic)) {
+ ic.imageComplete(ImageConsumer.IMAGEERROR);
+ }
+ if(isConsumer(ic)) {
+ removeConsumer(ic);
+ }
+ }
+ }
+
+ public void requestTopDownLeftRightResend(ImageConsumer ic) {
+ }
+
+ public synchronized void removeConsumer(ImageConsumer ic) {
+ consumers.removeElement(ic);
+ }
+
+ public synchronized void addConsumer(ImageConsumer ic) {
+ if(ic == null || consumers.contains(ic)) {
+ return;
+ }
+ consumers.addElement(ic);
+ }
+
+ /**
+ * Replaces the pixel data with a new pixel array for holding
+ * the pixels for this image. If an animation
+ * flag is set to true value by the setAnimated() method,
+ * the new pixels will be immediately delivered to the ImageConsumers.
+ *
+ * @param newpix the new pixel array.
+ * @param newmodel the new ColorModel.
+ * @param offset the offset in the array.
+ * @param scansize the distance from one row of pixels to the next row
+ * in the pixel array
+ */
+ public synchronized void newPixels(int newpix[], ColorModel newmodel,
+ int offset, int scansize) {
+ this.dataType = DATA_TYPE_INT;
+ this.iData = newpix;
+ this.cm = newmodel;
+ this.offset = offset;
+ this.scanline = scansize;
+ newPixels();
+ }
+
+ /**
+ * Replaces the pixel data with a new pixel array for holding
+ * the pixels for this image. If an animation
+ * flag is set to true value by the setAnimated() method,
+ * the new pixels will be immediately delivered to the ImageConsumers.
+ *
+ * @param newpix the new pixel array.
+ * @param newmodel the new ColorModel.
+ * @param offset the offset in the array.
+ * @param scansize the distance from one row of pixels to the next row
+ * in the pixel array
+ */
+ public synchronized void newPixels(byte newpix[], ColorModel newmodel,
+ int offset, int scansize) {
+ this.dataType = DATA_TYPE_BYTE;
+ this.bData = newpix;
+ this.cm = newmodel;
+ this.offset = offset;
+ this.scanline = scansize;
+ newPixels();
+ }
+
+ /**
+ * Sets the full buffer updates flag to true. If this is an
+ * animated image, the image consumers hints are updated
+ * accordingly.
+ *
+ * @param fullbuffers the true if the pixel buffer should be sent always.
+ */
+ public synchronized void setFullBufferUpdates(boolean fullbuffers) {
+ if(this.fullbuffers == fullbuffers) {
+ return;
+ }
+ this.fullbuffers = fullbuffers;
+ if(animated){
+ Object consAr[] = consumers.toArray();
+ for (Object element : consAr) {
+ ImageConsumer con = (ImageConsumer)element;
+ try{
+ if(fullbuffers){
+ con.setHints(ImageConsumer.TOPDOWNLEFTRIGHT |
+ ImageConsumer.COMPLETESCANLINES);
+ }else{
+ con.setHints(ImageConsumer.RANDOMPIXELORDER);
+ }
+ }catch(Exception e){
+ if(isConsumer(con)) {
+ con.imageComplete(ImageConsumer.IMAGEERROR);
+ }
+ if(isConsumer(con)) {
+ removeConsumer(con);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Sets the flag that tells whether this memory image has more
+ * than one frame (for animation): true for multiple frames,
+ * false if this class represents a single frame image.
+ *
+ * @param animated whether this image represents an animation.
+ */
+ public synchronized void setAnimated(boolean animated) {
+ if(this.animated == animated) {
+ return;
+ }
+ Object consAr[] = consumers.toArray();
+ for (Object element : consAr) {
+ ImageConsumer con = (ImageConsumer)element;
+ try{
+ con.imageComplete(ImageConsumer.STATICIMAGEDONE);
+ }catch(Exception e){
+ if(isConsumer(con)) {
+ con.imageComplete(ImageConsumer.IMAGEERROR);
+ }
+ }
+ if(isConsumer(con)){
+ removeConsumer(con);
+ }
+ }
+ this.animated = animated;
+ }
+
+ /**
+ * Sends the specified rectangular area of the buffer to
+ * ImageConsumers and notifies them that an animation frame
+ * is completed only if framenotify parameter is true.
+ * That works only if the animated flag has been set to true
+ * by the setAnimated() method. If the full buffer update flag
+ * has been set to true by the setFullBufferUpdates() method,
+ * then the entire buffer will always be sent ignoring parameters.
+ *
+ * @param x the X coordinate of the rectangular area.
+ * @param y the Y coordinate of rthe ectangular area.
+ * @param w the width of the rectangular area.
+ * @param h the height of the rectangular area.
+ * @param framenotify true if a SINGLEFRAMEDONE notification
+ * should be sent to the registered consumers, false otherwise.
+ */
+ public synchronized void newPixels(int x, int y, int w, int h,
+ boolean framenotify) {
+ if(animated){
+ if(fullbuffers){
+ x = 0;
+ y = 0;
+ w = width;
+ h = height;
+ }else{
+ if(x < 0){
+ w += x;
+ x = 0;
+ }
+ if(w > width) {
+ w = width - x;
+ }
+ if(y < 0){
+ h += y;
+ y = 0;
+ }
+ }
+ if(h > height) {
+ h = height - y;
+ }
+ Object consAr[] = consumers.toArray();
+ for (Object element : consAr) {
+ ImageConsumer con = (ImageConsumer)element;
+ try{
+ if(w > 0 && h > 0) {
+ setPixels(con, x, y, w, h);
+ }
+ if(framenotify) {
+ con.imageComplete(ImageConsumer.SINGLEFRAMEDONE);
+ }
+ }catch(Exception ex){
+ if(isConsumer(con)) {
+ con.imageComplete(ImageConsumer.IMAGEERROR);
+ }
+ if(isConsumer(con)) {
+ removeConsumer(con);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Sends the specified rectangular area of the buffer to
+ * the ImageConsumers and notifies them that an animation frame
+ * is completed if the animated flag has been set to true
+ * by the setAnimated() method. If the full buffer update flag
+ * has been set to true by the setFullBufferUpdates() method,
+ * then the entire buffer will always be sent ignoring parameters.
+ *
+ * @param x the X coordinate of the rectangular area.
+ * @param y the Y coordinate of the rectangular area.
+ * @param w the width of the rectangular area.
+ * @param h the height of the rectangular area.
+ */
+ public synchronized void newPixels(int x, int y, int w, int h) {
+ newPixels(x, y, w, h, true);
+ }
+
+ /**
+ * Sends a new buffer of pixels to the ImageConsumers
+ * and notifies them that an animation frame is completed if
+ * the animated flag has been set to true by the setAnimated() method.
+ */
+ public void newPixels() {
+ newPixels(0, 0, width, height, true);
+ }
+
+ /**
+ * Inits the.
+ *
+ * @param width the width
+ * @param height the height
+ * @param model the model
+ * @param pixels the pixels
+ * @param off the off
+ * @param scan the scan
+ * @param prop the prop
+ */
+ private void init(int width, int height, ColorModel model, byte pixels[],
+ int off, int scan, Hashtable<?, ?> prop){
+
+ this.width = width;
+ this.height = height;
+ this.cm = model;
+ this.bData = pixels;
+ this.offset = off;
+ this.scanline = scan;
+ this.properties = prop;
+ this.dataType = DATA_TYPE_BYTE;
+ this.consumers = new Vector<ImageConsumer>();
+
+ }
+
+ /**
+ * Inits the.
+ *
+ * @param width the width
+ * @param height the height
+ * @param model the model
+ * @param pixels the pixels
+ * @param off the off
+ * @param scan the scan
+ * @param prop the prop
+ */
+ private void init(int width, int height, ColorModel model, int pixels[],
+ int off, int scan, Hashtable<?, ?> prop){
+
+ this.width = width;
+ this.height = height;
+ this.cm = model;
+ this.iData = pixels;
+ this.offset = off;
+ this.scanline = scan;
+ this.properties = prop;
+ this.dataType = DATA_TYPE_INT;
+ this.consumers = new Vector<ImageConsumer>();
+ }
+
+ /**
+ * Sets the pixels.
+ *
+ * @param con the con
+ * @param x the x
+ * @param y the y
+ * @param w the w
+ * @param h the h
+ */
+ private void setPixels(ImageConsumer con, int x, int y, int w, int h){
+ int pixelOff = scanline * y + offset + x;
+
+ switch(dataType){
+ case DATA_TYPE_BYTE:
+ con.setPixels(x, y, w, h, cm, bData, pixelOff, scanline);
+ break;
+ case DATA_TYPE_INT:
+ con.setPixels(x, y, w, h, cm, iData, pixelOff, scanline);
+ break;
+ default:
+ // awt.22A=Wrong type of pixels array
+ throw new IllegalArgumentException(Messages.getString("awt.22A")); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Sets the header.
+ *
+ * @param con the new header
+ */
+ private synchronized void setHeader(ImageConsumer con){
+ con.setDimensions(width, height);
+ con.setProperties(properties);
+ con.setColorModel(cm);
+ con.setHints(animated ? (fullbuffers ? (ImageConsumer.TOPDOWNLEFTRIGHT |
+ ImageConsumer.COMPLETESCANLINES) : ImageConsumer.RANDOMPIXELORDER) :
+ (ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.COMPLETESCANLINES |
+ ImageConsumer.SINGLEPASS | ImageConsumer.SINGLEFRAME));
+ }
+
+}
+
diff --git a/awt/java/awt/image/MultiPixelPackedSampleModel.java b/awt/java/awt/image/MultiPixelPackedSampleModel.java
new file mode 100644
index 0000000..dd44b49
--- /dev/null
+++ b/awt/java/awt/image/MultiPixelPackedSampleModel.java
@@ -0,0 +1,454 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The MultiPixelPackedSampleModel class represents image data with one
+ * band. This class packs multiple pixels with one sample in one data
+ * element and supports the following data types: DataBuffer.TYPE_BYTE,
+ * DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT.
+ */
+public class MultiPixelPackedSampleModel extends SampleModel {
+
+ /** The pixel bit stride. */
+ private int pixelBitStride;
+
+ /** The scanline stride. */
+ private int scanlineStride;
+
+ /** The data bit offset. */
+ private int dataBitOffset;
+
+ /** The bit mask. */
+ private int bitMask;
+
+ /** The data element size. */
+ private int dataElementSize;
+
+ /** The pixels per data element. */
+ private int pixelsPerDataElement;
+
+ /**
+ * Instantiates a new MultiPixelPackedSampleModel with the specified
+ * parameters.
+ *
+ * @param dataType the data type of the samples.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param numberOfBits the number of bits per pixel.
+ * @param scanlineStride the scanline stride of the of the image data.
+ * @param dataBitOffset the array of the band offsets.
+ */
+ public MultiPixelPackedSampleModel(int dataType, int w, int h,
+ int numberOfBits, int scanlineStride, int dataBitOffset) {
+
+ super(dataType, w, h, 1);
+ if (dataType != DataBuffer.TYPE_BYTE &&
+ dataType != DataBuffer.TYPE_USHORT &&
+ dataType != DataBuffer.TYPE_INT) {
+ // awt.61=Unsupported data type: {0}
+ throw new IllegalArgumentException(Messages.getString("awt.61", //$NON-NLS-1$
+ dataType));
+ }
+
+ this.scanlineStride = scanlineStride;
+ if(numberOfBits == 0) {
+ // awt.20C=Number of Bits equals to zero
+ throw new RasterFormatException(Messages.getString("awt.20C")); //$NON-NLS-1$
+ }
+ this.pixelBitStride = numberOfBits;
+ this.dataElementSize = DataBuffer.getDataTypeSize(dataType);
+ if(dataElementSize % pixelBitStride != 0) {
+ // awt.20D=The number of bits per pixel is not a power of 2 or pixels span data element boundaries
+ throw new RasterFormatException(Messages.getString("awt.20D")); //$NON-NLS-1$
+ }
+
+ if(dataBitOffset % numberOfBits != 0) {
+ // awt.20E=Data Bit offset is not a multiple of pixel bit stride
+ throw new RasterFormatException(Messages.getString("awt.20E")); //$NON-NLS-1$
+ }
+ this.dataBitOffset = dataBitOffset;
+
+ this.pixelsPerDataElement = dataElementSize / pixelBitStride;
+ this.bitMask = (1 << numberOfBits) - 1;
+ }
+
+ /**
+ * Instantiates a new MultiPixelPackedSampleModel with the specified
+ * parameters.
+ *
+ * @param dataType the data type of the samples.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param numberOfBits the number of bits per pixel.
+ */
+ public MultiPixelPackedSampleModel(int dataType, int w, int h,
+ int numberOfBits) {
+
+ this(dataType, w, h, numberOfBits, (numberOfBits * w +
+ DataBuffer.getDataTypeSize(dataType) - 1) /
+ DataBuffer.getDataTypeSize(dataType), 0);
+ }
+
+ @Override
+ public Object getDataElements(int x, int y, Object obj, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ switch (getTransferType()) {
+ case DataBuffer.TYPE_BYTE:
+ byte bdata[];
+ if (obj == null) {
+ bdata = new byte[1];
+ } else {
+ bdata = (byte[]) obj;
+ }
+ bdata[0] = (byte) getSample(x, y, 0, data);
+ obj = bdata;
+ break;
+ case DataBuffer.TYPE_USHORT:
+ short sdata[];
+ if (obj == null) {
+ sdata = new short[1];
+ } else {
+ sdata = (short[]) obj;
+ }
+ sdata[0] = (short) getSample(x, y, 0, data);
+ obj = sdata;
+ break;
+ case DataBuffer.TYPE_INT:
+ int idata[];
+ if (obj == null) {
+ idata = new int[1];
+ } else {
+ idata = (int[]) obj;
+ }
+ idata[0] = getSample(x, y, 0, data);
+ obj = idata;
+ break;
+ }
+
+ return obj;
+ }
+
+ @Override
+ public void setDataElements(int x, int y, Object obj, DataBuffer data) {
+ setSample(x, y, obj, data, 1, 0);
+ }
+
+ /**
+ * Compares this MultiPixelPackedSampleModel object with
+ * the specified object.
+ *
+ * @param o the Object to be compared.
+ *
+ * @return true, if the object is a MultiPixelPackedSampleModel
+ * with the same data parameter values as this MultiPixelPackedSampleModel,
+ * false otherwise.
+ */
+ @Override
+ public boolean equals(Object o) {
+ if ((o == null) || !(o instanceof MultiPixelPackedSampleModel)) {
+ return false;
+ }
+
+ MultiPixelPackedSampleModel model = (MultiPixelPackedSampleModel) o;
+ return this.width == model.width &&
+ this.height == model.height &&
+ this.numBands == model.numBands &&
+ this.dataType == model.dataType &&
+ this.pixelBitStride == model.pixelBitStride &&
+ this.bitMask == model.bitMask &&
+ this.pixelsPerDataElement == model.pixelsPerDataElement &&
+ this.dataElementSize == model.dataElementSize &&
+ this.dataBitOffset == model.dataBitOffset &&
+ this.scanlineStride == model.scanlineStride;
+ }
+
+ @Override
+ public SampleModel createSubsetSampleModel(int bands[]) {
+ if (bands != null && bands.length != 1) {
+ // awt.20F=Number of bands must be only 1
+ throw new RasterFormatException(Messages.getString("awt.20F")); //$NON-NLS-1$
+ }
+ return createCompatibleSampleModel(width, height);
+ }
+
+ @Override
+ public SampleModel createCompatibleSampleModel(int w, int h) {
+ return new MultiPixelPackedSampleModel(dataType, w, h, pixelBitStride);
+ }
+
+ @Override
+ public int[] getPixel(int x, int y, int iArray[], DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int pixel[];
+ if (iArray == null) {
+ pixel = new int[numBands];
+ } else {
+ pixel = iArray;
+ }
+
+ pixel[0] = getSample(x, y, 0, data);
+ return pixel;
+ }
+
+ @Override
+ public void setPixel(int x, int y, int iArray[], DataBuffer data) {
+ setSample(x, y, iArray, data, 2, 0);
+ }
+
+ @Override
+ public int getSample(int x, int y, int b, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height || b != 0) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ int bitnum = dataBitOffset + x * pixelBitStride;
+ int elem = data.getElem(y * scanlineStride + bitnum / dataElementSize);
+ int shift = dataElementSize - (bitnum & (dataElementSize - 1)) -
+ pixelBitStride;
+
+ return (elem >> shift) & bitMask;
+ }
+
+ @Override
+ public void setSample(int x, int y, int b, int s, DataBuffer data) {
+ if (b != 0) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ setSample(x, y, null, data, 3, s);
+ }
+
+ @Override
+ public DataBuffer createDataBuffer() {
+ DataBuffer dataBuffer = null;
+ int size = scanlineStride * height;
+
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ dataBuffer = new DataBufferByte(size + (dataBitOffset + 7) / 8);
+ break;
+ case DataBuffer.TYPE_USHORT:
+ dataBuffer = new DataBufferUShort(size + (dataBitOffset + 15) / 16);
+ break;
+ case DataBuffer.TYPE_INT:
+ dataBuffer = new DataBufferInt(size + (dataBitOffset + 31) / 32);
+ break;
+ }
+ return dataBuffer;
+ }
+
+ /**
+ * Gets the offset of the specified pixel in the data array.
+ *
+ * @param x the X coordinate of the specified pixel.
+ * @param y the Y coordinate of the specified pixel.
+ *
+ * @return the offset of the specified pixel.
+ */
+ public int getOffset(int x, int y) {
+ return y * scanlineStride + (x * pixelBitStride + dataBitOffset) /
+ dataElementSize;
+ }
+
+ @Override
+ public int getSampleSize(int band) {
+ return pixelBitStride;
+ }
+
+ /**
+ * Gets the bit offset in the data element which
+ * is stored for the specified pixel of a scanline.
+ *
+ * @param x the pixel.
+ *
+ * @return the bit offset of the pixel in the data element.
+ */
+ public int getBitOffset(int x) {
+ return (x * pixelBitStride + dataBitOffset) % dataElementSize;
+ }
+
+ @Override
+ public int[] getSampleSize() {
+ int sampleSizes[] = { pixelBitStride };
+ return sampleSizes;
+ }
+
+ /**
+ * Returns a hash code of this MultiPixelPackedSampleModel class.
+ *
+ * @return the hash code of this MultiPixelPackedSampleModel class.
+ */
+ @Override
+ public int hashCode() {
+ int hash = 0;
+ int tmp = 0;
+
+ hash = width;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= height;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= numBands;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= dataType;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= scanlineStride;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= pixelBitStride;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= dataBitOffset;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= bitMask;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= dataElementSize;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= pixelsPerDataElement;
+ return hash;
+ }
+
+ @Override
+ public int getTransferType() {
+ if (pixelBitStride > 16) {
+ return DataBuffer.TYPE_INT;
+ } else if (pixelBitStride > 8) {
+ return DataBuffer.TYPE_USHORT;
+ } else {
+ return DataBuffer.TYPE_BYTE;
+ }
+ }
+
+ /**
+ * Gets the scanline stride of this MultiPixelPackedSampleModel.
+ *
+ * @return the scanline stride of this MultiPixelPackedSampleModel.
+ */
+ public int getScanlineStride() {
+ return scanlineStride;
+ }
+
+ /**
+ * Gets the pixel bit stride of this MultiPixelPackedSampleModel.
+ *
+ * @return the pixel bit stride of this MultiPixelPackedSampleModel.
+ */
+ public int getPixelBitStride() {
+ return pixelBitStride;
+ }
+
+ @Override
+ public int getNumDataElements() {
+ return 1;
+ }
+
+ /**
+ * Gets the data bit offset.
+ *
+ * @return the data bit offset.
+ */
+ public int getDataBitOffset() {
+ return dataBitOffset;
+ }
+
+ /**
+ * This method is used by other methods of this class. The behaviour of
+ * this method depends on the method which has been invoke this one. The
+ * argument methodId is used to choose valid behaviour in a particular case.
+ * If methodId is equal to 1 it means that this method has been invoked by
+ * the setDataElements() method, 2 - means setPixel(), and setSample() in
+ * any other cases.
+ *
+ * @param x the x
+ * @param y the y
+ * @param obj the obj
+ * @param data the data
+ * @param methodId the method id
+ * @param s the s
+ */
+ private void setSample(final int x, final int y, final Object obj,
+ final DataBuffer data, final int methodId, int s) {
+ if ((x < 0) || (y < 0) || (x >= this.width) || (y >= this.height)) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages
+ .getString("awt.63")); //$NON-NLS-1$
+ }
+
+ final int bitnum = dataBitOffset + x * pixelBitStride;
+ final int idx = y * scanlineStride + bitnum / dataElementSize;
+ final int shift = dataElementSize - (bitnum & (dataElementSize - 1))
+ - pixelBitStride;
+ final int mask = ~(bitMask << shift);
+ int elem = data.getElem(idx);
+
+ switch (methodId) {
+ case 1: { // Invoked from setDataElements()
+ switch (getTransferType()) {
+ case DataBuffer.TYPE_BYTE:
+ s = ((byte[]) obj)[0] & 0xff;
+ break;
+ case DataBuffer.TYPE_USHORT:
+ s = ((short[]) obj)[0] & 0xffff;
+ break;
+ case DataBuffer.TYPE_INT:
+ s = ((int[]) obj)[0];
+ break;
+ }
+ break;
+ }
+ case 2: { // Invoked from setPixel()
+ s = ((int[]) obj)[0];
+ break;
+ }
+ }
+
+ elem &= mask;
+ elem |= (s & bitMask) << shift;
+ data.setElem(idx, elem);
+ }
+}
+
diff --git a/awt/java/awt/image/PackedColorModel.java b/awt/java/awt/image/PackedColorModel.java
new file mode 100644
index 0000000..7aaefbf
--- /dev/null
+++ b/awt/java/awt/image/PackedColorModel.java
@@ -0,0 +1,383 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Transparency;
+import java.awt.color.ColorSpace;
+import java.util.Arrays;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class PackedColorModel represents a color model where the
+ * components are just the red, green, and blue bands, plus an alpha
+ * band if alpha is supported.
+ */
+public abstract class PackedColorModel extends ColorModel {
+
+ /** The component masks. */
+ int componentMasks[];
+
+ /** The offsets. */
+ int offsets[];
+
+ /** The scales. */
+ float scales[];
+
+ /**
+ * Instantiates a new packed color model.
+ *
+ * @param space the color space
+ * @param bits the array of component masks
+ * @param colorMaskArray the array that gives the bitmask corresponding
+ * to each color band (red, green, and blue)
+ * @param alphaMask the bitmask corresponding to the alpha band
+ * @param isAlphaPremultiplied whether the alpha is premultiplied in this color model
+ * @param trans the transparency strategy, @see java.awt.Transparency
+ * @param transferType the transfer type (primitive java type
+ * to use for the components)
+ *
+ * @throws IllegalArgumentException if the number of bits in the combined
+ * bitmasks for the color bands is less than one or greater than 32
+ */
+ public PackedColorModel(ColorSpace space, int bits, int colorMaskArray[],
+ int alphaMask, boolean isAlphaPremultiplied, int trans,
+ int transferType) {
+
+ super(bits, createBits(colorMaskArray, alphaMask), space,
+ (alphaMask == 0 ? false : true), isAlphaPremultiplied, trans,
+ validateTransferType(transferType));
+
+ if (pixel_bits < 1 || pixel_bits > 32) {
+ // awt.236=The bits is less than 1 or greater than 32
+ throw new IllegalArgumentException(Messages.getString("awt.236")); //$NON-NLS-1$
+ }
+
+ componentMasks = new int[numComponents];
+ for (int i = 0; i < numColorComponents; i++) {
+ componentMasks[i] = colorMaskArray[i];
+ }
+
+ if (hasAlpha) {
+ componentMasks[numColorComponents] = alphaMask;
+ if (this.bits[numColorComponents] == 1) {
+ transparency = Transparency.BITMASK;
+ }
+ }
+
+ parseComponents();
+ }
+
+ /**
+ * Instantiates a new packed color model.
+ *
+ * @param space the color space
+ * @param bits the array of component masks
+ * @param rmask the bitmask corresponding to the red band
+ * @param gmask the bitmask corresponding to the green band
+ * @param bmask the bitmask corresponding to the blue band
+ * @param amask the bitmask corresponding to the alpha band
+ * @param isAlphaPremultiplied whether the alpha is premultiplied in this color model
+ * @param trans the transparency strategy, @see java.awt.Transparency
+ * @param transferType the transfer type (primitive java type
+ * to use for the components)
+ *
+ * @throws IllegalArgumentException if the number of bits in the combined
+ * bitmasks for the color bands is less than one or greater than 32
+ */
+ public PackedColorModel(ColorSpace space, int bits, int rmask, int gmask,
+ int bmask, int amask, boolean isAlphaPremultiplied, int trans,
+ int transferType) {
+
+ super(bits, createBits(rmask, gmask, bmask, amask), space,
+ (amask == 0 ? false : true), isAlphaPremultiplied, trans,
+ validateTransferType(transferType));
+
+ if (pixel_bits < 1 || pixel_bits > 32) {
+ // awt.236=The bits is less than 1 or greater than 32
+ throw new IllegalArgumentException(Messages.getString("awt.236")); //$NON-NLS-1$
+ }
+
+ if (cs.getType() != ColorSpace.TYPE_RGB) {
+ // awt.239=The space is not a TYPE_RGB space
+ throw new IllegalArgumentException(Messages.getString("awt.239")); //$NON-NLS-1$
+ }
+
+ for (int i = 0; i < numColorComponents; i++) {
+ if (cs.getMinValue(i) != 0.0f || cs.getMaxValue(i) != 1.0f) {
+ // awt.23A=The min/max normalized component values are not 0.0/1.0
+ throw new IllegalArgumentException(Messages.getString("awt.23A")); //$NON-NLS-1$
+ }
+ }
+ componentMasks = new int[numComponents];
+ componentMasks[0] = rmask;
+ componentMasks[1] = gmask;
+ componentMasks[2] = bmask;
+
+ if (hasAlpha) {
+ componentMasks[3] = amask;
+ if (this.bits[3] == 1) {
+ transparency = Transparency.BITMASK;
+ }
+ }
+
+ parseComponents();
+ }
+
+ @Override
+ public WritableRaster getAlphaRaster(WritableRaster raster) {
+ if(!hasAlpha) {
+ return null;
+ }
+
+ int x = raster.getMinX();
+ int y = raster.getMinY();
+ int w = raster.getWidth();
+ int h = raster.getHeight();
+ int band[] = new int[1];
+ band[0] = raster.getNumBands() - 1;
+ return raster.createWritableChild(x, y, w, h, x, y, band);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == null) {
+ return false;
+ }
+ if (!(obj instanceof PackedColorModel)) {
+ return false;
+ }
+ PackedColorModel cm = (PackedColorModel) obj;
+
+ return (pixel_bits == cm.getPixelSize() &&
+ transferType == cm.getTransferType() &&
+ cs.getType() == cm.getColorSpace().getType() &&
+ hasAlpha == cm.hasAlpha() &&
+ isAlphaPremultiplied == cm.isAlphaPremultiplied() &&
+ transparency == cm.getTransparency() &&
+ numColorComponents == cm.getNumColorComponents()&&
+ numComponents == cm.getNumComponents() &&
+ Arrays.equals(bits, cm.getComponentSize()) &&
+ Arrays.equals(componentMasks, cm.getMasks()));
+ }
+
+ @Override
+ public boolean isCompatibleSampleModel(SampleModel sm) {
+ if (sm == null) {
+ return false;
+ }
+ if (!(sm instanceof SinglePixelPackedSampleModel)) {
+ return false;
+ }
+ SinglePixelPackedSampleModel esm = (SinglePixelPackedSampleModel) sm;
+
+ return ((esm.getNumBands() == numComponents) &&
+ (esm.getTransferType() == transferType) &&
+ Arrays.equals(esm.getBitMasks(), componentMasks));
+ }
+
+ @Override
+ public SampleModel createCompatibleSampleModel(int w, int h) {
+ return new SinglePixelPackedSampleModel(transferType, w, h,
+ componentMasks);
+ }
+
+ /**
+ * Gets the bitmask corresponding to the specified color component.
+ *
+ * @param index the index of the desired color
+ *
+ * @return the mask
+ */
+ public final int getMask(int index) {
+ return componentMasks[index];
+ }
+
+ /**
+ * Gets the bitmasks of the components.
+ *
+ * @return the masks
+ */
+ public final int[] getMasks() {
+ return (componentMasks.clone());
+ }
+
+ /**
+ * Creates the bits.
+ *
+ * @param colorMaskArray the color mask array
+ * @param alphaMask the alpha mask
+ *
+ * @return the int[]
+ */
+ private static int[] createBits(int colorMaskArray[], int alphaMask) {
+ int bits[];
+ int numComp;
+ if (alphaMask == 0) {
+ numComp = colorMaskArray.length;
+ } else {
+ numComp = colorMaskArray.length + 1;
+ }
+
+ bits = new int[numComp];
+ int i = 0;
+ for (; i < colorMaskArray.length; i++) {
+ bits[i] = countCompBits(colorMaskArray[i]);
+ if (bits[i] < 0) {
+ // awt.23B=The mask of the {0} component is not contiguous
+ throw new IllegalArgumentException(Messages.getString("awt.23B", i)); //$NON-NLS-1$
+ }
+ }
+
+ if (i < numComp) {
+ bits[i] = countCompBits(alphaMask);
+
+ if (bits[i] < 0) {
+ // awt.23C=The mask of the alpha component is not contiguous
+ throw new IllegalArgumentException(Messages.getString("awt.23C")); //$NON-NLS-1$
+ }
+ }
+
+ return bits;
+ }
+
+ /**
+ * Creates the bits.
+ *
+ * @param rmask the rmask
+ * @param gmask the gmask
+ * @param bmask the bmask
+ * @param amask the amask
+ *
+ * @return the int[]
+ */
+ private static int[] createBits(int rmask, int gmask, int bmask,
+ int amask) {
+
+ int numComp;
+ if (amask == 0) {
+ numComp = 3;
+ } else {
+ numComp = 4;
+ }
+ int bits[] = new int[numComp];
+
+ bits[0] = countCompBits(rmask);
+ if (bits[0] < 0) {
+ // awt.23D=The mask of the red component is not contiguous
+ throw new IllegalArgumentException(Messages.getString("awt.23D")); //$NON-NLS-1$
+ }
+
+ bits[1] = countCompBits(gmask);
+ if (bits[1] < 0) {
+ // awt.23E=The mask of the green component is not contiguous
+ throw new IllegalArgumentException(Messages.getString("awt.23E")); //$NON-NLS-1$
+ }
+
+ bits[2] = countCompBits(bmask);
+ if (bits[2] < 0) {
+ // awt.23F=The mask of the blue component is not contiguous
+ throw new IllegalArgumentException(Messages.getString("awt.23F")); //$NON-NLS-1$
+ }
+
+ if (amask != 0) {
+ bits[3] = countCompBits(amask);
+ if (bits[3] < 0) {
+ // awt.23C=The mask of the alpha component is not contiguous
+ throw new IllegalArgumentException(Messages.getString("awt.23C")); //$NON-NLS-1$
+ }
+ }
+
+ return bits;
+ }
+
+ /**
+ * Count comp bits.
+ *
+ * @param compMask the comp mask
+ *
+ * @return the int
+ */
+ private static int countCompBits(int compMask) {
+ int bits = 0;
+ if (compMask != 0) {
+ // Deleting final zeros
+ while ((compMask & 1) == 0) {
+ compMask >>>= 1;
+ }
+ // Counting component bits
+ while ((compMask & 1) == 1) {
+ compMask >>>= 1;
+ bits++;
+ }
+ }
+
+ if (compMask != 0) {
+ return -1;
+ }
+
+ return bits;
+ }
+
+ /**
+ * Validate transfer type.
+ *
+ * @param transferType the transfer type
+ *
+ * @return the int
+ */
+ private static int validateTransferType(int transferType) {
+ if (transferType != DataBuffer.TYPE_BYTE &&
+ transferType != DataBuffer.TYPE_USHORT &&
+ transferType != DataBuffer.TYPE_INT) {
+ // awt.240=The transferType not is one of DataBuffer.TYPE_BYTE,
+ // DataBuffer.TYPE_USHORT or DataBuffer.TYPE_INT
+ throw new IllegalArgumentException(Messages.getString("awt.240")); //$NON-NLS-1$
+ }
+ return transferType;
+}
+
+ /**
+ * Parses the components.
+ */
+ private void parseComponents() {
+ offsets = new int[numComponents];
+ scales = new float[numComponents];
+ for (int i = 0; i < numComponents; i++) {
+ int off = 0;
+ int mask = componentMasks[i];
+ while ((mask & 1) == 0) {
+ mask >>>= 1;
+ off++;
+ }
+ offsets[i] = off;
+ if (bits[i] == 0) {
+ scales[i] = 256.0f; // May be any value different from zero,
+ // because will dividing by zero
+ } else {
+ scales[i] = 255.0f / maxValues[i];
+ }
+ }
+
+ }
+
+}
+
diff --git a/awt/java/awt/image/PixelGrabber.java b/awt/java/awt/image/PixelGrabber.java
new file mode 100644
index 0000000..cecd5c8
--- /dev/null
+++ b/awt/java/awt/image/PixelGrabber.java
@@ -0,0 +1,408 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Image;
+import java.util.Hashtable;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+public class PixelGrabber implements ImageConsumer {
+
+ int width;
+ int height;
+ int X;
+ int Y;
+ int offset;
+ int scanline;
+ ImageProducer producer;
+
+ byte bData[];
+ int iData[];
+ ColorModel cm;
+
+ private int grabberStatus;
+ private int dataType;
+ private boolean isGrabbing;
+ private boolean isRGB;
+
+
+ private static final int DATA_TYPE_BYTE = 0;
+ private static final int DATA_TYPE_INT = 1;
+ private static final int DATA_TYPE_UNDEFINED = 2;
+
+ private static final int ALL_BITS = (ImageObserver.FRAMEBITS |
+ ImageObserver.ALLBITS);
+
+ private static final int GRABBING_STOP = ALL_BITS | ImageObserver.ERROR;
+
+
+
+ public PixelGrabber(ImageProducer ip, int x, int y, int w, int h, int[] pix,
+ int off, int scansize) {
+ initialize(ip, x, y, w, h, pix, off, scansize, true);
+ }
+
+ public PixelGrabber(Image img, int x, int y, int w, int h, int[] pix,
+ int off, int scansize) {
+ initialize(img.getSource(), x, y, w, h, pix, off, scansize, true);
+ }
+
+ public PixelGrabber(Image img, int x, int y, int w, int h, boolean forceRGB) {
+ initialize(img.getSource(), x, y, w, h, null, 0, 0, forceRGB);
+ }
+
+ public void setProperties(Hashtable<?, ?> props) {
+ return;
+ }
+
+ public synchronized Object getPixels() {
+ switch(dataType){
+ case DATA_TYPE_BYTE:
+ return bData;
+ case DATA_TYPE_INT:
+ return iData;
+ default:
+ return null;
+ }
+ }
+
+ public void setColorModel(ColorModel model) {
+ return;
+ }
+
+ public void setPixels(int srcX, int srcY, int srcW, int srcH,
+ ColorModel model, byte[] pixels, int srcOff, int srcScan) {
+ if(srcY < Y){
+ int delta = Y - srcY;
+ if(delta >= height) {
+ return;
+ }
+ srcY += delta;
+ srcH -= delta;
+ srcOff += srcScan * delta;
+ }
+
+ if(srcY + srcH > Y + height){
+ srcH = Y + height - srcY;
+ if(srcH <= 0) {
+ return;
+ }
+ }
+
+ if(srcX < X){
+ int delta = X - srcX;
+ if(delta >= width) {
+ return;
+ }
+ srcW -= delta;
+ srcX += delta;
+ srcOff += delta;
+ }
+
+ if(srcX + srcW > X + width){
+ srcW = X + width - srcX;
+ if(srcW <= 0) {
+ return;
+ }
+ }
+ if(scanline == 0) {
+ scanline = width;
+ }
+ int realOff = offset + (srcY - Y) * scanline + (srcX - X);
+ switch(dataType){
+ case DATA_TYPE_UNDEFINED:
+ cm = model;
+ if(model != ColorModel.getRGBdefault()){
+ bData = new byte[width * height];
+ isRGB = false;
+ dataType = DATA_TYPE_BYTE;
+ }else{
+ iData = new int[width * height];
+ isRGB = true;
+ dataType = DATA_TYPE_INT;
+ }
+ case DATA_TYPE_BYTE:
+ if(!isRGB && cm == model){
+ for(int y = 0; y < srcH; y++){
+ System.arraycopy(pixels, srcOff, bData, realOff, srcW);
+ srcOff += srcScan;
+ realOff += scanline;
+ }
+ break;
+ }
+ forceToRGB();
+ case DATA_TYPE_INT:
+ for(int y = 0; y < srcH; y++){
+ for(int x = 0; x < srcW; x++){
+ iData[realOff + x] = cm.getRGB(pixels[srcOff + x] & 0xff);
+ }
+ srcOff += srcScan;
+ realOff += scanline;
+ }
+ }
+
+ return;
+ }
+
+ public void setPixels(int srcX, int srcY, int srcW, int srcH,
+ ColorModel model, int[] pixels, int srcOff, int srcScan) {
+
+ if(srcY < Y){
+ int delta = Y - srcY;
+ if(delta >= height) {
+ return;
+ }
+ srcY += delta;
+ srcH -= delta;
+ srcOff += srcScan * delta;
+ }
+
+ if(srcY + srcH > Y + height){
+ srcH = Y + height - srcY;
+ if(srcH <= 0) {
+ return;
+ }
+ }
+
+ if(srcX < X){
+ int delta = X - srcX;
+ if(delta >= width) {
+ return;
+ }
+ srcW -= delta;
+ srcX += delta;
+ srcOff += delta;
+ }
+
+ if(srcX + srcW > X + width){
+ srcW = X + width - srcX;
+ if(srcW <= 0) {
+ return;
+ }
+ }
+ if(scanline == 0) {
+ scanline = width;
+ }
+ int realOff = offset + (srcY - Y) * scanline + (srcX - X);
+
+ int mask = 0xFF;
+
+ switch(dataType){
+ case DATA_TYPE_UNDEFINED:
+ cm = model;
+ iData = new int[width * height];
+ dataType = DATA_TYPE_INT;
+ isRGB = (cm == ColorModel.getRGBdefault());
+
+ case DATA_TYPE_INT:
+ if(cm == model){
+ for(int y = 0; y < srcH; y++){
+ System.arraycopy(pixels, srcOff, iData, realOff, srcW);
+ srcOff += srcScan;
+ realOff += scanline;
+ }
+ break;
+ }
+ mask = 0xFFFFFFFF;
+
+ case DATA_TYPE_BYTE:
+ forceToRGB();
+ for(int y = 0; y < srcH; y++){
+ for(int x = 0; x < srcW; x++){
+ iData[realOff+x] = cm.getRGB(pixels[srcOff+x] & mask);
+ }
+ srcOff += srcScan;
+ realOff += scanline;
+ }
+ }
+ }
+
+ public synchronized ColorModel getColorModel() {
+ return cm;
+ }
+
+ public synchronized boolean grabPixels(long ms)
+ throws InterruptedException {
+ if((grabberStatus & GRABBING_STOP) != 0){
+ return ((grabberStatus & ALL_BITS) != 0);
+ }
+
+ long start = System.currentTimeMillis();
+
+ if(!isGrabbing){
+ isGrabbing = true;
+ grabberStatus &= ~ImageObserver.ABORT;
+ producer.startProduction(this);
+ }
+ while((grabberStatus & GRABBING_STOP) == 0){
+ if(ms != 0){
+ ms = start + ms - System.currentTimeMillis();
+ if(ms <= 0) {
+ break;
+ }
+ }
+ wait(ms);
+ }
+
+ return ((grabberStatus & ALL_BITS) != 0);
+ }
+
+ public void setDimensions(int w, int h) {
+ if(width < 0) {
+ width = w - X;
+ }
+ if(height < 0) {
+ height = h - Y;
+ }
+
+ grabberStatus |= ImageObserver.WIDTH | ImageObserver.HEIGHT;
+
+ if(width <=0 || height <=0){
+ imageComplete(STATICIMAGEDONE);
+ return;
+ }
+
+ if(isRGB && dataType == DATA_TYPE_UNDEFINED){
+ iData = new int[width * height];
+ dataType = DATA_TYPE_INT;
+ scanline = width;
+ }
+ }
+
+ public void setHints(int hints) {
+ return;
+ }
+
+ public synchronized void imageComplete(int status) {
+ switch(status){
+ case IMAGEABORTED:
+ grabberStatus |= ImageObserver.ABORT;
+ break;
+ case IMAGEERROR:
+ grabberStatus |= ImageObserver.ERROR | ImageObserver.ABORT;
+ break;
+ case SINGLEFRAMEDONE:
+ grabberStatus |= ImageObserver.FRAMEBITS;
+ break;
+ case STATICIMAGEDONE:
+ grabberStatus |= ImageObserver.ALLBITS;
+ break;
+ default:
+ // awt.26A=Incorrect ImageConsumer completion status
+ throw new IllegalArgumentException(Messages.getString("awt.26A")); //$NON-NLS-1$
+ }
+ isGrabbing = false;
+ producer.removeConsumer(this);
+ notifyAll();
+ }
+
+ public boolean grabPixels() throws InterruptedException {
+ return grabPixels(0);
+ }
+
+ public synchronized void startGrabbing() {
+ if((grabberStatus & GRABBING_STOP) != 0){
+ return;
+ }
+ if(!isGrabbing){
+ isGrabbing = true;
+ grabberStatus &= ~ImageObserver.ABORT;
+ producer.startProduction(this);
+ }
+ }
+
+ public synchronized void abortGrabbing() {
+ imageComplete(IMAGEABORTED);
+ }
+
+ public synchronized int status() {
+ return grabberStatus;
+ }
+
+ public synchronized int getWidth() {
+ if(width < 0) {
+ return -1;
+ }
+ return width;
+ }
+
+ public synchronized int getStatus() {
+ return grabberStatus;
+ }
+
+ public synchronized int getHeight() {
+ if(height < 0) {
+ return -1;
+ }
+ return height;
+ }
+
+ private void initialize(ImageProducer ip, int x, int y, int w, int h,
+ int pixels[], int off, int scansize, boolean forceRGB){
+
+ producer = ip;
+ X = x;
+ Y = y;
+ width = w;
+ height = h;
+ iData = pixels;
+ dataType = (pixels == null) ? DATA_TYPE_UNDEFINED : DATA_TYPE_INT;
+ offset = off;
+ scanline = scansize;
+ if(forceRGB){
+ cm = ColorModel.getRGBdefault();
+ isRGB = true;
+ }
+ }
+
+ /**
+ * Force pixels to INT RGB mode
+ */
+ private void forceToRGB(){
+ if (isRGB)
+ return;
+
+ switch(dataType){
+ case DATA_TYPE_BYTE:
+ iData = new int[width * height];
+ for(int i = 0; i < iData.length; i++){
+ iData[i] = cm.getRGB(bData[i] & 0xff);
+ }
+ dataType = DATA_TYPE_INT;
+ bData = null;
+ break;
+
+ case DATA_TYPE_INT:
+ int buff[] = new int[width * height];
+ for(int i = 0; i < iData.length; i++){
+ buff[i] = cm.getRGB(iData[i]);
+ }
+ iData = buff;
+ break;
+ }
+ offset = 0;
+ scanline = width;
+ cm = ColorModel.getRGBdefault();
+ isRGB = true;
+ }
+
+}
diff --git a/awt/java/awt/image/PixelInterleavedSampleModel.java b/awt/java/awt/image/PixelInterleavedSampleModel.java
new file mode 100644
index 0000000..e41473e
--- /dev/null
+++ b/awt/java/awt/image/PixelInterleavedSampleModel.java
@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The PixelInterleavedSampleModel class represents image data
+ * as represented as interleaved pixels and for which each sample of
+ * a pixel takes one data element of the DataBuffer.
+ */
+public class PixelInterleavedSampleModel extends ComponentSampleModel {
+
+ /**
+ * Instantiates a new PixelInterleavedSampleModel with the
+ * specified parameters.
+ *
+ * @param dataType the data type of the samples.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param pixelStride the pixel stride of the image data.
+ * @param scanlineStride the scanline stride of the of the image data.
+ * @param bandOffsets the array of the band offsets.
+ */
+ public PixelInterleavedSampleModel(int dataType, int w, int h,
+ int pixelStride, int scanlineStride, int bandOffsets[]) {
+
+ super(dataType, w, h, pixelStride, scanlineStride, bandOffsets);
+
+ int maxOffset = bandOffsets[0];
+ int minOffset = bandOffsets[0];
+ for (int i = 1; i < bandOffsets.length; i++) {
+ if (bandOffsets[i] > maxOffset) {
+ maxOffset = bandOffsets[i];
+ }
+ if (bandOffsets[i] < minOffset) {
+ minOffset = bandOffsets[i];
+ }
+ }
+
+ maxOffset -= minOffset;
+
+ if (maxOffset > scanlineStride) {
+ // awt.241=Any offset between bands is greater than the Scanline stride
+ throw new IllegalArgumentException(Messages.getString("awt.241")); //$NON-NLS-1$
+ }
+
+ if (maxOffset > pixelStride) {
+ // awt.242=Pixel stride is less than any offset between bands
+ throw new IllegalArgumentException(Messages.getString("awt.242")); //$NON-NLS-1$
+ }
+
+ if (pixelStride * w > scanlineStride) {
+ // awt.243=Product of Pixel stride and w is greater than Scanline stride
+ throw new IllegalArgumentException(Messages.getString("awt.243")); //$NON-NLS-1$
+ }
+
+ }
+
+ @Override
+ public SampleModel createSubsetSampleModel(int bands[]) {
+ int newOffsets[] = new int[bands.length];
+ for (int i = 0; i < bands.length; i++) {
+ newOffsets[i] = bandOffsets[bands[i]];
+ }
+
+ return new PixelInterleavedSampleModel(dataType, width, height,
+ pixelStride, scanlineStride, newOffsets);
+ }
+
+ @Override
+ public SampleModel createCompatibleSampleModel(int w, int h) {
+ int newOffsets[];
+ int minOffset = bandOffsets[0];
+
+ for (int i = 1; i < numBands; i++) {
+ if (bandOffsets[i] < minOffset) {
+ minOffset = bandOffsets[i];
+ }
+ }
+
+ if (minOffset > 0) {
+ newOffsets = new int[numBands];
+ for (int i = 0; i < numBands; i++) {
+ newOffsets[i] = bandOffsets[i] - minOffset;
+ }
+ } else {
+ newOffsets = bandOffsets;
+ }
+
+ return new PixelInterleavedSampleModel(dataType, w, h, pixelStride,
+ pixelStride * w, newOffsets);
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = super.hashCode();
+ int tmp = hash >>> 8;
+ hash <<= 8;
+ hash |= tmp;
+
+ return hash ^ 0x66;
+ }
+
+}
+
diff --git a/awt/java/awt/image/RGBImageFilter.java b/awt/java/awt/image/RGBImageFilter.java
new file mode 100644
index 0000000..9a76997
--- /dev/null
+++ b/awt/java/awt/image/RGBImageFilter.java
@@ -0,0 +1,190 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+
+/**
+ * The RGBImageFilter class represents a filter which modifies
+ * pixels of an image in the default RGB ColorModel.
+ */
+public abstract class RGBImageFilter extends ImageFilter {
+
+ /**
+ * The origmodel is the ColorModel to be replaced by newmodel
+ * when substituteColorModel is called.
+ */
+ protected ColorModel origmodel;
+
+ /**
+ * The newmodel is the ColorModel with which to replace origmodel
+ * when substituteColorModel is called.
+ */
+ protected ColorModel newmodel;
+
+ /**
+ * The canFilterIndexColorModel indicates if it is
+ * acceptable to apply the color filtering of the filterRGB
+ * method to the color table entries of an IndexColorModel
+ * object.
+ * */
+ protected boolean canFilterIndexColorModel;
+
+ /**
+ * Instantiates a new RGBImageFilter.
+ */
+ public RGBImageFilter() {}
+
+ /**
+ * Filters an IndexColorModel object by calling filterRGB function for
+ * each entry of IndexColorModel.
+ *
+ * @param icm the IndexColorModel to be filtered.
+ *
+ * @return the IndexColorModel.
+ */
+ public IndexColorModel filterIndexColorModel(IndexColorModel icm) {
+ int transferType = icm.getTransferType();
+ int bits = icm.getPixelSize();
+ int mapSize = icm.getMapSize();
+ int colorMap[] = new int[mapSize];
+ int filteredColorMap[] = new int[mapSize];
+ icm.getRGBs(colorMap);
+ int trans = -1;
+ boolean hasAlpha = false;
+ for(int i = 0; i < mapSize; i++){
+ filteredColorMap[i] = filterRGB(-1, -1, colorMap[i]);
+ int alpha = filteredColorMap[i] >>> 24;
+ if(alpha != 0xff){
+ if(!hasAlpha) {
+ hasAlpha = true;
+ }
+ if(alpha == 0 && trans < 0) {
+ trans = i;
+ }
+ }
+ }
+
+ return new IndexColorModel(bits, mapSize, filteredColorMap, 0,
+ hasAlpha, trans, transferType);
+ }
+
+ /**
+ * Replaces the original color model and the new one.
+ *
+ * @param oldcm the old ColorModel.
+ * @param newcm the new ColorModel.
+ */
+ public void substituteColorModel(ColorModel oldcm, ColorModel newcm) {
+ origmodel = oldcm;
+ newmodel = newcm;
+ }
+
+ @Override
+ public void setColorModel(ColorModel model) {
+ if(model instanceof IndexColorModel &&
+ canFilterIndexColorModel){
+ IndexColorModel icm = (IndexColorModel) model;
+ ColorModel filteredModel = filterIndexColorModel(icm);
+ substituteColorModel(model, filteredModel);
+ consumer.setColorModel(filteredModel);
+ }else{
+ consumer.setColorModel(ColorModel.getRGBdefault());
+ }
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h, ColorModel model,
+ int[] pixels, int off, int scansize) {
+
+ if(model == null || model == origmodel){
+ consumer.setPixels(x, y, w, h, newmodel, pixels, off, scansize);
+ }else{
+ int rgbPixels[] = new int[w];
+ for(int sy = y, pixelsOff = off; sy < y + h;
+ sy++, pixelsOff += scansize){
+
+ for(int sx = x, idx = 0; sx < x + w; sx++, idx++){
+ rgbPixels[idx] = model.getRGB(pixels[pixelsOff + idx]);
+ }
+ filterRGBPixels(x, sy, w, 1, rgbPixels, 0, w);
+ }
+ }
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h, ColorModel model,
+ byte[] pixels, int off, int scansize) {
+
+ if(model == null || model == origmodel){
+ consumer.setPixels(x, y, w, h, newmodel, pixels, off, scansize);
+ }else{
+ int rgbPixels[] = new int[w];
+ for(int sy = y, pixelsOff = off; sy < y + h;
+ sy++, pixelsOff += scansize){
+
+ for(int sx = x, idx = 0; sx < x + w; sx++, idx++){
+ rgbPixels[idx] =
+ model.getRGB(pixels[pixelsOff + idx] & 0xff);
+ }
+ filterRGBPixels(x, sy, w, 1, rgbPixels, 0, w);
+ }
+ }
+ }
+
+ /**
+ * Filters a region of pixels in the default RGB ColorModel
+ * by calling the filterRGB method for them.
+ *
+ * @param x the X coordinate of region.
+ * @param y the Y coordinate of region.
+ * @param w the width ofregion.
+ * @param h the height of region.
+ * @param pixels the pixels array.
+ * @param off the offset of array.
+ * @param scansize the distance between rows of pixels in the array.
+ */
+ public void filterRGBPixels(int x, int y, int w, int h,
+ int[] pixels, int off, int scansize) {
+
+ for(int sy = y, lineOff = off; sy < y + h; sy++, lineOff += scansize){
+ for(int sx = x, idx = 0; sx < x + w; sx++, idx++){
+ pixels[lineOff + idx] =
+ filterRGB(sx, sy, pixels[lineOff + idx]);
+ }
+ }
+ consumer.setPixels(x, y, w, h, ColorModel.getRGBdefault(),
+ pixels, off, scansize);
+ }
+
+ /**
+ * Coverts a single input pixel in the default RGB ColorModel
+ * to a single output pixel.
+ *
+ * @param x the X pixel's coordinate.
+ * @param y the Y pixel's coordinate.
+ * @param rgb a pixel in the default RGB color model.
+ *
+ * @return a filtered pixel in the default RGB color model.
+ */
+ public abstract int filterRGB(int x, int y, int rgb);
+
+}
+
diff --git a/awt/java/awt/image/Raster.java b/awt/java/awt/image/Raster.java
new file mode 100644
index 0000000..4b2426e
--- /dev/null
+++ b/awt/java/awt/image/Raster.java
@@ -0,0 +1,1412 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Point;
+import java.awt.Rectangle;
+
+import org.apache.harmony.awt.gl.image.OrdinaryWritableRaster;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Raster class represents a rectangular area of pixels.
+ * This class is defined by DataBuffer and SampleModel objects.
+ * The DataBuffer object stores sample values and DSampleModel defines
+ * the location of sample in this DataBuffer.
+ */
+public class Raster {
+
+ /** The DataBuffer of this Raster. */
+ protected DataBuffer dataBuffer;
+
+ /** The height of this Raster. */
+ protected int height;
+
+ /** The X coordinate of the upper left pixel in this Raster. */
+ protected int minX;
+
+ /** The Y coordinate of the upper left pixel in this Raster. */
+ protected int minY;
+
+ /** The number of bands in this Raster. */
+ protected int numBands;
+
+ /** The number of data elements. */
+ protected int numDataElements;
+
+ /** The parent of this Raster. */
+ protected Raster parent;
+
+ /** The SampleModel of this Raster. */
+ protected SampleModel sampleModel;
+
+ /**
+ * The X translation from the coordinate space of the
+ * SampleModel of this Raster.
+ */
+ protected int sampleModelTranslateX;
+
+ /**
+ * The Y translation from the coordinate space of the
+ * SampleModel of this Raster.
+ */
+ protected int sampleModelTranslateY;
+
+ /** The width of this Raster. */
+ protected int width;
+
+ /**
+ * Creates a Raster object with a BandedSampleModel and the specified
+ * DataBuffer. The number of bands is defined by the length of bandOffsets
+ * or bankIndices arrays.
+ *
+ * @param dataBuffer the specified DataBuffer.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param bankIndices the bank indices of bands.
+ * @param bandOffsets the band offsets of bands.
+ * @param location the location which defines the upper left corner
+ * of Raster.
+ *
+ * @return the WritableRaster object.
+ */
+ public static WritableRaster createBandedRaster(DataBuffer dataBuffer,
+ int w, int h, int scanlineStride, int bankIndices[],
+ int bandOffsets[], Point location) {
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (bankIndices == null || bandOffsets == null) {
+ // awt.277=bankIndices or bandOffsets is null
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.277")); //$NON-NLS-1$
+ }
+
+ if (dataBuffer == null) {
+ // awt.278=dataBuffer is null
+ throw new NullPointerException(Messages.getString("awt.278")); //$NON-NLS-1$
+ }
+
+ int dataType = dataBuffer.getDataType();
+
+ if (dataType != DataBuffer.TYPE_BYTE
+ && dataType != DataBuffer.TYPE_USHORT
+ && dataType != DataBuffer.TYPE_INT) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ BandedSampleModel sampleModel = new BandedSampleModel(dataType, w, h,
+ scanlineStride, bankIndices, bandOffsets);
+
+ return new OrdinaryWritableRaster(sampleModel, dataBuffer, location);
+ }
+
+ /**
+ * Creates a Raster object with a BandedSampleModel and the specified
+ * data type. The Data type can be one of the following values:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ *
+ * @param dataType the data type of the samples:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param scanlineStride the scanline stride of the image data.
+ * @param bankIndices the bank indices of bands.
+ * @param bandOffsets the band offsets of bands.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster object.
+ */
+ public static WritableRaster createBandedRaster(int dataType, int w, int h,
+ int scanlineStride, int bankIndices[], int bandOffsets[],
+ Point location) {
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (bankIndices == null || bandOffsets == null) {
+ // awt.277=bankIndices or bandOffsets is null
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.277")); //$NON-NLS-1$
+ }
+
+ if (dataType != DataBuffer.TYPE_BYTE
+ && dataType != DataBuffer.TYPE_USHORT
+ && dataType != DataBuffer.TYPE_INT) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ int maxOffset = bandOffsets[0];
+ int maxBank = bankIndices[0];
+
+ for (int i = 0; i < bankIndices.length; i++) {
+ if (bandOffsets[i] > maxOffset) {
+ maxOffset = bandOffsets[i];
+ }
+ if (bankIndices[i] > maxBank) {
+ maxBank = bankIndices[i];
+ }
+ }
+
+ int numBanks = maxBank + 1;
+ int dataSize = scanlineStride * (h - 1) + w + maxOffset;
+
+ DataBuffer data = null;
+
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ data = new DataBufferByte(dataSize, numBanks);
+ break;
+ case DataBuffer.TYPE_USHORT:
+ data = new DataBufferUShort(dataSize, numBanks);
+ break;
+ case DataBuffer.TYPE_INT:
+ data = new DataBufferInt(dataSize, numBanks);
+ break;
+ }
+ return createBandedRaster(data, w, h, scanlineStride, bankIndices,
+ bandOffsets, location);
+ }
+
+ /**
+ * Creates a Raster object with a BandedSampleModel and the specified
+ * data type. The Data type can be one of the following values:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ *
+ * @param dataType the data type of the samples:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param bands the number of bands.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster object.
+ */
+ public static WritableRaster createBandedRaster(int dataType, int w, int h,
+ int bands, Point location) {
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (bands < 1) {
+ // awt.279=bands is less than 1
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.279")); //$NON-NLS-1$
+ }
+
+ int bandOffsets[] = new int[bands];
+ int bankIndices[] = new int[bands];
+
+ for (int i = 0; i < bands; i++) {
+ bandOffsets[i] = 0;
+ bankIndices[i] = i;
+ }
+ return createBandedRaster(dataType, w, h, w, bankIndices, bandOffsets,
+ location);
+ }
+
+ /**
+ * Creates a Raster object with a PixelInterleavedSampleModel
+ * and the specified DataBuffer.
+ *
+ * @param dataBuffer the DataBuffer.
+ * @param w the width of image data.
+ * @param h the height of image data.
+ * @param scanlineStride the scanline stride of the image data.
+ * @param pixelStride the pixel stride of image data.
+ * @param bandOffsets the band offsets of bands.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster object.
+ */
+ public static WritableRaster createInterleavedRaster(DataBuffer dataBuffer,
+ int w, int h, int scanlineStride, int pixelStride,
+ int bandOffsets[], Point location) {
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (dataBuffer == null) {
+ // awt.278=dataBuffer is null
+ throw new NullPointerException(Messages.getString("awt.278")); //$NON-NLS-1$
+ }
+
+ int dataType = dataBuffer.getDataType();
+ if (dataType != DataBuffer.TYPE_BYTE
+ && dataType != DataBuffer.TYPE_USHORT) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ if (dataBuffer.getNumBanks() > 1) {
+ // awt.27A=dataBuffer has more than one bank
+ throw new RasterFormatException(Messages.getString("awt.27A")); //$NON-NLS-1$
+ }
+
+ if (bandOffsets == null) {
+ // awt.27B=bandOffsets is null
+ throw new NullPointerException(Messages.getString("awt.27B")); //$NON-NLS-1$
+ }
+
+ PixelInterleavedSampleModel sampleModel =
+ new PixelInterleavedSampleModel(dataType, w, h,
+ pixelStride, scanlineStride, bandOffsets);
+
+ return new OrdinaryWritableRaster(sampleModel, dataBuffer, location);
+
+ }
+
+ /**
+ * Creates a Raster object with a PixelInterleavedSampleModel
+ * and the specified data type. The Data type can be one of the
+ * following values:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ *
+ * @param dataType the data type of the samples:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ * @param w the width of image data.
+ * @param h the height of image data.
+ * @param scanlineStride the scanline stride of the image data.
+ * @param pixelStride the pixel stride of image data.
+ * @param bandOffsets the band offsets of bands.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster object.
+ */
+ public static WritableRaster createInterleavedRaster(int dataType, int w,
+ int h, int scanlineStride, int pixelStride, int bandOffsets[],
+ Point location) {
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (dataType != DataBuffer.TYPE_BYTE
+ && dataType != DataBuffer.TYPE_USHORT) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ if (bandOffsets == null) {
+ // awt.27B=bandOffsets is null
+ throw new NullPointerException(Messages.getString("awt.27B")); //$NON-NLS-1$
+ }
+
+ int minOffset = bandOffsets[0];
+ for (int i = 1; i < bandOffsets.length; i++) {
+ if (bandOffsets[i] < minOffset) {
+ minOffset = bandOffsets[i];
+ }
+ }
+ int size = (h - 1) * scanlineStride + w * pixelStride + minOffset;
+ DataBuffer data = null;
+
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ data = new DataBufferByte(size);
+ break;
+ case DataBuffer.TYPE_USHORT:
+ data = new DataBufferUShort(size);
+ break;
+ }
+
+ return createInterleavedRaster(data, w, h, scanlineStride, pixelStride,
+ bandOffsets, location);
+ }
+
+ /**
+ * Creates a Raster object with a PixelInterleavedSampleModel
+ * and the specified data type. The Data type can be one of the
+ * following values:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ *
+ * @param dataType the data type of samples:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ * @param w the width of image data.
+ * @param h the height of image data.
+ * @param bands the number of bands.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster.
+ */
+ public static WritableRaster createInterleavedRaster(int dataType, int w,
+ int h, int bands, Point location) {
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (dataType != DataBuffer.TYPE_BYTE
+ && dataType != DataBuffer.TYPE_USHORT) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ int bandOffsets[] = new int[bands];
+ for (int i = 0; i < bands; i++) {
+ bandOffsets[i] = i;
+ }
+
+ return createInterleavedRaster(dataType, w, h, w * bands, bands,
+ bandOffsets, location);
+ }
+
+ /**
+ * Creates a Raster object with a SinglePixelPackedSampleModel
+ * and the specified DataBuffer.
+ *
+ * @param dataBuffer the DataBuffer.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param scanlineStride the scanline stride of the image data.
+ * @param bandMasks the band masks.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster.
+ */
+ public static WritableRaster createPackedRaster(DataBuffer dataBuffer,
+ int w, int h, int scanlineStride, int bandMasks[], Point location) {
+ if (dataBuffer == null) {
+ // awt.278=dataBuffer is null
+ throw new NullPointerException(Messages.getString("awt.278")); //$NON-NLS-1$
+ }
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (bandMasks == null) {
+ // awt.27C=bandMasks is null
+ throw new RasterFormatException(Messages.getString("awt.27C")); //$NON-NLS-1$
+ }
+
+ if (dataBuffer.getNumBanks() > 1) {
+ // awt.27A=dataBuffer has more than one bank
+ throw new RasterFormatException(Messages.getString("awt.27A")); //$NON-NLS-1$
+ }
+
+ int dataType = dataBuffer.getDataType();
+ if (dataType != DataBuffer.TYPE_BYTE
+ && dataType != DataBuffer.TYPE_USHORT
+ && dataType != DataBuffer.TYPE_INT) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ SinglePixelPackedSampleModel sampleModel =
+ new SinglePixelPackedSampleModel(dataType, w, h,
+ scanlineStride, bandMasks);
+
+ return new OrdinaryWritableRaster(sampleModel, dataBuffer, location);
+ }
+
+ /**
+ * Creates a Raster object with a MultiPixelPackedSampleModel
+ * and the specified DataBuffer.
+ *
+ * @param dataBuffer the DataBuffer.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param bitsPerPixel the number of bits per pixel.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster.
+ */
+ public static WritableRaster createPackedRaster(DataBuffer dataBuffer,
+ int w, int h, int bitsPerPixel, Point location) {
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (dataBuffer == null) {
+ // awt.278=dataBuffer is null
+ throw new NullPointerException(Messages.getString("awt.278")); //$NON-NLS-1$
+ }
+
+ if (dataBuffer.getNumBanks() > 1) {
+ // awt.27A=dataBuffer has more than one bank
+ throw new RasterFormatException(Messages.getString("awt.27A")); //$NON-NLS-1$
+ }
+
+ int dataType = dataBuffer.getDataType();
+ if (dataType != DataBuffer.TYPE_BYTE
+ && dataType != DataBuffer.TYPE_USHORT
+ && dataType != DataBuffer.TYPE_INT) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ MultiPixelPackedSampleModel sampleModel =
+ new MultiPixelPackedSampleModel(dataType, w, h, bitsPerPixel);
+
+ return new OrdinaryWritableRaster(sampleModel, dataBuffer, location);
+
+ }
+
+ /**
+ * Creates a Raster object with a MultiPixelPackedSampleModel
+ * and the specified DataBuffer.
+ *
+ * @param dataType the data type of samples:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param bands the number of bands.
+ * @param bitsPerBand the number of bits per band.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster.
+ */
+ public static WritableRaster createPackedRaster(int dataType, int w, int h,
+ int bands, int bitsPerBand, Point location) {
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (bands < 1 || bitsPerBand < 1) {
+ // awt.27D=bitsPerBand or bands is not greater than zero
+ throw new IllegalArgumentException(Messages.getString("awt.27D")); //$NON-NLS-1$
+ }
+
+ if (dataType != DataBuffer.TYPE_BYTE
+ && dataType != DataBuffer.TYPE_USHORT
+ && dataType != DataBuffer.TYPE_INT) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ if (bitsPerBand * bands > DataBuffer.getDataTypeSize(dataType)) {
+ // awt.27E=The product of bitsPerBand and bands is greater than the number of bits held by dataType
+ throw new IllegalArgumentException(Messages.getString("awt.27E")); //$NON-NLS-1$
+ }
+
+ if (bands > 1) {
+
+ int bandMasks[] = new int[bands];
+ int mask = (1 << bitsPerBand) - 1;
+
+ for (int i = 0; i < bands; i++) {
+ bandMasks[i] = mask << (bitsPerBand * (bands - 1 - i));
+ }
+
+ return createPackedRaster(dataType, w, h, bandMasks, location);
+ }
+ DataBuffer data = null;
+ int size = ((bitsPerBand * w +
+ DataBuffer.getDataTypeSize(dataType) - 1) /
+ DataBuffer.getDataTypeSize(dataType)) * h;
+
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ data = new DataBufferByte(size);
+ break;
+ case DataBuffer.TYPE_USHORT:
+ data = new DataBufferUShort(size);
+ break;
+ case DataBuffer.TYPE_INT:
+ data = new DataBufferInt(size);
+ break;
+ }
+ return createPackedRaster(data, w, h, bitsPerBand, location);
+ }
+
+ /**
+ * Creates a Raster object with a SinglePixelPackedSampleModel
+ * and the specified DataBuffer.
+ *
+ * @param dataType the data type of samples:
+ * TYPE_BYTE, TYPE_USHORT, or TYPE_INT.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param bandMasks the band masks.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster.
+ */
+ public static WritableRaster createPackedRaster(int dataType, int w, int h,
+ int bandMasks[], Point location) {
+
+ if (dataType != DataBuffer.TYPE_BYTE
+ && dataType != DataBuffer.TYPE_USHORT
+ && dataType != DataBuffer.TYPE_INT) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ if ((long) location.x + w > Integer.MAX_VALUE
+ || (long) location.y + h > Integer.MAX_VALUE) {
+ // awt.276=location.x + w or location.y + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.276")); //$NON-NLS-1$
+ }
+
+ if (bandMasks == null) {
+ // awt.27C=bandMasks is null
+ throw new NullPointerException(Messages.getString("awt.27C")); //$NON-NLS-1$
+ }
+
+ DataBuffer data = null;
+
+ switch (dataType) {
+ case DataBuffer.TYPE_BYTE:
+ data = new DataBufferByte(w * h);
+ break;
+ case DataBuffer.TYPE_USHORT:
+ data = new DataBufferUShort(w * h);
+ break;
+ case DataBuffer.TYPE_INT:
+ data = new DataBufferInt(w * h);
+ break;
+ }
+
+ return createPackedRaster(data, w, h, w, bandMasks, location);
+ }
+
+ /**
+ * Creates a Raster object with the specified DataBuffer and SampleModel.
+ *
+ * @param sm the specified SampleModel.
+ * @param db the specified DataBuffer.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the Raster.
+ */
+ public static Raster createRaster(SampleModel sm, DataBuffer db,
+ Point location) {
+
+ if (sm == null || db == null) {
+ // awt.27F=SampleModel or DataBuffer is null
+ throw new NullPointerException(Messages.getString("awt.27F")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ return new Raster(sm, db, location);
+ }
+
+ /**
+ * Creates a WritableRaster with the specified SampleModel and DataBuffer.
+ *
+ * @param sm the specified SampleModel.
+ * @param db the specified DataBuffer.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster.
+ */
+ public static WritableRaster createWritableRaster(SampleModel sm,
+ DataBuffer db, Point location) {
+
+ if (sm == null || db == null) {
+ // awt.27F=SampleModel or DataBuffer is null
+ throw new NullPointerException(Messages.getString("awt.27F")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ return new OrdinaryWritableRaster(sm, db, location);
+ }
+
+ /**
+ * Creates a WritableRaster with the specified SampleModel.
+ *
+ * @param sm the specified SampleModel.
+ * @param location the location which defines the upper left corner
+ * of the Raster.
+ *
+ * @return the WritableRaster.
+ */
+ public static WritableRaster createWritableRaster(SampleModel sm,
+ Point location) {
+
+ if (sm == null) {
+ // awt.280=SampleModel is null
+ throw new NullPointerException(Messages.getString("awt.280")); //$NON-NLS-1$
+ }
+
+ if (location == null) {
+ location = new Point(0, 0);
+ }
+
+ return createWritableRaster(sm, sm.createDataBuffer(), location);
+ }
+
+ /**
+ * Instantiates a new Raster object with the specified SampleModel and
+ * DataBuffer.
+ *
+ * @param sampleModel the specified SampleModel.
+ * @param dataBuffer the specified DataBuffer.
+ * @param origin the specified origin.
+ */
+ protected Raster(SampleModel sampleModel, DataBuffer dataBuffer,
+ Point origin) {
+
+ this(sampleModel, dataBuffer, new Rectangle(origin.x, origin.y,
+ sampleModel.getWidth(), sampleModel.getHeight()), origin, null);
+ }
+
+ /**
+ * Instantiates a new Raster object with the specified SampleModel,
+ * DataBuffer, rectangular region and parent Raster.
+ *
+ * @param sampleModel the specified SampleModel.
+ * @param dataBuffer the specified DataBuffer.
+ * @param aRegion the a rectangular region which defines the new image bounds.
+ * @param sampleModelTranslate this point defines the translation point
+ * from the SampleModel coordinates to the new Raster coordinates.
+ * @param parent the parent of this Raster.
+ */
+ protected Raster(SampleModel sampleModel, DataBuffer dataBuffer,
+ Rectangle aRegion, Point sampleModelTranslate, Raster parent) {
+
+ if (sampleModel == null || dataBuffer == null || aRegion == null
+ || sampleModelTranslate == null) {
+ // awt.281=sampleModel, dataBuffer, aRegion or sampleModelTranslate is null
+ throw new NullPointerException(Messages.getString("awt.281")); //$NON-NLS-1$
+ }
+
+ if (aRegion.width <= 0 || aRegion.height <= 0) {
+ // awt.282=aRegion has width or height less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.282")); //$NON-NLS-1$
+ }
+
+ if ((long) aRegion.x + (long) aRegion.width > Integer.MAX_VALUE) {
+ // awt.283=Overflow X coordinate of Raster
+ throw new RasterFormatException(Messages.getString("awt.283")); //$NON-NLS-1$
+ }
+
+ if ((long) aRegion.y + (long) aRegion.height > Integer.MAX_VALUE) {
+ // awt.284=Overflow Y coordinate of Raster
+ throw new RasterFormatException(Messages.getString("awt.284")); //$NON-NLS-1$
+ }
+
+ if (sampleModel instanceof ComponentSampleModel) {
+ validateDataBuffer(dataBuffer, aRegion.width, aRegion.height,
+ ((ComponentSampleModel) sampleModel).getScanlineStride());
+ } else if (sampleModel instanceof MultiPixelPackedSampleModel) {
+ validateDataBuffer(dataBuffer, aRegion.width, aRegion.height,
+ ((MultiPixelPackedSampleModel) sampleModel)
+ .getScanlineStride());
+ } else if (sampleModel instanceof SinglePixelPackedSampleModel) {
+ validateDataBuffer(dataBuffer, aRegion.width, aRegion.height,
+ ((SinglePixelPackedSampleModel) sampleModel)
+ .getScanlineStride());
+ }
+
+ this.sampleModel = sampleModel;
+ this.dataBuffer = dataBuffer;
+ this.minX = aRegion.x;
+ this.minY = aRegion.y;
+ this.width = aRegion.width;
+ this.height = aRegion.height;
+ this.sampleModelTranslateX = sampleModelTranslate.x;
+ this.sampleModelTranslateY = sampleModelTranslate.y;
+ this.parent = parent;
+ this.numBands = sampleModel.getNumBands();
+ this.numDataElements = sampleModel.getNumDataElements();
+
+ }
+
+ /**
+ * Instantiates a new Raster with the specified SampleModel.
+ *
+ * @param sampleModel the specified SampleModel.
+ * @param origin the origin.
+ */
+ protected Raster(SampleModel sampleModel, Point origin) {
+ this(sampleModel, sampleModel.createDataBuffer(), new Rectangle(
+ origin.x, origin.y, sampleModel.getWidth(), sampleModel
+ .getHeight()), origin, null);
+ }
+
+ /**
+ * Creates the child of this Raster by sharing the specified rectangular
+ * area in this Raste. The parentX, parentY, width
+ * and height parameters specify the rectangular area to be shared.
+ *
+ * @param parentX the X coordinate of the upper left corner of this Raster.
+ * @param parentY the Y coordinate of the upper left corner of this Raster.
+ * @param width the width of the child area.
+ * @param height the height of the child area.
+ * @param childMinX the X coordinate of child area mapped to the parentX
+ * coordinate.
+ * @param childMinY the Y coordinate of child area mapped to the parentY
+ * coordinate.
+ * @param bandList the array of band indicies.
+ *
+ * @return the Raster.
+ */
+ public Raster createChild(int parentX, int parentY, int width, int height,
+ int childMinX, int childMinY, int bandList[]) {
+ if (width <= 0 || height <= 0) {
+ // awt.285=Width or Height of child Raster is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.285")); //$NON-NLS-1$
+ }
+
+ if (parentX < this.minX || parentX + width > this.minX + this.width) {
+ // awt.286=parentX disposes outside Raster
+ throw new RasterFormatException(Messages.getString("awt.286")); //$NON-NLS-1$
+ }
+
+ if (parentY < this.minY || parentY + height > this.minY + this.height) {
+ // awt.287=parentY disposes outside Raster
+ throw new RasterFormatException(Messages.getString("awt.287")); //$NON-NLS-1$
+ }
+
+ if ((long) parentX + width > Integer.MAX_VALUE) {
+ // awt.288=parentX + width results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.288")); //$NON-NLS-1$
+ }
+
+ if ((long) parentY + height > Integer.MAX_VALUE) {
+ // awt.289=parentY + height results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.289")); //$NON-NLS-1$
+ }
+
+ if ((long) childMinX + width > Integer.MAX_VALUE) {
+ // awt.28A=childMinX + width results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.28A")); //$NON-NLS-1$
+ }
+
+ if ((long) childMinY + height > Integer.MAX_VALUE) {
+ // awt.28B=childMinY + height results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.28B")); //$NON-NLS-1$
+ }
+
+ SampleModel childModel;
+
+ if (bandList == null) {
+ childModel = sampleModel;
+ } else {
+ childModel = sampleModel.createSubsetSampleModel(bandList);
+ }
+
+ int childTranslateX = childMinX - parentX;
+ int childTranslateY = childMinY - parentY;
+
+ return new Raster(childModel, dataBuffer, new Rectangle(childMinX,
+ childMinY, width, height), new Point(childTranslateX
+ + sampleModelTranslateX, childTranslateY
+ + sampleModelTranslateY), this);
+ }
+
+ /**
+ * Create a compatible WritableRaster with the same parameters
+ * as this Raster.
+ *
+ * @return the WritableRaster.
+ */
+ public WritableRaster createCompatibleWritableRaster() {
+ return new OrdinaryWritableRaster(sampleModel, new Point(0, 0));
+ }
+
+ /**
+ * Create a compatible WritableRaster with the same parameters
+ * as this Raster and the specified size.
+ *
+ * @param w the width of the new WritableRaster.
+ * @param h the height of the new WritableRaster.
+ *
+ * @return the WritableRaster.
+ */
+ public WritableRaster createCompatibleWritableRaster(int w, int h) {
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ SampleModel sm = sampleModel.createCompatibleSampleModel(w, h);
+
+ return new OrdinaryWritableRaster(sm, new Point(0, 0));
+ }
+
+ /**
+ * Create a compatible WritableRaster with the same parameters
+ * as this Raster and the specified size and location.
+ *
+ * @param x the X coordinate of the new WritableRaster.
+ * @param y the Y coordinate of the new WritableRaster.
+ * @param w the width of the new WritableRaster.
+ * @param h the height of the new WritableRaster.
+ *
+ * @return the WritableRaster.
+ */
+ public WritableRaster createCompatibleWritableRaster(int x, int y, int w,
+ int h) {
+
+ WritableRaster raster = createCompatibleWritableRaster(w, h);
+
+ return raster.createWritableChild(0, 0, w, h, x, y, null);
+ }
+
+ /**
+ * Create a compatible WritableRaster with the same parameters
+ * as this Raster and the specified rectangle which determines
+ * new WritableRaster's location and size.
+ *
+ * @param rect the specified Rectangle.
+ *
+ * @return the WritableRaster.
+ */
+ public WritableRaster createCompatibleWritableRaster(Rectangle rect) {
+ if (rect == null) {
+ // awt.28C=Rect is null
+ throw new NullPointerException(Messages.getString("awt.28C")); //$NON-NLS-1$
+ }
+
+ return createCompatibleWritableRaster(rect.x, rect.y, rect.width,
+ rect.height);
+ }
+
+ /**
+ * Creates the translated child of this Raster. The New Raster
+ * object is a reference to the this Raster with a
+ * different location.
+ *
+ * @param childMinX the X coordinate of the new Raster.
+ * @param childMinY the Y coordinate of the new Raster.
+ *
+ * @return the Raster.
+ */
+ public Raster createTranslatedChild(int childMinX, int childMinY) {
+ return createChild(minX, minY, width, height, childMinX, childMinY,
+ null);
+ }
+
+ /**
+ * Gets the bounds of this Raster as a rectangle.
+ *
+ * @return the bounds of this Raster.
+ */
+ public Rectangle getBounds() {
+ return new Rectangle(minX, minY, width, height);
+ }
+
+ /**
+ * Gets the DataBuffer associated with this Raster.
+ *
+ * @return the DataBuffer associated with this Raster.
+ */
+ public DataBuffer getDataBuffer() {
+ return dataBuffer;
+ }
+
+ /**
+ * Gets the data elements which represent the pixel data of the specified
+ * rectangle area as a primitive array. The following image data types
+ * are supported: DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
+ * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT,
+ * or DataBuffer.TYPE_DOUBLE.
+ *
+ * @param x the X coordinate of the area of pixels.
+ * @param y the Y coordinate of the area of pixels.
+ * @param w the width of the area of pixels.
+ * @param h the height of the area of pixels.
+ * @param outData the resulting array.
+ *
+ * @return the data elements of the specified area of this Raster.
+ */
+ public Object getDataElements(int x, int y, int w, int h, Object outData) {
+ return sampleModel.getDataElements(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, w, h, outData, dataBuffer);
+ }
+
+ /**
+ * Gets the data elements which represent the specified pixel of
+ * this Raster as a primitive array. The following image data types
+ * are supported: DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
+ * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT,
+ * or DataBuffer.TYPE_DOUBLE.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param outData the resulting data.
+ *
+ * @return the data elements of the specified pixel of this Raster.
+ */
+ public Object getDataElements(int x, int y, Object outData) {
+ return sampleModel.getDataElements(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, outData, dataBuffer);
+ }
+
+ /**
+ * Gets the height of this Raster.
+ *
+ * @return the height of this Raster.
+ */
+ public final int getHeight() {
+ return height;
+ }
+
+ /**
+ * Gets the minimum X coordinate of this Raster.
+ *
+ * @return the minimum X coordinate of this Raster.
+ */
+ public final int getMinX() {
+ return minX;
+ }
+
+ /**
+ * Gets the minimum Y coordinate of this Raster.
+ *
+ * @return the minimum Y coordinate of this Raster.
+ */
+ public final int getMinY() {
+ return minY;
+ }
+
+ /**
+ * Gets the number of bands in this Raster.
+ *
+ * @return the number of bands in this Raster.
+ */
+ public final int getNumBands() {
+ return numBands;
+ }
+
+ /**
+ * Gets the number of data elements for one pixel.
+ *
+ * @return the number of data elements for one pixel.
+ */
+ public final int getNumDataElements() {
+ return numDataElements;
+ }
+
+ /**
+ * Gets the parent Raster for this Raster object.
+ *
+ * @return the parent Raster for this Raster object.
+ */
+ public Raster getParent() {
+ return parent;
+ }
+
+ /**
+ * Gets a double array of samples for the specified pixel in this Raster.
+ *
+ * @param x the pixel's X coordinate.
+ * @param y the pixel's Y coordinate.
+ * @param dArray the double array where result array will be stored.
+ *
+ * @return the double array of samples for the specified pixel in
+ * this Raster.
+ */
+ public double[] getPixel(int x, int y, double dArray[]) {
+ return sampleModel.getPixel(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, dArray, dataBuffer);
+ }
+
+ /**
+ * Gets a float array of samples for the specified pixel in this Raster.
+ *
+ * @param x the pixel's X coordinate.
+ * @param y the pixel's Y coordinate.
+ * @param fArray the float array where the result array will be stored.
+ *
+ * @return the float array of samples for the specified pixel in
+ * this Raster.
+ */
+ public float[] getPixel(int x, int y, float fArray[]) {
+ return sampleModel.getPixel(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, fArray, dataBuffer);
+ }
+
+ /**
+ * Gets an int array of samples for the specified pixel in this Raster.
+ *
+ * @param x the pixel's X coordinate.
+ * @param y the pixel's Y coordinate.
+ * @param iArray the int array where the result array will be stored.
+ *
+ * @return the int array of samples for the specified pixel in
+ * this Raster.
+ */
+ public int[] getPixel(int x, int y, int iArray[]) {
+ return sampleModel.getPixel(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, iArray, dataBuffer);
+ }
+
+ /**
+ * Gets an double array of samples for the specified rectangular
+ * area of pixels in this Raster.
+ *
+ * @param x the X coordinate of the area of pixels.
+ * @param y the Y coordinate of the area of pixels.
+ * @param w the width of the area of pixels.
+ * @param h the height of the area of pixels.
+ * @param dArray the resulting array.
+ *
+ * @return the double array of samples for the specified rectangular
+ * area of pixels in this Raster.
+ */
+ public double[] getPixels(int x, int y, int w, int h, double dArray[]) {
+ return sampleModel.getPixels(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, w, h, dArray, dataBuffer);
+ }
+
+ /**
+ * Gets an float array of samples for the specified rectangular
+ * area of pixels in this Raster.
+ *
+ * @param x the X coordinate of the area of pixels.
+ * @param y the Y coordinate of the area of pixels.
+ * @param w the width of the area of pixels.
+ * @param h the height of the area of pixels.
+ * @param fArray the resulting array.
+ *
+ * @return the float array of samples for the specified rectangular
+ * area of pixels in this Raster.
+ */
+ public float[] getPixels(int x, int y, int w, int h, float fArray[]) {
+ return sampleModel.getPixels(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, w, h, fArray, dataBuffer);
+ }
+
+ /**
+ * Gets an int array of samples for the specified rectangular
+ * area of pixels in this Raster.
+ *
+ * @param x the X coordinate of the area of pixels.
+ * @param y the Y coordinate of the area of pixels.
+ * @param w the width of pixel's the area of pixels.
+ * @param h the height of pixel's the area of pixels.
+ * @param iArray the resulting array.
+ *
+ * @return the int array of samples for the specified rectangular
+ * area of pixels in this Raster.
+ */
+ public int[] getPixels(int x, int y, int w, int h, int iArray[]) {
+ return sampleModel.getPixels(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, w, h, iArray, dataBuffer);
+ }
+
+ /**
+ * Gets the sample for the specified band of the specified
+ * pixel as an int.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the band.
+ *
+ * @return the sample for the specified band of the specified
+ * pixel as an int.
+ */
+ public int getSample(int x, int y, int b) {
+ return sampleModel.getSample(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, b, dataBuffer);
+ }
+
+ /**
+ * Gets the sample for the specified band of the specified
+ * pixel as a double.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the band.
+ *
+ * @return the sample for the specified band of the specified
+ * pixel as a double.
+ */
+ public double getSampleDouble(int x, int y, int b) {
+ return sampleModel.getSampleDouble(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, b, dataBuffer);
+ }
+
+ /**
+ * Gets the sample for the specified band of the specified
+ * pixel as a float.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the band.
+ *
+ * @return the sample for the specified band of the specified
+ * pixel as a float.
+ */
+ public float getSampleFloat(int x, int y, int b) {
+ return sampleModel.getSampleFloat(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, b, dataBuffer);
+ }
+
+ /**
+ * Gets the SampleModel associated with this Raster.
+ *
+ * @return the SampleModel associated with this Raster.
+ */
+ public SampleModel getSampleModel() {
+ return sampleModel;
+ }
+
+ /**
+ * Gets the translation of the X coordinate from the SampleModel
+ * coordinate system to the Rasters's coordinate system.
+ *
+ * @return the value of the translation of the X coordinate from
+ * the SampleModel coordinate system to the Rasters's
+ * coordinate system.
+ */
+ public final int getSampleModelTranslateX() {
+ return sampleModelTranslateX;
+ }
+
+ /**
+ * Gets the translation of the Y coordinate from the SampleModel
+ * coordinate system to the Rasters's coordinate system.
+ *
+ * @return the value of the translation of the Y coordinate from
+ * the SampleModel coordinate system to the Rasters's
+ * coordinate system.
+
+ */
+ public final int getSampleModelTranslateY() {
+ return sampleModelTranslateY;
+ }
+
+ /**
+ * Gets the double array of samples for the specified band
+ * of the specified rectangular area of pixels in this Raster
+ * as a double array.
+ *
+ * @param x the X coordinate of the rectangular area of pixels.
+ * @param y the Y coordinate of the rectangular area of pixels.
+ * @param w the width of the rectangular area of pixels.
+ * @param h the height of the rectangular area of pixels.
+ * @param b the band.
+ * @param dArray the resulting double array.
+ *
+ * @return the double array of samples for the specified band
+ * of the specified rectangular area of pixels.
+ */
+ public double[] getSamples(int x, int y, int w, int h, int b,
+ double dArray[]) {
+
+ return sampleModel.getSamples(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, w, h, b, dArray, dataBuffer);
+ }
+
+ /**
+ * Gets the float array of samples for the specified band
+ * of the specified rectangular area of pixels in this Raster
+ * as a float array.
+ *
+ * @param x the X coordinate of the rectangular area of pixels.
+ * @param y the Y coordinate of the rectangular area of pixels.
+ * @param w the width of the rectangular area of pixels.
+ * @param h the height of the rectangular area of pixels.
+ * @param b the band.
+ * @param fArray the resulting float array.
+ *
+ * @return the float array of samples for the specified band
+ * of the specified rectangular area of pixels.
+ */
+ public float[] getSamples(int x, int y, int w, int h, int b, float fArray[]) {
+
+ return sampleModel.getSamples(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, w, h, b, fArray, dataBuffer);
+ }
+
+ /**
+ * Gets the int array of samples for the specified band
+ * of the specified rectangular area of pixels in this Raster
+ * as a int array.
+ *
+ * @param x the X coordinate of the rectangular area of pixels.
+ * @param y the Y coordinate of the rectangular area of pixels.
+ * @param w the width of the rectangular area of pixels.
+ * @param h the height of the rectangular area of pixels.
+ * @param b the band.
+ * @param iArray the resulting int array.
+ *
+ * @return the int array of samples for the specified band
+ * of the specified rectangular area of pixels.
+ */
+ public int[] getSamples(int x, int y, int w, int h, int b, int iArray[]) {
+ return sampleModel.getSamples(x - sampleModelTranslateX, y
+ - sampleModelTranslateY, w, h, b, iArray, dataBuffer);
+ }
+
+ /**
+ * Gets the transfer type for pixels of this Raster.
+ * @see SampleModel#getTransferType()
+ *
+ * @return the transfer type for pixels of this Raster.
+ */
+ public final int getTransferType() {
+ return sampleModel.getTransferType();
+ }
+
+ /**
+ * Gets the width of this Raster.
+ *
+ * @return the width of this Raster.
+ */
+ public final int getWidth() {
+ return width;
+ }
+
+ /**
+ * Validate data buffer.
+ *
+ * @param dataBuffer the data buffer
+ * @param w the w
+ * @param h the h
+ * @param scanlineStride the scanline stride
+ */
+ private static void validateDataBuffer(final DataBuffer dataBuffer, final int w,
+ final int h, final int scanlineStride) {
+ if (dataBuffer.getSize() < (scanlineStride * (h - 1) + w - 1)) {
+ // awt.298=dataBuffer is too small
+ throw new RasterFormatException(Messages.getString("awt.298")); //$NON-NLS-1$
+ }
+ }
+}
+
+
diff --git a/awt/java/awt/image/RasterFormatException.java b/awt/java/awt/image/RasterFormatException.java
new file mode 100644
index 0000000..8577dad
--- /dev/null
+++ b/awt/java/awt/image/RasterFormatException.java
@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+
+/**
+ * The RasterFormatException class represents the exception
+ * that is thrown when there's an invalid layout
+ * in the Raster.
+ */
+public class RasterFormatException extends RuntimeException {
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = 96598996116164315L;
+
+ /**
+ * Instantiates a new RasterFormatException with the
+ * specified detail message.
+ *
+ * @param s the detail message.
+ */
+ public RasterFormatException(String s) {
+ super(s);
+ }
+
+}
+
diff --git a/awt/java/awt/image/RasterOp.java b/awt/java/awt/image/RasterOp.java
new file mode 100644
index 0000000..e8933ee
--- /dev/null
+++ b/awt/java/awt/image/RasterOp.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.RenderingHints;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * The RasterOp interface provides methods for performing transformations
+ * from source data to destination data for Raster objects. The source and
+ * destination objects should contain the appropriate number of bands for
+ * the particular classes which implement this interface.
+ */
+public interface RasterOp {
+
+ /**
+ * Creates a destination WritableRaster with the specified Raster;
+ * this destination image data is empty and has the correct size
+ * and number of bands.
+ *
+ * @param src the source Raster.
+ *
+ * @return the WritableRaster.
+ */
+ public WritableRaster createCompatibleDestRaster(Raster src);
+
+ /**
+ * Performs a filter operation on the source Raster and stores the resulting
+ * image data to the destination WritableRaster.
+ *
+ * @param src the source Raster.
+ * @param dst the destination WritableRaster, where the result is stored.
+ *
+ * @return the filtered WritableRaster.
+ */
+ public WritableRaster filter(Raster src, WritableRaster dst);
+
+ /**
+ * Gets the bounds of the filtered Raster.
+ *
+ * @param src the source Raster to be filtered.
+ *
+ * @return the rectangle bounds of the filtered Raster.
+ */
+ public Rectangle2D getBounds2D(Raster src);
+
+ /**
+ * Gets the point of the destination image which corresponds
+ * to the specified point in the source raster.
+ *
+ * @param srcPoint the point of the source raster.
+ * @param dstPoint the point where the result will be stored.
+ *
+ * @return the destination point.
+ */
+ public Point2D getPoint2D(Point2D srcPoint, Point2D dstPoint);
+
+ /**
+ * Gets the RenderingHints of the RasterOp.
+ *
+ * @return the RenderingHints of the RasterOp.
+ */
+ public RenderingHints getRenderingHints();
+}
diff --git a/awt/java/awt/image/RenderedImage.java b/awt/java/awt/image/RenderedImage.java
new file mode 100644
index 0000000..db3a4c8
--- /dev/null
+++ b/awt/java/awt/image/RenderedImage.java
@@ -0,0 +1,198 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Rectangle;
+import java.util.Vector;
+
+/**
+ * The RenderedImage interface should be implemented by all objects which
+ * contains image data. The image data is represented as a single tile or
+ * an array of tiles.
+ */
+public interface RenderedImage {
+
+ /**
+ * Gets the property with the specified name from the property set
+ * of this RenderedImage.
+ *
+ * @param name the property's name.
+ *
+ * @return the property value corresponded to this property's name.
+ */
+ public Object getProperty(String name);
+
+ /**
+ * Copies the region of this RenderedImage to the specified
+ * WritableRaster. The bounds of the region are the bounds of the
+ * WritableRaster.
+ *
+ * @param raster the WritableRaster.
+ *
+ * @return the created WritableRaster.
+ */
+ public WritableRaster copyData(WritableRaster raster);
+
+ /**
+ * Gets the image data of the image's region as one tile.
+ *
+ * @param rect the rectangular region of RenderedImage.
+ *
+ * @return the image data of the image's region as one tile.
+ */
+ public Raster getData(Rectangle rect);
+
+ /**
+ * Gets all RenderedImage objects which are the source of this
+ * RenderedImage object.
+ *
+ * @return a Vector of RenderedImage objects which are the source
+ * of this RenderedImage object or null, if there is no information
+ * about them.
+ */
+ public Vector<RenderedImage> getSources();
+
+ /**
+ * Gets the set of all property names for this RenderedImage.
+ *
+ * @return the array of all property names for this RenderedImage.
+ */
+ public String[] getPropertyNames();
+
+ /**
+ * Gets the SampleModel of this RenderedImage.
+ *
+ * @return the SampleModel of this RenderedImage.
+ */
+ public SampleModel getSampleModel();
+
+ /**
+ * Gets the tile corresponded to the specified indices in the tile
+ * array.
+ *
+ * @param tileX the X index of the tile.
+ * @param tileY the Y index of the tile.
+ *
+ * @return the tile corresponded to the specified indices in the tile
+ * array.
+ */
+ public Raster getTile(int tileX, int tileY);
+
+ /**
+ * Gets the image data of this image as one tile.
+ *
+ * @return the image data of this image as one tile.
+ */
+ public Raster getData();
+
+ /**
+ * Gets the ColorModel of this RenderedImage.
+ *
+ * @return the ColorModel of this RenderedImage.
+ */
+ public ColorModel getColorModel();
+
+ /**
+ * Gets the width of the RenderedImage.
+ *
+ * @return the width of the RenderedImage.
+ */
+ public int getWidth();
+
+ /**
+ * Gets the tile width.
+ *
+ * @return the tile width in pixels.
+ */
+ public int getTileWidth();
+
+ /**
+ * Gets the tile height.
+ *
+ * @return the tile height in pixels.
+ */
+ public int getTileHeight();
+
+ /**
+ * Gets the Y offset of the tile grid.
+ *
+ * @return the Y offset of the tile grid.
+ */
+ public int getTileGridYOffset();
+
+ /**
+ * Gets the X offset of the tile grid.
+ *
+ * @return the X offset of the tile grid.
+ */
+ public int getTileGridXOffset();
+
+ /**
+ * Gets the number of tiles along Y direction.
+ *
+ * @return the number of tiles along Y direction.
+ */
+ public int getNumYTiles();
+
+ /**
+ * Gets the number of tiles along X direction.
+ *
+ * @return the number of tiles along X direction.
+ */
+ public int getNumXTiles();
+
+ /**
+ * Gets the minimum Y coordinate of this RenderedImage.
+ *
+ * @return the minimum Y coordinate of this RenderedImage.
+ */
+ public int getMinY();
+
+ /**
+ * Gets the minimum X coordinate of this RenderedImage.
+ *
+ * @return the minimum X coordinate of this RenderedImage.
+ */
+ public int getMinX();
+
+ /**
+ * Gets the minimum tile's index along the Y direction.
+ *
+ * @return the minimum tile's index along the Y direction.
+ */
+ public int getMinTileY();
+
+ /**
+ * Gets the minimum tile's index along the X direction.
+ *
+ * @return the minimum tile's index along the X direction.
+ */
+ public int getMinTileX();
+
+ /**
+ * Gets the height of the RenderedImage.
+ *
+ * @return the height of the RenderedImage.
+ */
+ public int getHeight();
+
+}
+
diff --git a/awt/java/awt/image/ReplicateScaleFilter.java b/awt/java/awt/image/ReplicateScaleFilter.java
new file mode 100644
index 0000000..9298125
--- /dev/null
+++ b/awt/java/awt/image/ReplicateScaleFilter.java
@@ -0,0 +1,213 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.util.Hashtable;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+
+/**
+ * The ReplicateScaleFilter class scales an source image
+ * by replicating rows and columns of pixels to scale up or
+ * omitting rows and columns of pixels to scale down.
+ */
+public class ReplicateScaleFilter extends ImageFilter {
+
+ /** The width of a source image. */
+ protected int srcWidth;
+
+ /** The height of a source image. */
+ protected int srcHeight;
+
+ /** The width of a destination image. */
+ protected int destWidth;
+
+ /** The height of a destination image. */
+ protected int destHeight;
+
+ /** The int array of source rows. */
+ protected int[] srcrows;
+
+ /** The int array of source columns. */
+ protected int[] srccols;
+
+ /**
+ * An Object (byte array with a destination width) provides
+ * a row of pixel data to the ImageConsumer.
+ */
+ protected Object outpixbuf;
+
+ /**
+ * Instantiates a new ReplicateScaleFilter that filters
+ * the image with the specified width and height.
+ *
+ * @param width the width of scaled image.
+ * @param height the height of scaled image.
+ */
+ public ReplicateScaleFilter(int width, int height) {
+ if(width == 0 || height == 0) {
+ // awt.234=Width or Height equals zero
+ throw new IllegalArgumentException(Messages.getString("awt.234")); //$NON-NLS-1$
+ }
+
+ this.destWidth = width;
+ this.destHeight = height;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public void setProperties(Hashtable<?, ?> props) {
+ Hashtable<Object, Object> fprops;
+ if(props == null) {
+ fprops = new Hashtable<Object, Object>();
+ } else {
+ fprops = (Hashtable<Object, Object>) props.clone();
+ }
+ String propName = "Rescale Filters"; //$NON-NLS-1$
+ String prop = "destWidth=" + destWidth + "; " + //$NON-NLS-1$ //$NON-NLS-2$
+ "destHeight=" + destHeight; //$NON-NLS-1$
+ Object o = fprops.get(propName);
+ if(o != null){
+ if(o instanceof String){
+ prop = (String)o + "; " + prop; //$NON-NLS-1$
+ }else{
+ prop = o.toString() + "; " + prop; //$NON-NLS-1$
+ }
+ }
+ fprops.put(propName, prop);
+ consumer.setProperties(fprops);
+ }
+
+ // setPixels methods produce pixels according to Java API Spacification
+
+ @Override
+ public void setPixels(int x, int y, int w, int h,
+ ColorModel model, int[] pixels, int off, int scansize) {
+
+ if(srccols == null) {
+ initArrays();
+ }
+ int buff[];
+ if(outpixbuf == null || !(outpixbuf instanceof int[])){
+ buff = new int[destWidth];
+ outpixbuf = buff;
+ }else{
+ buff = (int[])outpixbuf;
+ }
+
+ int wa = (srcWidth - 1) >>> 1;
+ int ha = (srcHeight - 1) >>> 1;
+ int dstX = (x * destWidth + wa) / srcWidth;
+ int dstY = (y * destHeight + ha) / srcHeight;
+
+ int sx, sy, dx, dy;
+ dy = dstY;
+ while((dy < destHeight) && ((sy = srcrows[dy]) < y + h)){
+ dx = dstX;
+ int srcOff = off + (sy - y) * scansize;
+ while((dx < destWidth) && ((sx = srccols[dx]) < x + w)){
+ buff[dx] = pixels[srcOff + (sx - x)];
+ dx++;
+ }
+
+ consumer.setPixels(dstX, dy, dx - dstX, 1, model, buff,
+ dstX, destWidth);
+ dy++;
+ }
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h,
+ ColorModel model, byte[] pixels, int off, int scansize) {
+
+ if(srccols == null) {
+ initArrays();
+ }
+ byte buff[];
+ if(outpixbuf == null || !(outpixbuf instanceof byte[])){
+ buff = new byte[destWidth];
+ outpixbuf = buff;
+ }else{
+ buff = (byte[])outpixbuf;
+ }
+
+ int wa = (srcWidth - 1) >>> 1;
+ int ha = (srcHeight - 1) >>> 1;
+ int dstX = (x * destWidth + wa) / srcWidth;
+ int dstY = (y * destHeight + ha) / srcHeight;
+
+ int sx, sy, dx, dy;
+ dy = dstY;
+ while((dy < destHeight) && ((sy = srcrows[dy]) < y + h)){
+ dx = dstX;
+ int srcOff = off + (sy - y) * scansize;
+ while((dx < destWidth) && ((sx = srccols[dx]) < x + w)){
+ buff[dx] = pixels[srcOff + (sx - x)];
+ dx++;
+ }
+
+ consumer.setPixels(dstX, dy, dx - dstX, 1, model, buff,
+ dstX, destWidth);
+ dy++;
+ }
+ }
+
+ @Override
+ public void setDimensions(int w, int h) {
+ srcWidth = w;
+ srcHeight = h;
+
+ if(destWidth < 0 && destHeight < 0){
+ destWidth = srcWidth;
+ destHeight = srcHeight;
+ }else if(destWidth < 0){
+ destWidth = destHeight * srcWidth / srcHeight;
+ }else if(destHeight < 0){
+ destHeight = destWidth * srcHeight / srcWidth;
+ }
+ consumer.setDimensions(destWidth, destHeight);
+ }
+
+ /**
+ * Initialization of srccols and srcrows arrays.
+ */
+ private void initArrays(){
+ if ((destWidth < 0) || (destHeight < 0)) {
+ throw new IndexOutOfBoundsException();
+ }
+
+ srccols = new int[destWidth];
+ int ca = srcWidth >>> 1;
+ for(int i = 0; i < destWidth; i++){
+ srccols[i] = (i * srcWidth + ca) / destWidth;
+ }
+
+ srcrows = new int[destHeight];
+ int ra = srcHeight >>> 1;
+ for(int i = 0; i < destHeight; i++){
+ srcrows[i] = (i * srcHeight + ra) / destHeight;
+ }
+ }
+
+}
+
+
diff --git a/awt/java/awt/image/RescaleOp.java b/awt/java/awt/image/RescaleOp.java
new file mode 100644
index 0000000..0e96031
--- /dev/null
+++ b/awt/java/awt/image/RescaleOp.java
@@ -0,0 +1,659 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ *
+ * @date: Oct 6, 2005
+ */
+
+package java.awt.image;
+
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.*;
+import java.util.Arrays;
+
+import org.apache.harmony.awt.gl.AwtImageBackdoorAccessor;
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class RescaleOp performs rescaling of the source image data
+ * by multiplying the pixel values with a scale factor
+ * and then adding an offset.
+ */
+public class RescaleOp implements BufferedImageOp, RasterOp {
+
+ /** The scale factors. */
+ private float scaleFactors[];
+
+ /** The offsets. */
+ private float offsets[];
+
+ /** The hints. */
+ private RenderingHints hints;
+
+ static {
+ // TODO
+ //System.loadLibrary("imageops");
+ }
+
+ /**
+ * Instantiates a new RescaleOp object with the specified
+ * scale factors and offsets.
+ *
+ * @param scaleFactors the array of scale factor values.
+ * @param offsets the array of offset values.
+ * @param hints the RenderingHints or null.
+ */
+ public RescaleOp(float[] scaleFactors, float[] offsets, RenderingHints hints) {
+ int numFactors = Math.min(scaleFactors.length, offsets.length);
+
+ this.scaleFactors = new float[numFactors];
+ this.offsets = new float[numFactors];
+
+ System.arraycopy(scaleFactors, 0, this.scaleFactors, 0, numFactors);
+ System.arraycopy(offsets, 0, this.offsets, 0, numFactors);
+
+ this.hints = hints;
+ }
+
+ /**
+ * Instantiates a new RescaleOp object with the specified
+ * scale factor and offset.
+ *
+ * @param scaleFactor the scale factor.
+ * @param offset the offset.
+ * @param hints the RenderingHints or null.
+ */
+ public RescaleOp(float scaleFactor, float offset, RenderingHints hints) {
+ scaleFactors = new float[1];
+ offsets = new float[1];
+
+ scaleFactors[0] = scaleFactor;
+ offsets[0] = offset;
+
+ this.hints = hints;
+ }
+
+ /**
+ * Gets the number of scaling factors.
+ *
+ * @return the number of scaling factors.
+ */
+ public final int getNumFactors() {
+ return scaleFactors.length;
+ }
+
+ public final RenderingHints getRenderingHints() {
+ return hints;
+ }
+
+ /**
+ * Gets the scale factors of this RescaleOp.
+ *
+ * @param scaleFactors the desired scale factors array will be copied
+ * to this array.
+ *
+ * @return the scale factors array.
+ */
+ public final float[] getScaleFactors(float[] scaleFactors) {
+ if (scaleFactors == null) {
+ scaleFactors = new float[this.scaleFactors.length];
+ }
+
+ int minLength = Math.min(scaleFactors.length, this.scaleFactors.length);
+ System.arraycopy(this.scaleFactors, 0, scaleFactors, 0, minLength);
+ return scaleFactors;
+ }
+
+ /**
+ * Gets the offsets array of this RescaleOp.
+ *
+ * @param offsets the desired offsets array will be copied to this array.
+ *
+ * @return the offsets array of this RescaleOp.
+ */
+ public final float[] getOffsets(float[] offsets) {
+ if (offsets == null) {
+ offsets = new float[this.offsets.length];
+ }
+
+ int minLength = Math.min(offsets.length, this.offsets.length);
+ System.arraycopy(this.offsets, 0, offsets, 0, minLength);
+ return offsets;
+ }
+
+ public final Point2D getPoint2D(Point2D srcPt, Point2D dstPt) {
+ if (dstPt == null) {
+ dstPt = new Point2D.Float();
+ }
+
+ dstPt.setLocation(srcPt);
+ return dstPt;
+ }
+
+ public final Rectangle2D getBounds2D(Raster src) {
+ return src.getBounds();
+ }
+
+ public final Rectangle2D getBounds2D(BufferedImage src) {
+ return getBounds2D(src.getRaster());
+ }
+
+ public WritableRaster createCompatibleDestRaster(Raster src) {
+ return src.createCompatibleWritableRaster();
+ }
+
+ public BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel dstCM) {
+ if (dstCM == null) {
+ dstCM = src.getColorModel();
+ }
+
+ if (dstCM instanceof IndexColorModel) {
+ dstCM = ColorModel.getRGBdefault();
+ }
+
+ WritableRaster r =
+ dstCM.isCompatibleSampleModel(src.getSampleModel()) ?
+ src.getRaster().createCompatibleWritableRaster(src.getWidth(), src.getHeight()) :
+ dstCM.createCompatibleWritableRaster(src.getWidth(), src.getHeight());
+
+ return new BufferedImage(
+ dstCM,
+ r,
+ dstCM.isAlphaPremultiplied(),
+ null
+ );
+ }
+
+ public final WritableRaster filter(Raster src, WritableRaster dst) {
+ if (dst == null) {
+ dst = createCompatibleDestRaster(src);
+ } else {
+ if (src.getNumBands() != dst.getNumBands()) {
+ // awt.21D=Number of src bands ({0}) does not match number of dst bands ({1})
+ throw new IllegalArgumentException(Messages.getString("awt.21D", //$NON-NLS-1$
+ src.getNumBands(), dst.getNumBands()));
+ }
+ }
+
+ if (
+ this.scaleFactors.length != 1 &&
+ this.scaleFactors.length != src.getNumBands()
+ ) {
+ // awt.21E=Number of scaling constants is not equal to the number of bands
+ throw new IllegalArgumentException(Messages.getString("awt.21E")); //$NON-NLS-1$
+ }
+
+ // TODO
+ //if (ippFilter(src, dst, BufferedImage.TYPE_CUSTOM, false) != 0)
+ if (slowFilter(src, dst, false) != 0) {
+ // awt.21F=Unable to transform source
+ throw new ImagingOpException (Messages.getString("awt.21F")); //$NON-NLS-1$
+ }
+
+ return dst;
+ }
+
+ /**
+ * Slow filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ * @param skipAlpha the skip alpha
+ *
+ * @return the int
+ */
+ private final int slowFilter(Raster src, WritableRaster dst, boolean skipAlpha) {
+ SampleModel sm = src.getSampleModel();
+
+ int numBands = src.getNumBands();
+ int srcHeight = src.getHeight();
+ int srcWidth = src.getWidth();
+
+ int srcMinX = src.getMinX();
+ int srcMinY = src.getMinY();
+ int dstMinX = dst.getMinX();
+ int dstMinY = dst.getMinY();
+
+ int[] maxValues = new int[numBands];
+ int[] masks = new int[numBands];
+ int[] sampleSizes = sm.getSampleSize();
+
+ for (int i=0; i < numBands; i++){
+ maxValues[i] = (1 << sampleSizes[i]) - 1;
+ masks[i] = ~(maxValues[i]);
+ }
+
+ // Processing bounds
+ float[] pixels = null;
+ pixels = src.getPixels(srcMinX, srcMinY, srcWidth, srcHeight, pixels);
+
+ // Cycle over pixels to be calculated
+ if (skipAlpha) { // Always suppose that alpha channel is the last band
+ if (scaleFactors.length > 1) {
+ for (int i = 0; i < pixels.length; ){
+ for (int bandIdx = 0; bandIdx < numBands-1; bandIdx++, i++){
+ pixels[i] = pixels[i] * scaleFactors[bandIdx] + offsets[bandIdx];
+ // Check for overflow now
+ if (((int)pixels[i] & masks[bandIdx]) != 0) {
+ if (pixels[i] < 0) {
+ pixels[i] = 0;
+ } else {
+ pixels[i] = maxValues[bandIdx];
+ }
+ }
+ }
+
+ i++;
+ }
+ } else {
+ for (int i = 0; i < pixels.length; ){
+ for (int bandIdx = 0; bandIdx < numBands-1; bandIdx++, i++){
+ pixels[i] = pixels[i] * scaleFactors[0] + offsets[0];
+ // Check for overflow now
+ if (((int)pixels[i] & masks[bandIdx]) != 0) {
+ if (pixels[i] < 0) {
+ pixels[i] = 0;
+ } else {
+ pixels[i] = maxValues[bandIdx];
+ }
+ }
+ }
+
+ i++;
+ }
+ }
+ } else {
+ if (scaleFactors.length > 1) {
+ for (int i = 0; i < pixels.length; ){
+ for (int bandIdx = 0; bandIdx < numBands; bandIdx++, i++){
+ pixels[i] = pixels[i] * scaleFactors[bandIdx] + offsets[bandIdx];
+ // Check for overflow now
+ if (((int)pixels[i] & masks[bandIdx]) != 0) {
+ if (pixels[i] < 0) {
+ pixels[i] = 0;
+ } else {
+ pixels[i] = maxValues[bandIdx];
+ }
+ }
+ }
+ }
+ } else {
+ for (int i = 0; i < pixels.length; ){
+ for (int bandIdx = 0; bandIdx < numBands; bandIdx++, i++){
+ pixels[i] = pixels[i] * scaleFactors[0] + offsets[0];
+ // Check for overflow now
+ if (((int)pixels[i] & masks[bandIdx]) != 0) {
+ if (pixels[i] < 0) {
+ pixels[i] = 0;
+ } else {
+ pixels[i] = maxValues[bandIdx];
+ }
+ }
+ }
+ }
+ }
+ }
+
+ dst.setPixels(dstMinX, dstMinY, srcWidth, srcHeight, pixels);
+
+ return 0;
+ }
+
+ public final BufferedImage filter(BufferedImage src, BufferedImage dst) {
+ ColorModel srcCM = src.getColorModel();
+
+ if (srcCM instanceof IndexColorModel) {
+ // awt.220=Source should not have IndexColorModel
+ throw new IllegalArgumentException(Messages.getString("awt.220")); //$NON-NLS-1$
+ }
+
+ // Check if the number of scaling factors matches the number of bands
+ int nComponents = srcCM.getNumComponents();
+ boolean skipAlpha;
+ if (srcCM.hasAlpha()) {
+ if (scaleFactors.length == 1 || scaleFactors.length == nComponents-1) {
+ skipAlpha = true;
+ } else if (scaleFactors.length == nComponents) {
+ skipAlpha = false;
+ } else {
+ // awt.21E=Number of scaling constants is not equal to the number of bands
+ throw new IllegalArgumentException(Messages.getString("awt.21E")); //$NON-NLS-1$
+ }
+ } else if (scaleFactors.length == 1 || scaleFactors.length == nComponents) {
+ skipAlpha = false;
+ } else {
+ // awt.21E=Number of scaling constants is not equal to the number of bands
+ throw new IllegalArgumentException(Messages.getString("awt.21E")); //$NON-NLS-1$
+ }
+
+ BufferedImage finalDst = null;
+ if (dst == null) {
+ finalDst = dst;
+ dst = createCompatibleDestImage(src, srcCM);
+ } else if (!srcCM.equals(dst.getColorModel())) {
+ // Treat BufferedImage.TYPE_INT_RGB and BufferedImage.TYPE_INT_ARGB as same
+ if (
+ !((src.getType() == BufferedImage.TYPE_INT_RGB ||
+ src.getType() == BufferedImage.TYPE_INT_ARGB) &&
+ (dst.getType() == BufferedImage.TYPE_INT_RGB ||
+ dst.getType() == BufferedImage.TYPE_INT_ARGB))
+ ) {
+ finalDst = dst;
+ dst = createCompatibleDestImage(src, srcCM);
+ }
+ }
+
+ // TODO
+ //if (ippFilter(src.getRaster(), dst.getRaster(), src.getType(), skipAlpha) != 0)
+ if (slowFilter(src.getRaster(), dst.getRaster(), skipAlpha) != 0) {
+ // awt.21F=Unable to transform source
+ throw new ImagingOpException (Messages.getString("awt.21F")); //$NON-NLS-1$
+ }
+
+ if (finalDst != null) {
+ Graphics2D g = finalDst.createGraphics();
+ g.setComposite(AlphaComposite.Src);
+ g.drawImage(dst, 0, 0, null);
+ } else {
+ finalDst = dst;
+ }
+
+ return finalDst;
+ }
+
+ // Don't forget to pass allocated arrays for levels and values, size should be numBands*4
+ /**
+ * Creates the levels.
+ *
+ * @param sm the sm
+ * @param numBands the num bands
+ * @param skipAlpha the skip alpha
+ * @param levels the levels
+ * @param values the values
+ * @param channelsOrder the channels order
+ */
+ private final void createLevels(
+ SampleModel sm, int numBands, boolean skipAlpha,
+ int levels[], int values[], int channelsOrder[]
+ ) {
+ // Suppose same sample size for all channels, otherwise use slow filter
+ int maxValue = (1 << sm.getSampleSize(0)) - 1;
+
+ // For simplicity introduce these arrays
+ float extScaleFactors[] = new float[numBands];
+ float extOffsets[] = new float[numBands];
+
+ if (scaleFactors.length != 1) {
+ System.arraycopy(scaleFactors, 0, extScaleFactors, 0, scaleFactors.length);
+ System.arraycopy(offsets, 0, extOffsets, 0, scaleFactors.length);
+ } else {
+ for (int i = 0; i < numBands; i++) {
+ extScaleFactors[i] = scaleFactors[0];
+ extOffsets[i] = offsets[0];
+ }
+ }
+
+ if (skipAlpha) {
+ extScaleFactors[numBands-1] = 1;
+ extOffsets[numBands-1] = 0;
+ }
+
+ // Create a levels
+ for (int i=0; i<numBands; i++) {
+ if (extScaleFactors[i] == 0) {
+ levels[i*4] = 0;
+ levels[i*4+1] = 0;
+ levels[i*4+2] = maxValue+1;
+ levels[i*4+3] = maxValue+1;
+ }
+
+ float minLevel = -extOffsets[i] / extScaleFactors[i];
+ float maxLevel = (maxValue - extOffsets[i]) / extScaleFactors[i];
+
+ if (minLevel < 0) {
+ minLevel = 0;
+ } else if (minLevel > maxValue){
+ minLevel = maxValue;
+ }
+
+ if (maxLevel < 0) {
+ maxLevel = 0;
+ } else if (maxLevel > maxValue){
+ maxLevel = maxValue;
+ }
+
+ levels[i*4] = 0;
+ if (minLevel > maxLevel) {
+ levels[i*4+1] = (int) maxLevel;
+ levels[i*4+2] = (int) minLevel;
+ } else {
+ levels[i*4+1] = (int) minLevel;
+ levels[i*4+2] = (int) maxLevel;
+ }
+ levels[i*4+3] = maxValue+1;
+
+ // Fill values
+ for (int k=0; k<4; k++) {
+ int idx = i*4+k;
+ values[idx] = (int) (extScaleFactors[i] * levels[idx] + extOffsets[i]);
+ if (values[idx] < 0) {
+ values[idx] = 0;
+ } else if (values[idx] > maxValue){
+ values[idx] = maxValue;
+ }
+ }
+ }
+
+ // Reorder data if channels are stored in different order
+ if (channelsOrder != null) {
+ int len = numBands*4;
+ int savedLevels[] = new int[len];
+ int savedValues[] = new int[len];
+ System.arraycopy(levels, 0, savedLevels, 0, len);
+ System.arraycopy(values, 0, savedValues, 0, len);
+ for (int i = 0; i < channelsOrder.length; i++) {
+ System.arraycopy(savedLevels, i*4, levels, channelsOrder[i]*4, 4);
+ System.arraycopy(savedValues, i*4, values, channelsOrder[i]*4, 4);
+ }
+ }
+ }
+
+ // TODO remove when this method is used
+ /**
+ * Ipp filter.
+ *
+ * @param src the src
+ * @param dst the dst
+ * @param imageType the image type
+ * @param skipAlpha the skip alpha
+ *
+ * @return the int
+ */
+ @SuppressWarnings("unused")
+ private final int ippFilter(
+ Raster src, WritableRaster dst,
+ int imageType, boolean skipAlpha
+ ) {
+ int res;
+
+ int srcStride, dstStride;
+ int channels;
+ int offsets[] = null;
+ int channelsOrder[] = null;
+
+ switch (imageType) {
+ case BufferedImage.TYPE_INT_ARGB:
+ case BufferedImage.TYPE_INT_ARGB_PRE:
+ case BufferedImage.TYPE_INT_RGB: {
+ channels = 4;
+ srcStride = src.getWidth()*4;
+ dstStride = dst.getWidth()*4;
+ channelsOrder = new int[] {2, 1, 0, 3};
+ break;
+ }
+
+ case BufferedImage.TYPE_4BYTE_ABGR:
+ case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+ case BufferedImage.TYPE_INT_BGR: {
+ channels = 4;
+ srcStride = src.getWidth()*4;
+ dstStride = dst.getWidth()*4;
+ break;
+ }
+
+ case BufferedImage.TYPE_BYTE_GRAY: {
+ channels = 1;
+ srcStride = src.getWidth();
+ dstStride = dst.getWidth();
+ break;
+ }
+
+ case BufferedImage.TYPE_3BYTE_BGR: {
+ channels = 3;
+ srcStride = src.getWidth()*3;
+ dstStride = dst.getWidth()*3;
+ channelsOrder = new int[] {2, 1, 0};
+ break;
+ }
+
+ case BufferedImage.TYPE_USHORT_GRAY:
+ case BufferedImage.TYPE_USHORT_565_RGB:
+ case BufferedImage.TYPE_USHORT_555_RGB:
+ case BufferedImage.TYPE_BYTE_BINARY: {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ default: {
+ SampleModel srcSM = src.getSampleModel();
+ SampleModel dstSM = dst.getSampleModel();
+
+ if (
+ srcSM instanceof PixelInterleavedSampleModel &&
+ dstSM instanceof PixelInterleavedSampleModel
+ ) {
+ // Check PixelInterleavedSampleModel
+ if (
+ srcSM.getDataType() != DataBuffer.TYPE_BYTE ||
+ dstSM.getDataType() != DataBuffer.TYPE_BYTE
+ ) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ channels = srcSM.getNumBands(); // Have IPP functions for 1, 3 and 4 channels
+ if (!(channels == 1 || channels == 3 || channels == 4)) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ srcStride = ((ComponentSampleModel) srcSM).getScanlineStride();
+ dstStride = ((ComponentSampleModel) dstSM).getScanlineStride();
+
+ channelsOrder = ((ComponentSampleModel) srcSM).getBandOffsets();
+ } else if (
+ srcSM instanceof SinglePixelPackedSampleModel &&
+ dstSM instanceof SinglePixelPackedSampleModel
+ ) {
+ // Check SinglePixelPackedSampleModel
+ SinglePixelPackedSampleModel sppsm1 = (SinglePixelPackedSampleModel) srcSM;
+ SinglePixelPackedSampleModel sppsm2 = (SinglePixelPackedSampleModel) dstSM;
+
+ channels = sppsm1.getNumBands();
+
+ // TYPE_INT_RGB, TYPE_INT_ARGB...
+ if (
+ sppsm1.getDataType() != DataBuffer.TYPE_INT ||
+ sppsm2.getDataType() != DataBuffer.TYPE_INT ||
+ !(channels == 3 || channels == 4)
+ ) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ // Check compatibility of sample models
+ if (
+ !Arrays.equals(sppsm1.getBitOffsets(), sppsm2.getBitOffsets()) ||
+ !Arrays.equals(sppsm1.getBitMasks(), sppsm2.getBitMasks())
+ ) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ for (int i=0; i<channels; i++) {
+ if (sppsm1.getSampleSize(i) != 8) {
+ return slowFilter(src, dst, skipAlpha);
+ }
+ }
+
+ channelsOrder = new int[channels];
+ int bitOffsets[] = sppsm1.getBitOffsets();
+ for (int i=0; i<channels; i++) {
+ channelsOrder[i] = bitOffsets[i] / 8;
+ }
+
+ if (channels == 3) { // Don't skip channel now, could be optimized
+ channels = 4;
+ }
+
+ srcStride = sppsm1.getScanlineStride() * 4;
+ dstStride = sppsm2.getScanlineStride() * 4;
+ } else {
+ return slowFilter(src, dst, skipAlpha);
+ }
+
+ // Fill offsets if there's a child raster
+ if (src.getParent() != null || dst.getParent() != null) {
+ if (
+ src.getSampleModelTranslateX() != 0 ||
+ src.getSampleModelTranslateY() != 0 ||
+ dst.getSampleModelTranslateX() != 0 ||
+ dst.getSampleModelTranslateY() != 0
+ ) {
+ offsets = new int[4];
+ offsets[0] = -src.getSampleModelTranslateX() + src.getMinX();
+ offsets[1] = -src.getSampleModelTranslateY() + src.getMinY();
+ offsets[2] = -dst.getSampleModelTranslateX() + dst.getMinX();
+ offsets[3] = -dst.getSampleModelTranslateY() + dst.getMinY();
+ }
+ }
+ }
+ }
+
+ int levels[] = new int[4*channels];
+ int values[] = new int[4*channels];
+
+ createLevels(src.getSampleModel(), channels, skipAlpha, levels, values, channelsOrder);
+
+ Object srcData, dstData;
+ AwtImageBackdoorAccessor dbAccess = AwtImageBackdoorAccessor.getInstance();
+ try {
+ srcData = dbAccess.getData(src.getDataBuffer());
+ dstData = dbAccess.getData(dst.getDataBuffer());
+ } catch (IllegalArgumentException e) {
+ return -1; // Unknown data buffer type
+ }
+
+ res = LookupOp.ippLUT(
+ srcData, src.getWidth(), src.getHeight(), srcStride,
+ dstData, dst.getWidth(), dst.getHeight(), dstStride,
+ levels, values,
+ channels, offsets,
+ true
+ );
+
+ return res;
+ }
+}
diff --git a/awt/java/awt/image/SampleModel.java b/awt/java/awt/image/SampleModel.java
new file mode 100644
index 0000000..44059a0
--- /dev/null
+++ b/awt/java/awt/image/SampleModel.java
@@ -0,0 +1,1053 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The SampleModel class is abstract class for retrieving pixel's samples
+ * in the data of an image. Each pixel contains several samples. A
+ * sample is the set of values of the bands for single pixel.
+ * For example, each pixel in the RGB model contains three samples
+ * and there are three corresponding bands in the image
+ * data of such pixels representing red, green and blue components.
+ * <p>
+ * The image data is represented as a Raster with a DataBuffer
+ * and a SampleModel. The SampleModel allows access to the samples in the
+ * DataBuffer.
+ */
+public abstract class SampleModel {
+
+ /** The width of the image data which this SampleModel describes. */
+ protected int width;
+
+ /** The height of the image data which this SampleModel describes. */
+ protected int height;
+
+ /** The number of bands of image data which this SampleModel describes. */
+ protected int numBands;
+
+ /** The data type of the image data which this SampleModel describes. */
+ protected int dataType;
+
+ /**
+ * Instantiates a new SampleModel with the specified data type,
+ * width, height and number of bands.
+ *
+ * @param dataType the data type of the image data.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param numBands the number of bands of the image data.
+ */
+ public SampleModel(int dataType, int w, int h, int numBands) {
+ if (w <= 0 || h <= 0) {
+ // awt.22E=w or h is less than or equal to zero
+ throw new IllegalArgumentException(Messages.getString("awt.22E")); //$NON-NLS-1$
+ }
+
+ double squre = ((double) w) * ((double) h);
+ if (squre >= Integer.MAX_VALUE) {
+ // awt.22F=The product of w and h is greater than Integer.MAX_VALUE
+ throw new IllegalArgumentException(Messages.getString("awt.22F")); //$NON-NLS-1$
+ }
+
+ if (dataType < DataBuffer.TYPE_BYTE ||
+ dataType > DataBuffer.TYPE_DOUBLE &&
+ dataType != DataBuffer.TYPE_UNDEFINED) {
+ // awt.230=dataType is not one of the supported data types
+ throw new IllegalArgumentException(Messages.getString("awt.230")); //$NON-NLS-1$
+ }
+
+ if (numBands < 1) {
+ // awt.231=Number of bands must be more then 0
+ throw new IllegalArgumentException(Messages.getString("awt.231")); //$NON-NLS-1$
+ }
+
+ this.dataType = dataType;
+ this.width = w;
+ this.height = h;
+ this.numBands = numBands;
+
+ }
+
+ /**
+ * Gets the data array for the specified pixel of the specified
+ * DataBuffer with one of the following types:
+ * DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
+ * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT,
+ * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param obj the Object is a data where the result will be stored.
+ * @param data the image data.
+ *
+ * @return the data array for the specified pixel of the specified
+ * DataBuffer.
+ */
+ public abstract Object getDataElements(int x, int y, Object obj,
+ DataBuffer data);
+
+ /**
+ * Gets the array of pixel data for the specified rectangular
+ * area of pixels of the specified DataBuffer with one of
+ * the following types:
+ * DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
+ * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT,
+ * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE.
+ *
+ *
+ * @param x the X coordinate of the rectangular pixel area.
+ * @param y the Y coordinate of the rectangular pixel area.
+ * @param w the width of the rectangular pixel area.
+ * @param h the height of the rectangular pixel area.
+ * @param obj the Object is an array with the primitive type,
+ * where the result array will be stored.
+ * @param data the image data.
+ *
+ * @return the array of pixel data for the specified rectangular
+ * area of pixels of the specified DataBuffer object.
+ */
+ public Object getDataElements(int x, int y, int w, int h, Object obj,
+ DataBuffer data) {
+ int numDataElements = getNumDataElements();
+ int idx = 0;
+
+ switch (getTransferType()) {
+ case DataBuffer.TYPE_BYTE:
+ byte bdata[];
+ byte bbuf[] = null;
+
+ if (obj == null) {
+ bdata = new byte[numDataElements * w * h];
+ } else {
+ bdata = (byte[]) obj;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ bbuf = (byte[]) getDataElements(j, i, bbuf, data);
+ for (int n = 0; n < numDataElements; n++) {
+ bdata[idx++] = bbuf[n];
+ }
+ }
+ }
+ obj = bdata;
+ break;
+
+ case DataBuffer.TYPE_SHORT:
+ case DataBuffer.TYPE_USHORT:
+ short sdata[];
+ short sbuf[] = null;
+
+ if (obj == null) {
+ sdata = new short[numDataElements * w * h];
+ } else {
+ sdata = (short[]) obj;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ sbuf = (short[]) getDataElements(j, i, sbuf, data);
+ for (int n = 0; n < numDataElements; n++) {
+ sdata[idx++] = sbuf[n];
+ }
+ }
+ }
+ obj = sdata;
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int idata[];
+ int ibuf[] = null;
+
+ if (obj == null) {
+ idata = new int[numDataElements * w * h];
+ } else {
+ idata = (int[]) obj;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ ibuf = (int[]) getDataElements(j, i, ibuf, data);
+ for (int n = 0; n < numDataElements; n++) {
+ idata[idx++] = ibuf[n];
+ }
+ }
+ }
+ obj = idata;
+ break;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fdata[];
+ float fbuf[] = null;
+
+ if (obj == null) {
+ fdata = new float[numDataElements * w * h];
+ } else {
+ fdata = (float[]) obj;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ fbuf = (float[]) getDataElements(j, i, fbuf, data);
+ for (int n = 0; n < numDataElements; n++) {
+ fdata[idx++] = fbuf[n];
+ }
+ }
+ }
+ obj = fdata;
+ break;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double ddata[];
+ double dbuf[] = null;
+
+ if (obj == null) {
+ ddata = new double[numDataElements * w * h];
+ } else {
+ ddata = (double[]) obj;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ dbuf = (double[]) getDataElements(j, i, dbuf, data);
+ for (int n = 0; n < numDataElements; n++) {
+ ddata[idx++] = dbuf[n];
+ }
+ }
+ }
+ obj = ddata;
+ break;
+
+ }
+
+ return obj;
+ }
+
+ /**
+ * Sets the data for a single pixel in the specified DataBuffer
+ * from a primitive array with one of the following types:
+ * DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
+ * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT,
+ * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param obj the Object - the array of primitive pixel data
+ * to be set.
+ * @param data the image data.
+ */
+ public abstract void setDataElements(int x, int y, Object obj,
+ DataBuffer data);
+
+ /**
+ * Sets the data elements for a rectangular area of pixels in
+ * the specified DataBuffer from a primitive array with one of
+ * the following types: DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
+ * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT,
+ * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE.
+ *
+ * @param x the X coordinate of the specified rectangular area.
+ * @param y the Y coordinate of the specified rectangular area.
+ * @param w the width of rectangle.
+ * @param h the height of rectangle.
+ * @param obj the Object - the array of primitive pixel data
+ * to be set.
+ * @param data the image data.
+ */
+ public void setDataElements(int x, int y, int w, int h, Object obj,
+ DataBuffer data) {
+ int numDataElements = getNumDataElements();
+ int idx = 0;
+
+ switch (getTransferType()) {
+ case DataBuffer.TYPE_BYTE:
+ byte bbuf[] = new byte[numDataElements];
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numDataElements; n++) {
+ bbuf[n] = ((byte[]) obj)[idx++];
+ }
+ setDataElements(j, i, bbuf, data);
+ }
+ }
+
+ break;
+
+ case DataBuffer.TYPE_SHORT:
+ case DataBuffer.TYPE_USHORT:
+ short sbuf[] = new short[numDataElements];
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numDataElements; n++) {
+ sbuf[n] = ((short[]) obj)[idx++];
+ }
+ setDataElements(j, i, sbuf, data);
+ }
+ }
+ break;
+
+ case DataBuffer.TYPE_INT:
+ int ibuf[] = new int[numDataElements];
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numDataElements; n++) {
+ ibuf[n] = ((int[]) obj)[idx++];
+ }
+ setDataElements(j, i, ibuf, data);
+ }
+ }
+ break;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fbuf[] = new float[numDataElements];
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numDataElements; n++) {
+ fbuf[n] = ((float[]) obj)[idx++];
+ }
+ setDataElements(j, i, fbuf, data);
+ }
+ }
+ break;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double dbuf[] = new double[numDataElements];
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numDataElements; n++) {
+ dbuf[n] = ((double[]) obj)[idx++];
+ }
+ setDataElements(j, i, dbuf, data);
+ }
+ }
+ break;
+
+ }
+ }
+
+ /**
+ * Creates a new SampleModel with the specified bands of
+ * this SampleModel.
+ *
+ * @param bands the array of bands from this SampleModel.
+ *
+ * @return the SampleModel with the specified bands of
+ * this SampleModel.
+ */
+ public abstract SampleModel createSubsetSampleModel(int bands[]);
+
+ /**
+ * Creates the SampleModel which has the same data as in
+ * this SampleModel with a different width and height.
+ *
+ * @param a0 the width of the image data.
+ * @param a1 the height of the image data.
+ *
+ * @return the SampleModel which has the same data as in
+ * this SampleModel with a different width and height.
+ */
+ public abstract SampleModel createCompatibleSampleModel(int a0, int a1);
+
+ /**
+ * Gets the samples of the specified pixel as a int array.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param iArray the int array where result will be stored.
+ * @param data the image data.
+ *
+ * @return the int array with the samples of the specified pixel.
+
+ */
+ public int[] getPixel(int x, int y, int iArray[], DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int pixel[];
+
+ if (iArray == null) {
+ pixel = new int[numBands];
+ } else {
+ pixel = iArray;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ pixel[i] = getSample(x, y, i, data);
+ }
+
+ return pixel;
+ }
+
+ /**
+ * Sets a pixel of the DataBuffer from a int array of samples.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param iArray the int array.
+ * @param data the image data.
+ */
+ public void setPixel(int x, int y, int iArray[], DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, iArray[i], data);
+ }
+ }
+
+ /**
+ * Gets the samples of the specified pixel as a float array.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param fArray the float array where result will be stored.
+ * @param data the image data.
+ *
+ * @return the float array with the samples of the specified pixel.
+ */
+ public float[] getPixel(int x, int y, float fArray[], DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ float pixel[];
+
+ if (fArray == null) {
+ pixel = new float[numBands];
+ } else {
+ pixel = fArray;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ pixel[i] = getSampleFloat(x, y, i, data);
+ }
+
+ return pixel;
+ }
+
+ /**
+ * Sets a pixel of the DataBuffer from a float array of samples.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param fArray the float array.
+ * @param data the image data.
+ */
+ public void setPixel(int x, int y, float fArray[], DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, fArray[i], data);
+ }
+ }
+
+ /**
+ * Gets the samples of the specified pixel as a double array.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param dArray the double array where result will be stored.
+ * @param data the image data.
+ *
+ * @return the double array with the samples of the specified pixel.
+ */
+ public double[] getPixel(int x, int y, double dArray[], DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ double pixel[];
+
+ if (dArray == null) {
+ pixel = new double[numBands];
+ } else {
+ pixel = dArray;
+ }
+
+ for (int i = 0; i < numBands; i++) {
+ pixel[i] = getSampleDouble(x, y, i, data);
+ }
+
+ return pixel;
+ }
+
+ /**
+ * Sets a pixel of the DataBuffer from a double array of samples.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param dArray the double array.
+ * @param data the image data.
+ */
+ public void setPixel(int x, int y, double dArray[], DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ for (int i = 0; i < numBands; i++) {
+ setSample(x, y, i, dArray[i], data);
+ }
+ }
+
+ /**
+ * Gets the sample of a specified band for the specified pixel
+ * as an int.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param b the specified band.
+ * @param data the image data.
+ *
+ * @return the sample of a specified band for the specified pixel.
+ */
+ public abstract int getSample(int x, int y, int b, DataBuffer data);
+
+ /**
+ * Gets the sample of a specified band for the specified pixel
+ * as a float.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param b the specified band.
+ * @param data the image data.
+ *
+ * @return the sample of a specified band for the specified pixel.
+
+ */
+ public float getSampleFloat(int x, int y, int b, DataBuffer data) {
+ return getSample(x, y, b, data);
+ }
+
+ /**
+ * Gets the sample of a specified band for the specified pixel
+ * as a double.
+ *
+ * @param x the X coordinate of pixel.
+ * @param y the Y coordinate of pixel.
+ * @param b the specified band.
+ * @param data the image data.
+ *
+ * @return the sample of a specified band for the specified pixel.
+ */
+ public double getSampleDouble(int x, int y, int b, DataBuffer data) {
+ return getSample(x, y, b, data);
+ }
+
+ /**
+ * Gets the samples of the specified rectangular area of pixels
+ * as a int array.
+ *
+ * @param x the X coordinate of the rectangle of pixels.
+ * @param y the Y coordinate of the rectangle of pixels.
+ * @param w the width of the rectangle of pixels.
+ * @param h the height of the rectangle of pixels.
+ * @param iArray the int array where result will be stored.
+ * @param data the image data.
+ *
+ * @return the int array with the samples of the specified
+ * rectangular area of pixels.
+ */
+ public int[] getPixels(int x, int y, int w, int h, int iArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int pixels[];
+ int idx = 0;
+
+ if (iArray == null) {
+ pixels = new int[w * h * numBands];
+ } else {
+ pixels = iArray;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numBands; n++) {
+ pixels[idx++] = getSample(j, i, n, data);
+ }
+ }
+ }
+ return pixels;
+ }
+
+ /**
+ * Sets all of the samples for a rectangular area of pixels of the DataBuffer
+ * from an int array.
+ *
+ * @param x the X coordinate of the rectangle of pixels.
+ * @param y the Y coordinate of the rectangle of pixels.
+ * @param w the width of the rectangle of pixels.
+ * @param h the height of the rectangle of pixels.
+ * @param iArray the int array.
+ * @param data the image data.
+ */
+ public void setPixels(int x, int y, int w, int h, int iArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int idx = 0;
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numBands; n++) {
+ setSample(j, i, n, iArray[idx++], data);
+ }
+ }
+ }
+ }
+
+ /**
+ * Gets the samples of the specified rectangular area of pixels
+ * as a float array.
+ *
+ * @param x the X coordinate of the rectangle of pixels.
+ * @param y the Y coordinate of the rectangle of pixels.
+ * @param w the width of the rectangle of pixels.
+ * @param h the height of the rectangle of pixels.
+ * @param fArray the float array where result will be stored.
+ * @param data the image data.
+ *
+ * @return the float array with the samples of the specified
+ * rectangular area of pixels.
+ */
+ public float[] getPixels(int x, int y, int w, int h, float fArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ float pixels[];
+ int idx = 0;
+
+ if (fArray == null) {
+ pixels = new float[w * h * numBands];
+ } else {
+ pixels = fArray;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numBands; n++) {
+ pixels[idx++] = getSampleFloat(j, i, n, data);
+ }
+ }
+ }
+ return pixels;
+ }
+
+ /**
+ * Sets all of the samples for a rectangular area of pixels of the DataBuffer
+ * from a float array.
+ *
+ * @param x the X coordinate of the rectangle of pixels.
+ * @param y the Y coordinate of the rectangle of pixels.
+ * @param w the width of the rectangle of pixels.
+ * @param h the height of the rectangle of pixels.
+ * @param fArray the float array.
+ * @param data the image data.
+ */
+ public void setPixels(int x, int y, int w, int h, float fArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int idx = 0;
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numBands; n++) {
+ setSample(j, i, n, fArray[idx++], data);
+ }
+ }
+ }
+ }
+
+ /**
+ * Gets the samples of the specified rectangular area of pixels
+ * as a double array.
+ *
+ * @param x the X coordinate of the rectangle of pixels.
+ * @param y the Y coordinate of the rectangle of pixels.
+ * @param w the width of the rectangle of pixels.
+ * @param h the height of the rectangle of pixels.
+ * @param dArray the double array where result will be stored.
+ * @param data the image data.
+ *
+ * @return the double array with the samples of the specified
+ * rectangular area of pixels.
+ */
+ public double[] getPixels(int x, int y, int w, int h, double dArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ double pixels[];
+ int idx = 0;
+
+ if (dArray == null) {
+ pixels = new double[w * h * numBands];
+ } else {
+ pixels = dArray;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numBands; n++) {
+ pixels[idx++] = getSampleDouble(j, i, n, data);
+ }
+ }
+ }
+ return pixels;
+ }
+
+ /**
+ * Sets all of the samples for a rectangular area of pixels of the DataBuffer
+ * from a double array.
+ *
+ * @param x the X coordinate of the rectangle of pixels.
+ * @param y the Y coordinate of the rectangle of pixels.
+ * @param w the width of the rectangle of pixels.
+ * @param h the height of the rectangle of pixels.
+ * @param dArray the double array.
+ * @param data the image data.
+ */
+ public void setPixels(int x, int y, int w, int h, double dArray[],
+ DataBuffer data) {
+ if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int idx = 0;
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < numBands; n++) {
+ setSample(j, i, n, dArray[idx++], data);
+ }
+ }
+ }
+ }
+
+ /**
+ * Sets a sample of the specified band for the specified pixel
+ * in the DataBuffer as int value.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the specified band.
+ * @param s the sample as an int value.
+ * @param data the image data.
+ */
+ public abstract void setSample(int x, int y, int b, int s, DataBuffer data);
+
+ /**
+ * Gets the samples of a specified band for a specified rectangular
+ * area of pixels as a int array.
+ *
+ * @param x the X coordinate of the rectangle.
+ * @param y the Y coordinate of the rectangle.
+ * @param w the width of the rectangle.
+ * @param h the height of the rectangle.
+ * @param b the specified band.
+ * @param iArray the int array where result will be stored.
+ * @param data the image data.
+ *
+ * @return the samples of a specified band for a specified rectangular
+ * area of pixels.
+ */
+ public int[] getSamples(int x, int y, int w, int h, int b, int iArray[],
+ DataBuffer data) {
+ int samples[];
+ int idx = 0;
+
+ if (iArray == null) {
+ samples = new int[w * h];
+ } else {
+ samples = iArray;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ samples[idx++] = getSample(j, i, b, data);
+ }
+ }
+
+ return samples;
+ }
+
+ /**
+ * Sets the samples from an int array in the specified band for
+ * the specified rectangle of pixels.
+ *
+ * @param x the X coordinate of the rectangle.
+ * @param y the Y coordinate of the rectangle.
+ * @param w the width of the rectangle.
+ * @param h the height of the rectangle.
+ * @param b the specified band.
+ * @param iArray the int array.
+ * @param data the image data.
+ */
+ public void setSamples(int x, int y, int w, int h, int b, int iArray[],
+ DataBuffer data) {
+ int idx = 0;
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ setSample(j, i, b, iArray[idx++], data);
+ }
+ }
+ }
+
+ /**
+ * Gets the samples of a specified band for a specified rectangular
+ * area of pixels as a float array.
+ *
+ * @param x the X coordinate of the rectangle.
+ * @param y the Y coordinate of the rectangle.
+ * @param w the width of the rectangle.
+ * @param h the height of the rectangle.
+ * @param b the specified band.
+ * @param fArray the float array where result will be stored.
+ * @param data the image data.
+ *
+ * @return the samples of a specified band for a specified rectangular
+ * area of pixels.
+ */
+ public float[] getSamples(int x, int y, int w, int h, int b,
+ float fArray[], DataBuffer data) {
+ float samples[];
+ int idx = 0;
+
+ if (fArray == null) {
+ samples = new float[w * h];
+ } else {
+ samples = fArray;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ samples[idx++] = getSampleFloat(j, i, b, data);
+ }
+ }
+
+ return samples;
+ }
+
+ /**
+ * Sets the samples from an float array in the specified band for
+ * the specified rectangle of pixels.
+ *
+ * @param x the X coordinate of the rectangle.
+ * @param y the Y coordinate of the rectangle.
+ * @param w the width of the rectangle.
+ * @param h the height of the rectangle.
+ * @param b the specified band.
+ * @param fArray the float array
+ * @param data the image data.
+ */
+ public void setSamples(int x, int y, int w, int h, int b, float fArray[],
+ DataBuffer data) {
+ int idx = 0;
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ setSample(j, i, b, fArray[idx++], data);
+ }
+ }
+ }
+
+ /**
+ * Gets the samples of a specified band for a specified rectangular
+ * area of pixels as a double array.
+ *
+ * @param x the X coordinate of the rectangle.
+ * @param y the Y coordinate of the rectangle.
+ * @param w the width of the rectangle.
+ * @param h the height of the rectangle.
+ * @param b the specified band.
+ * @param dArray the double array where result will be stored.
+ * @param data the image data.
+ *
+ * @return the samples of a specified band for a specified rectangular
+ * area of pixels.
+ */
+ public double[] getSamples(int x, int y, int w, int h, int b,
+ double dArray[], DataBuffer data) {
+ double samples[];
+ int idx = 0;
+
+ if (dArray == null) {
+ samples = new double[w * h];
+ } else {
+ samples = dArray;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ samples[idx++] = getSampleDouble(j, i, b, data);
+ }
+ }
+
+ return samples;
+ }
+
+ /**
+ * Sets the samples from an double array in the specified band for
+ * the specified rectangle of pixels.
+ *
+ * @param x the X coordinate of the rectangle.
+ * @param y the Y coordinate of the rectangle.
+ * @param w the width of the rectangle.
+ * @param h the height of the rectangle.
+ * @param b the specified band.
+ * @param dArray the double array
+ * @param data the image data.
+ */
+ public void setSamples(int x, int y, int w, int h, int b, double dArray[],
+ DataBuffer data) {
+ int idx = 0;
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ setSample(j, i, b, dArray[idx++], data);
+ }
+ }
+ }
+
+ /**
+ * Sets a sample of the specified band for the specified pixel
+ * in the DataBuffer as float value.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the specified band.
+ * @param s the sample as float value.
+ * @param data the image data.
+ */
+ public void setSample(int x, int y, int b, float s, DataBuffer data) {
+ setSample(x, y, b, (int) s, data);
+ }
+
+ /**
+ * Sets a sample of the specified band for the specified pixel
+ * in the DataBuffer as double value.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the specified band.
+ * @param s the sample as double value.
+ * @param data the image data.
+ */
+ public void setSample(int x, int y, int b, double s, DataBuffer data) {
+ setSample(x, y, b, (int) s, data);
+ }
+
+ /**
+ * Creates a DataBuffer object which corresponds to the SampleModel.
+ *
+ * @return the DataBuffer object which corresponds to
+ * the SampleModel.
+ */
+ public abstract DataBuffer createDataBuffer();
+
+ /**
+ * Gets the sample size in bits for the specified band.
+ *
+ * @param band the specified band.
+ *
+ * @return the sample size in bits for the specified band.
+ */
+ public abstract int getSampleSize(int band);
+
+ /**
+ * Gets an array of the sample size in bits for all bands.
+ *
+ * @return an array of the sample size in bits for all bands.
+ */
+ public abstract int[] getSampleSize();
+
+ /**
+ * Gets the width of the image data of this SampleModel object.
+ *
+ * @return the width of the image data of this SampleModel object.
+ */
+ public final int getWidth() {
+ return width;
+ }
+
+ /**
+ * Gets the transfer type used to transfer pixels via
+ * the getDataElements and setDataElements methods.
+ * Transfer type value can be one of the predefined type
+ * from DataBuffer class or not.
+ *
+ * @return the transfer type.
+ */
+ public int getTransferType() {
+ return dataType;
+ }
+
+ /**
+ * Returns the number of data elements for pixel transfering
+ * via the getDataElements and setDataElements methods.
+ *
+ * @return the number of data elements for pixel transfering
+ * via the getDataElements and setDataElements methods.
+ */
+ public abstract int getNumDataElements();
+
+ /**
+ * Gets the number of bands in the image data of this
+ * SampleModel object.
+ *
+ * @return the number of bands in the image data of this
+ * SampleModel object.
+ */
+ public final int getNumBands() {
+ return numBands;
+ }
+
+ /**
+ * Gets the height of the image data of this SampleModel object.
+ *
+ * @return the height of the image data of this SampleModel object.
+ */
+ public final int getHeight() {
+ return height;
+ }
+
+ /**
+ * Gets the data type of image data of this SampleModel object.
+ *
+ * @return the data type of image data of this SampleModel object.
+ */
+ public final int getDataType() {
+ return dataType;
+ }
+
+}
+
diff --git a/awt/java/awt/image/ShortLookupTable.java b/awt/java/awt/image/ShortLookupTable.java
new file mode 100644
index 0000000..77c9c45
--- /dev/null
+++ b/awt/java/awt/image/ShortLookupTable.java
@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Oleg V. Khaschansky
+ * @version $Revision$
+ *
+ * @date: Oct 14, 2005
+ */
+
+package java.awt.image;
+
+
+/**
+ * The ShortLookupTable class provides provides functionality for
+ * lookup operations, and is defined by an input short array for
+ * bands or components of image and an offset value.
+ * The offset value will be subtracted from the input values before
+ * indexing the input arrays. The output of a lookup operation is
+ * represented as an unsigned short array.
+ */
+public class ShortLookupTable extends LookupTable {
+
+ /** The data. */
+ private short data[][];
+
+ /**
+ * Instantiates a new ShortLookupTable with the specified offset value
+ * and the specified short array which represents lookup table for
+ * all bands.
+ *
+ * @param offset the offset value.
+ * @param data the data array.
+ */
+ public ShortLookupTable(int offset, short[] data) {
+ super(offset, 1);
+ this.data = new short[1][data.length];
+ // The data array stored as a reference
+ this.data[0] = data;
+ }
+
+ /**
+ * Instantiates a new ShortLookupTable with the specified offset value
+ * and the specified short array of arrays which represents lookup table
+ * for each band.
+ *
+ * @param offset the offset value.
+ * @param data the data array of arrays for each band.
+ */
+ public ShortLookupTable(int offset, short[][] data) {
+ super(offset, data.length);
+ this.data = new short[data.length][data[0].length];
+ for (int i = 0; i < data.length; i++) {
+ // The data array for each band stored as a reference
+ this.data[i] = data[i];
+ }
+ }
+
+ /**
+ * Gets the lookup table of this ShortLookupTable object. If
+ * this ShortLookupTable object has one short array for all bands,
+ * the returned array length is one.
+ *
+ * @return the lookup table of this ShortLookupTable object.
+ */
+ public final short[][] getTable() {
+ return data;
+ }
+
+ /**
+ * Returns a short array which contains samples of the specified
+ * pixel which is translated with the lookup table of this
+ * ShortLookupTable object. The resulted array is stored to
+ * the dst array.
+ *
+ * @param src the source array.
+ * @param dst the destination array where the result can be stored.
+ *
+ * @return the short array of translated samples of a pixel.
+ */
+ public short[] lookupPixel(short[] src, short[] dst) {
+ if (dst == null) {
+ dst = new short[src.length];
+ }
+
+ int offset = getOffset();
+ if (getNumComponents() == 1) {
+ for (int i = 0; i < src.length; i++) {
+ dst[i] = data[0][src[i]-offset];
+ }
+ } else {
+ for (int i = 0; i < getNumComponents(); i++) {
+ dst[i] = data[i][src[i]-offset];
+ }
+ }
+
+ return dst;
+ }
+
+ @Override
+ public int[] lookupPixel(int[] src, int[] dst) {
+ if (dst == null) {
+ dst = new int[src.length];
+ }
+
+ int offset = getOffset();
+ if (getNumComponents() == 1) {
+ for (int i = 0; i < src.length; i++) {
+ dst[i] = data[0][src[i]-offset];
+ }
+ } else {
+ for (int i = 0; i < getNumComponents(); i++) {
+ dst[i] = data[i][src[i]-offset];
+ }
+ }
+
+ return dst;
+ }
+}
diff --git a/awt/java/awt/image/SinglePixelPackedSampleModel.java b/awt/java/awt/image/SinglePixelPackedSampleModel.java
new file mode 100644
index 0000000..311395a
--- /dev/null
+++ b/awt/java/awt/image/SinglePixelPackedSampleModel.java
@@ -0,0 +1,508 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.util.Arrays;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The SinglePixelPackedSampleModel class represents pixel data
+ * where several samples combine to create a single pixel and
+ * are stored in a single data array element. This class
+ * supports TYPE_BYTE, TYPE_USHORT, TYPE_INT data types.
+ */
+public class SinglePixelPackedSampleModel extends SampleModel {
+
+ /** The bit masks. */
+ private int bitMasks[];
+
+ /** The bit offsets. */
+ private int bitOffsets[];
+
+ /** The bit sizes. */
+ private int bitSizes[];
+
+ /** The scanline stride. */
+ private int scanlineStride;
+
+ /** The max bit size. */
+ private int maxBitSize;
+
+ /**
+ * Instantiates a new SinglePixelPackedSampleModel with the specified
+ * parameters.
+ *
+ * @param dataType the data type of samples.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param bitMasks the bit masks for all the bands.
+ */
+ public SinglePixelPackedSampleModel(int dataType, int w, int h,
+ int bitMasks[]) {
+ this(dataType, w, h, w, bitMasks);
+ }
+
+ /**
+ * Instantiates a new SinglePixelPackedSampleModel with the specified
+ * parameters.
+ *
+ * @param dataType the data type of the samples.
+ * @param w the width of the image data.
+ * @param h the height of the image data.
+ * @param scanlineStride The scanline stride of the image data.
+ * @param bitMasks the bit masks for all the bands.
+ */
+ public SinglePixelPackedSampleModel(int dataType, int w, int h,
+ int scanlineStride, int bitMasks[]) {
+
+ super(dataType, w, h, bitMasks.length);
+
+ if (dataType != DataBuffer.TYPE_BYTE &&
+ dataType != DataBuffer.TYPE_USHORT &&
+ dataType != DataBuffer.TYPE_INT) {
+ // awt.61=Unsupported data type: {0}
+ throw new IllegalArgumentException(Messages.getString("awt.61", //$NON-NLS-1$
+ dataType));
+ }
+
+ this.scanlineStride = scanlineStride;
+ this.bitMasks = bitMasks.clone();
+ this.bitOffsets = new int[this.numBands];
+ this.bitSizes = new int[this.numBands];
+
+ this.maxBitSize = 0;
+
+ for (int i = 0; i < this.numBands; i++) {
+ int offset = 0;
+ int size = 0;
+ int mask = bitMasks[i];
+
+ if (mask != 0) {
+ while ((mask & 1) == 0) {
+ mask >>>= 1;
+ offset++;
+ }
+
+ while ((mask & 1) == 1) {
+ mask >>>= 1;
+ size++;
+ }
+
+ if (mask != 0) {
+ // awt.62=Wrong mask : {0}
+ throw new IllegalArgumentException(Messages.getString(
+ "awt.62", bitMasks[i])); //$NON-NLS-1$
+ }
+ }
+
+ this.bitOffsets[i] = offset;
+ this.bitSizes[i] = size;
+
+ if (this.maxBitSize < size) {
+ this.maxBitSize = size;
+ }
+
+ }
+
+ }
+
+ @Override
+ public Object getDataElements(int x, int y, Object obj, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ switch (getTransferType()) {
+ case DataBuffer.TYPE_BYTE:
+ byte bdata[];
+ if (obj == null) {
+ bdata = new byte[1];
+ } else {
+ bdata = (byte[]) obj;
+ }
+
+ bdata[0] = (byte) data.getElem(y * scanlineStride + x);
+ obj = bdata;
+ break;
+ case DataBuffer.TYPE_USHORT:
+ short sdata[];
+ if (obj == null) {
+ sdata = new short[1];
+ } else {
+ sdata = (short[]) obj;
+ }
+
+ sdata[0] = (short) data.getElem(y * scanlineStride + x);
+ obj = sdata;
+ break;
+ case DataBuffer.TYPE_INT:
+ int idata[];
+ if (obj == null) {
+ idata = new int[1];
+ } else {
+ idata = (int[]) obj;
+ }
+
+ idata[0] = data.getElem(y * scanlineStride + x);
+ obj = idata;
+ break;
+ }
+ return obj;
+ }
+
+ @Override
+ public void setDataElements(int x, int y, Object obj, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ switch (getTransferType()) {
+ case DataBuffer.TYPE_BYTE:
+ data.setElem(y * scanlineStride + x, ((byte[]) obj)[0] & 0xff);
+ break;
+ case DataBuffer.TYPE_USHORT:
+ data.setElem(y * scanlineStride + x, ((short[]) obj)[0] & 0xffff);
+ break;
+ case DataBuffer.TYPE_INT:
+ data.setElem(y * scanlineStride + x, ((int[]) obj)[0]);
+ break;
+ }
+ }
+
+ /**
+ * Compares this SinglePixelPackedSampleModel object with
+ * the specified object.
+ *
+ * @param o the Object to be compared.
+ *
+ * @return true, if this SinglePixelPackedSampleModel object is
+ * equal to the specified object, false otherwise.
+ */
+ @Override
+ public boolean equals(Object o) {
+ if ((o == null) || !(o instanceof SinglePixelPackedSampleModel)) {
+ return false;
+ }
+
+ SinglePixelPackedSampleModel model = (SinglePixelPackedSampleModel) o;
+ return this.width == model.width &&
+ this.height == model.height &&
+ this.numBands == model.numBands &&
+ this.dataType == model.dataType &&
+ Arrays.equals(this.bitMasks, model.bitMasks) &&
+ Arrays.equals(this.bitOffsets, model.bitOffsets) &&
+ Arrays.equals(this.bitSizes, model.bitSizes) &&
+ this.scanlineStride == model.scanlineStride;
+ }
+
+ @Override
+ public SampleModel createSubsetSampleModel(int bands[]) {
+ if (bands.length > this.numBands) {
+ // awt.64=The number of the bands in the subset is greater than the number of bands in the sample model
+ throw new RasterFormatException(Messages.getString("awt.64")); //$NON-NLS-1$
+ }
+
+ int masks[] = new int[bands.length];
+ for (int i = 0; i < bands.length; i++) {
+ masks[i] = this.bitMasks[bands[i]];
+ }
+ return new SinglePixelPackedSampleModel(this.dataType, this.width,
+ this.height, this.scanlineStride, masks);
+ }
+
+ @Override
+ public SampleModel createCompatibleSampleModel(int w, int h) {
+ return new SinglePixelPackedSampleModel(this.dataType, w, h,
+ this.bitMasks);
+ }
+
+ @Override
+ public int[] getPixel(int x, int y, int iArray[], DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int pixel[];
+ if (iArray == null) {
+ pixel = new int[this.numBands];
+ } else {
+ pixel = iArray;
+ }
+
+ for (int i = 0; i < this.numBands; i++) {
+ pixel[i] = getSample(x, y, i, data);
+ }
+
+ return pixel;
+ }
+
+ @Override
+ public void setPixel(int x, int y, int iArray[], DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ for (int i = 0; i < this.numBands; i++) {
+ setSample(x, y, i, iArray[i], data);
+ }
+ }
+
+ @Override
+ public int getSample(int x, int y, int b, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int sample = data.getElem(y * scanlineStride + x);
+ return ((sample & this.bitMasks[b]) >>> this.bitOffsets[b]);
+ }
+
+ @Override
+ public int[] getPixels(int x, int y, int w, int h, int iArray[],
+ DataBuffer data) {
+ if ((x < 0) || (y < 0) || ((long) x + (long) w > this.width)
+ || ((long) y + (long) h > this.height)) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ int pixels[];
+
+ if (iArray == null) {
+ pixels = new int[w * h * this.numBands];
+ } else {
+ pixels = iArray;
+ }
+
+ int idx = 0;
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < this.numBands; n++) {
+ pixels[idx++] = getSample(j, i, n, data);
+ }
+ }
+ }
+ return pixels;
+ }
+
+ @Override
+ public void setPixels(int x, int y, int w, int h, int iArray[],
+ DataBuffer data) {
+ if ((x < 0) || (y < 0) || ((long) x + (long) w > this.width)
+ || ((long) y + (long) h > this.height)) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages
+ .getString("awt.63")); //$NON-NLS-1$
+ }
+
+ int idx = 0;
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ for (int n = 0; n < this.numBands; n++) {
+ setSample(j, i, n, iArray[idx++], data);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void setSample(int x, int y, int b, int s, DataBuffer data) {
+ if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+ int tmp = data.getElem(y * scanlineStride + x);
+ tmp &= ~this.bitMasks[b];
+ tmp |= (s << this.bitOffsets[b]) & this.bitMasks[b];
+ data.setElem(y * scanlineStride + x, tmp);
+ }
+
+ @Override
+ public int[] getSamples(int x, int y, int w, int h, int b, int iArray[],
+ DataBuffer data) {
+ if ((x < 0) || (y < 0) || ((long) x + (long) w > this.width)
+ || ((long) y + (long) h > this.height)) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages
+ .getString("awt.63")); //$NON-NLS-1$
+ }
+
+ int samples[];
+ int idx = 0;
+
+ if (iArray == null) {
+ samples = new int[w * h];
+ } else {
+ samples = iArray;
+ }
+
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ samples[idx++] = getSample(j, i, b, data);
+ }
+ }
+
+ return samples;
+ }
+
+ @Override
+ public void setSamples(int x, int y, int w, int h, int b, int iArray[],
+ DataBuffer data) {
+ if ((x < 0) || (y < 0) || ((long) x + (long) w > this.width)
+ || ((long) y + (long) h > this.height)) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ int idx = 0;
+ for (int i = y; i < y + h; i++) {
+ for (int j = x; j < x + w; j++) {
+ setSample(x + j, y + i, b, iArray[idx++], data);
+ }
+ }
+ }
+
+ @Override
+ public DataBuffer createDataBuffer() {
+ DataBuffer data = null;
+ int size = (this.height - 1) * scanlineStride + width;
+
+ switch (this.dataType) {
+ case DataBuffer.TYPE_BYTE:
+ data = new DataBufferByte(size);
+ break;
+ case DataBuffer.TYPE_USHORT:
+ data = new DataBufferUShort(size);
+ break;
+ case DataBuffer.TYPE_INT:
+ data = new DataBufferInt(size);
+ break;
+ }
+ return data;
+ }
+
+ /**
+ * Gets the offset of the specified pixel in the data array.
+ *
+ * @param x the X coordinate of the specified pixel.
+ * @param y the Y coordinate of the specified pixel.
+ *
+ * @return the offset of the specified pixel.
+ */
+ public int getOffset(int x, int y) {
+ return (y * scanlineStride + x);
+ }
+
+ @Override
+ public int getSampleSize(int band) {
+ return bitSizes[band];
+ }
+
+ @Override
+ public int[] getSampleSize() {
+ return bitSizes.clone();
+ }
+
+ /**
+ * Gets an array of the bit offsets of the data array elements.
+ *
+ * @return an array of the bit offsets.
+ */
+ public int[] getBitOffsets() {
+ return bitOffsets.clone();
+ }
+
+ /**
+ * Gets an array of the bit masks for all bands.
+ *
+ * @return an array of the bit masks for all bands.
+ */
+ public int[] getBitMasks() {
+ return bitMasks.clone();
+ }
+
+ /**
+ * Returns a hash code of this MultiPixelPackedSampleModel class.
+ *
+ * @return the hash code of this MultiPixelPackedSampleModel class.
+ */
+ @Override
+ public int hashCode() {
+ int hash = 0;
+ int tmp = 0;
+
+ hash = width;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= height;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= numBands;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ hash ^= dataType;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ for (int element : bitMasks) {
+ hash ^= element;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ }
+ for (int element : bitOffsets) {
+ hash ^= element;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ }
+ for (int element : bitSizes) {
+ hash ^= element;
+ tmp = hash >>> 24;
+ hash <<= 8;
+ hash |= tmp;
+ }
+ hash ^= scanlineStride;
+ return hash;
+ }
+
+ /**
+ * Gets the scanline stride.
+ *
+ * @return the scanline stride
+ */
+ public int getScanlineStride() {
+ return this.scanlineStride;
+ }
+
+ @Override
+ public int getNumDataElements() {
+ return 1;
+ }
+
+}
+
diff --git a/awt/java/awt/image/TileObserver.java b/awt/java/awt/image/TileObserver.java
new file mode 100644
index 0000000..39ded02
--- /dev/null
+++ b/awt/java/awt/image/TileObserver.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+
+/**
+ * An asynchronous update interface for receiving notifications
+ * about tile information when tiles of a WritableRenderedImage
+ * become modifiable or unmodifiable.
+ */
+public interface TileObserver {
+
+ /**
+ * This method is called when information about a tile
+ * update is available.
+ *
+ * @param source the source image.
+ * @param tileX the X index of the tile.
+ * @param tileY the Y index of the tile.
+ * @param willBeWritable parameter which indicates whether
+ * the tile will be grabbed for writing or be released.
+ */
+ public void tileUpdate(WritableRenderedImage source, int tileX, int tileY, boolean willBeWritable);
+
+}
+
diff --git a/awt/java/awt/image/VolatileImage.java b/awt/java/awt/image/VolatileImage.java
new file mode 100644
index 0000000..3b0cfb2
--- /dev/null
+++ b/awt/java/awt/image/VolatileImage.java
@@ -0,0 +1,144 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Alexey A. Petrenko
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.GraphicsConfiguration;
+import java.awt.Image;
+import java.awt.ImageCapabilities;
+import java.awt.Transparency;
+
+/**
+ * The VolatileImage abstract class represents an image which can lose
+ * its contents at any point. VolatileImage objects are device specific.
+ * This class provies methods for checking if operation of this image
+ * are compatible for the GraphicsConfiguration.
+ */
+public abstract class VolatileImage extends Image
+ // Volatile image implements Transparency since 1.5
+ implements Transparency {
+
+ /**
+ * The Constant IMAGE_INCOMPATIBLE indicates that this VolatileImage
+ * is not applicable for the GraphicsConfiguration object.
+ */
+ public static final int IMAGE_INCOMPATIBLE = 2;
+
+ /**
+ * The Constant IMAGE_OK indicates that VolatileImage is ready
+ * for using.
+ */
+ public static final int IMAGE_OK = 0;
+
+ /**
+ * The Constant IMAGE_RESTORED indicates that VolatileImage
+ * will be ready to use after restoring.
+ */
+ public static final int IMAGE_RESTORED = 1;
+
+ /**
+ * The transparency value of this image.
+ */
+ protected int transparency = OPAQUE;
+
+ /**
+ * Instantiates a new VolatileImage object.
+ */
+ public VolatileImage() {
+ super();
+ }
+
+ /**
+ * Returns true if rendering data is lost during validating.
+ * This method should be called after rendering operation of image.
+ *
+ * @return true, if contents lost during validating, false otherwise.
+ */
+
+ public abstract boolean contentsLost();
+
+ /**
+ * Creates a Graphics2D used to draw in this VolatileImage.
+ *
+ * @return the Graphics2D object.
+ */
+ public abstract Graphics2D createGraphics();
+
+ /**
+ * Gets the ImageCapabilities of this VolatileImage.
+ *
+ * @return the ImageCapabilities of this VolatileImage.
+ */
+ public abstract ImageCapabilities getCapabilities();
+
+ /**
+ * Gets the height of this VolatileImage.
+ *
+ * @return the height of this VolatileImage.
+ */
+ public abstract int getHeight();
+
+ /**
+ * Gets a BufferedImage representation of current VolatileImage that
+ * won't be affected by any changes to this VolatileImage.
+ *
+ * @return a BufferedImage representation of current VolatileImage.
+ */
+ public abstract BufferedImage getSnapshot();
+
+ /**
+ * Gets the width of this VolatileImage.
+ *
+ * @return the width of this VolatileImage.
+ */
+ public abstract int getWidth();
+
+ /**
+ * Validates the drawing surface of the image if the surface had been
+ * lost and if the spacified GraphicsConfiguration object is
+ * applicable to this image.
+ *
+ * @param gc GraphicsConfiguration object.
+ *
+ * @return one of the image status constants: IMAGE_OK, IMAGE_RESTORED or
+ * IMAGE_INCOMPATIBLE.
+ */
+ public abstract int validate(GraphicsConfiguration gc);
+
+ @Override
+ public void flush() {
+ }
+
+ @Override
+ public Graphics getGraphics() {
+ return createGraphics();
+ }
+
+ @Override
+ public ImageProducer getSource() {
+ return getSnapshot().getSource();
+ }
+
+ public int getTransparency() {
+ return transparency;
+ }
+}
diff --git a/awt/java/awt/image/WritableRaster.java b/awt/java/awt/image/WritableRaster.java
new file mode 100644
index 0000000..0893915
--- /dev/null
+++ b/awt/java/awt/image/WritableRaster.java
@@ -0,0 +1,516 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Point;
+import java.awt.Rectangle;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The WritableRaster class provides functionality for
+ * writing samples and pixel capabilities to the Raster.
+ */
+public class WritableRaster extends Raster {
+
+ /**
+ * Instantiates a new WritableRaster object with the specified
+ * SampleModel, DataBuffer, rectangular region and parent
+ * WritableRaster.
+ *
+ * @param sampleModel the specified SampleModel.
+ * @param dataBuffer the specified DataBuffer.
+ * @param aRegion the rectangular region which defines the new image bounds.
+ * @param sampleModelTranslate this point defines the translation point
+ * from the SampleModel to the new WritableRaster coordinates.
+ * @param parent the parent of this WritableRaster.
+ */
+ protected WritableRaster(SampleModel sampleModel, DataBuffer dataBuffer,
+ Rectangle aRegion, Point sampleModelTranslate,
+ WritableRaster parent) {
+ super(sampleModel, dataBuffer, aRegion, sampleModelTranslate, parent);
+ }
+
+ /**
+ * Instantiates a new WritableRaster object with the specified
+ * SampleModel which defines a layout of this WritableRaster and
+ * DataBuffer objects which defines the image data.
+ *
+ * @param sampleModel the specified SampleModel.
+ * @param dataBuffer the specified DataBuffer.
+ * @param origin the point of origin.
+ */
+ protected WritableRaster(SampleModel sampleModel, DataBuffer dataBuffer,
+ Point origin) {
+ this(sampleModel, dataBuffer, new Rectangle(origin.x, origin.y,
+ sampleModel.width, sampleModel.height), origin, null);
+ }
+
+ /**
+ * Instantiates a new WritableRaster with the specified SampleModel.
+ *
+ * @param sampleModel the specified SampleModel.
+ * @param origin the origin.
+ */
+ protected WritableRaster(SampleModel sampleModel, Point origin) {
+ this(sampleModel, sampleModel.createDataBuffer(), new Rectangle(
+ origin.x, origin.y, sampleModel.width, sampleModel.height),
+ origin, null);
+ }
+
+ /**
+ * Sets the data for a single pixel from an input Object which
+ * represents an array of primitive types: DataBuffer.TYPE_BYTE,
+ * DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT,
+ * DataBuffer.TYPE_FLOAT, or DataBuffer.TYPE_DOUBLE.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param inData the input data.
+ */
+ public void setDataElements(int x, int y, Object inData) {
+ sampleModel.setDataElements(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, inData, dataBuffer);
+ }
+
+ /**
+ * Sets the data elements which represent pixel data to the specified
+ * rectangle area as a primitive array. The following image data types
+ * are supported: DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT,
+ * DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT,
+ * or DataBuffer.TYPE_DOUBLE.
+ *
+ * @param x the X coordinate of the rectangle of pixels.
+ * @param y the Y coordinate of the rectangle of pixels.
+ * @param w the width of the rectangle of pixels.
+ * @param h the height of the rectangle of pixels.
+ * @param inData the array of primitive type data to be set to the
+ * specified area.
+ */
+ public void setDataElements(int x, int y, int w, int h, Object inData) {
+ sampleModel.setDataElements(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, w, h, inData, dataBuffer);
+ }
+
+ /**
+ * Creates the child of this WritableRaster by sharing the specified
+ * rectangular area in this WritableRaster.
+ * The parentX, parentY, width and height parameters specify rectangular
+ * area to be shared.
+ *
+ * @param parentX the X coordinate of the upper left corner of
+ * the shared rectangle with respect to this WritableRaster' coordinates.
+ * @param parentY the Y coordinate of the upper left corner of
+ * the shared rectangle with respect to this WritableRaster' coordinates.
+ * @param w the width of the child area.
+ * @param h the height of the child area.
+ * @param childMinX the X coordinate of child area mapped to the parentX
+ * coordinate.
+ * @param childMinY the Y coordinate of child area mapped to the parentY
+ * coordinate.
+ * @param bandList the array of band indicies.
+ *
+ * @return the child WritableRaster.
+ */
+ public WritableRaster createWritableChild(int parentX, int parentY, int w,
+ int h, int childMinX, int childMinY, int bandList[]) {
+ if (w <= 0 || h <= 0) {
+ // awt.244=Width or Height of child Raster is less than or equal to zero
+ throw new RasterFormatException(Messages.getString("awt.244")); //$NON-NLS-1$
+ }
+
+ if (parentX < this.minX || parentX + w > this.minX + this.width) {
+ // awt.245=parentX disposes outside Raster
+ throw new RasterFormatException(Messages.getString("awt.245")); //$NON-NLS-1$
+ }
+
+ if (parentY < this.minY || parentY + h > this.minY + this.height) {
+ // awt.246=parentY disposes outside Raster
+ throw new RasterFormatException(Messages.getString("awt.246")); //$NON-NLS-1$
+ }
+
+ if ((long) parentX + w > Integer.MAX_VALUE) {
+ // awt.247=parentX + w results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.247")); //$NON-NLS-1$
+ }
+
+ if ((long) parentY + h > Integer.MAX_VALUE) {
+ // awt.248=parentY + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.248")); //$NON-NLS-1$
+ }
+
+ if ((long) childMinX + w > Integer.MAX_VALUE) {
+ // awt.249=childMinX + w results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.249")); //$NON-NLS-1$
+ }
+
+ if ((long) childMinY + h > Integer.MAX_VALUE) {
+ // awt.24A=childMinY + h results in integer overflow
+ throw new RasterFormatException(Messages.getString("awt.24A")); //$NON-NLS-1$
+ }
+
+ SampleModel childModel;
+
+ if (bandList == null) {
+ childModel = sampleModel;
+ } else {
+ childModel = sampleModel.createSubsetSampleModel(bandList);
+ }
+
+ int childTranslateX = childMinX - parentX;
+ int childTranslateY = childMinY - parentY;
+
+ return new WritableRaster(childModel, dataBuffer,
+ new Rectangle(childMinX, childMinY, w, h),
+ new Point(childTranslateX + sampleModelTranslateX,
+ childTranslateY + sampleModelTranslateY),
+ this);
+ }
+
+ /**
+ * Creates the translated child of this WritableRaster.
+ * New WritableRaster object is a reference to the this
+ * WritableRaster and with different location.
+ *
+ * @param childMinX the X coordinate of the new WritableRaster.
+ * @param childMinY the Y coordinate of the new WritableRaster.
+ *
+ * @return the WritableRaster.
+ */
+ public WritableRaster createWritableTranslatedChild(int childMinX,
+ int childMinY) {
+ return createWritableChild(minX, minY, width, height, childMinX,
+ childMinY, null);
+ }
+
+ /**
+ * Gets the parent WritableRaster for this WritableRaster object.
+ *
+ * @return the parent WritableRaster for this WritableRaster object.
+ */
+ public WritableRaster getWritableParent() {
+ return (WritableRaster) parent;
+ }
+
+ /**
+ * Sets pixels from the specified source Raster srcRaster to this
+ * WritableRaster.
+ *
+ * @param srcRaster the source Raster.
+ */
+ public void setRect(Raster srcRaster) {
+ setRect(0, 0, srcRaster);
+ }
+
+ /**
+ * Sets pixels from the specified source Raster srcRaster to this
+ * WritableRaster. Each pixel with (x, y) coordinates from the source
+ * Raster is copied to pixel with (x+dx, y+dy) coordinates in this
+ * WritableRaster. The pixels with (x+dx, y+dy) coordinates which
+ * are out the bounds of this raster are ignored.
+ *
+ * @param dx the distance the pixel's X coordinate in the source
+ * Raster is translated when writtien to this WritableRaster.
+ * @param dy the distance the pixel's Y coordinate in the source
+ * Raster is translated when writtien to this WritableRaster.
+ * @param srcRaster the source Raster.
+ */
+ public void setRect(int dx, int dy, Raster srcRaster) {
+ int w = srcRaster.getWidth();
+ int h = srcRaster.getHeight();
+
+ int srcX = srcRaster.getMinX();
+ int srcY = srcRaster.getMinY();
+
+ int dstX = srcX + dx;
+ int dstY = srcY + dy;
+
+ if (dstX < this.minX) {
+ int minOffX = this.minX - dstX;
+ w -= minOffX;
+ dstX = this.minX;
+ srcX += minOffX;
+ }
+
+ if (dstY < this.minY) {
+ int minOffY = this.minY - dstY;
+ h -= minOffY;
+ dstY = this.minY;
+ srcY += minOffY;
+ }
+
+ if (dstX + w > this.minX + this.width) {
+ int maxOffX = (dstX + w) - (this.minX + this.width);
+ w -= maxOffX;
+ }
+
+ if (dstY + h > this.minY + this.height) {
+ int maxOffY = (dstY + h) - (this.minY + this.height);
+ h -= maxOffY;
+ }
+
+ if (w <= 0 || h <= 0) {
+ return;
+ }
+
+ switch (sampleModel.getDataType()) {
+ case DataBuffer.TYPE_BYTE:
+ case DataBuffer.TYPE_SHORT:
+ case DataBuffer.TYPE_USHORT:
+ case DataBuffer.TYPE_INT:
+ int iPixelsLine[] = null;
+ for (int i = 0; i < h; i++) {
+ iPixelsLine = srcRaster.getPixels(srcX, srcY + i, w, 1,
+ iPixelsLine);
+ setPixels(dstX, dstY + i, w, 1, iPixelsLine);
+ }
+ break;
+
+ case DataBuffer.TYPE_FLOAT:
+ float fPixelsLine[] = null;
+ for (int i = 0; i < h; i++) {
+ fPixelsLine = srcRaster.getPixels(srcX, srcY + i, w, 1,
+ fPixelsLine);
+ setPixels(dstX, dstY + i, w, 1, fPixelsLine);
+ }
+ break;
+
+ case DataBuffer.TYPE_DOUBLE:
+ double dPixelsLine[] = null;
+ for (int i = 0; i < h; i++) {
+ dPixelsLine = srcRaster.getPixels(srcX, srcY + i, w, 1,
+ dPixelsLine);
+ setPixels(dstX, dstY + i, w, 1, dPixelsLine);
+ }
+ break;
+ }
+ }
+
+ /**
+ * Sets the data for a rectangle of pixels from an input Raster to
+ * this WritableRaster.
+ *
+ * @param x the X coordinate of the point where the data of
+ * the input Raster is to be written.
+ * @param y the Y coordinate of the point where the data of
+ * the input Raster is to be written.
+ * @param inRaster the input Raster.
+ */
+ public void setDataElements(int x, int y, Raster inRaster) {
+ int dstX = x + inRaster.getMinX();
+ int dstY = y + inRaster.getMinY();
+
+ int w = inRaster.getWidth();
+ int h = inRaster.getHeight();
+
+ if (dstX < this.minX || dstX + w > this.minX + this.width ||
+ dstY < this.minY || dstY + h > this.minY + this.height) {
+ // awt.63=Coordinates are not in bounds
+ throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
+ }
+
+ int srcX = inRaster.getMinX();
+ int srcY = inRaster.getMinY();
+ Object line = null;
+
+ for (int i = 0; i < h; i++) {
+ line = inRaster.getDataElements(srcX, srcY + i, w, 1, line);
+ setDataElements(dstX, dstY + i, w, 1, line);
+ }
+ }
+
+ /**
+ * Sets a int array of samples for the specified pixel
+ * in this WritableRaster.
+ *
+ * @param x the pixel's X coordinate.
+ * @param y the pixel's Y coordinate.
+ * @param iArray the int array of samples.
+ */
+ public void setPixel(int x, int y, int iArray[]) {
+ sampleModel.setPixel(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, iArray, dataBuffer);
+ }
+
+ /**
+ * Sets a float array of samples for the specified pixel
+ * in this WritableRaster.
+ *
+ * @param x the pixel's X coordinate.
+ * @param y the pixel's Y coordinate.
+ * @param fArray the float array of samples.
+ */
+ public void setPixel(int x, int y, float fArray[]) {
+ sampleModel.setPixel(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, fArray, dataBuffer);
+ }
+
+ /**
+ * Sets a double array of samples for the specified pixel
+ * in this WritableRaster.
+ *
+ * @param x the pixel's X coordinate.
+ * @param y the pixel's Y coordinate.
+ * @param dArray the double array of samples.
+ */
+ public void setPixel(int x, int y, double dArray[]) {
+ sampleModel.setPixel(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, dArray, dataBuffer);
+ }
+
+ /**
+ * Sets a int array of samples for the specified rectangular area
+ * of pixels in this WritableRaster.
+ *
+ * @param x the X coordinate of rectangular area.
+ * @param y the Y coordinate of rectangular area.
+ * @param w the width of rectangular area.
+ * @param h the height of rectangular area.
+ * @param iArray the int array of samples.
+ */
+ public void setPixels(int x, int y, int w, int h, int iArray[]) {
+ sampleModel.setPixels(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, w, h, iArray, dataBuffer);
+ }
+
+ /**
+ * Sets a float array of samples for the specified rectangular area
+ * of pixels in this WritableRaster.
+ *
+ * @param x the X coordinate of rectangular area.
+ * @param y the Y coordinate of rectangular area.
+ * @param w the width of rectangular area.
+ * @param h the height of rectangular area.
+ * @param fArray the float array of samples.
+ */
+ public void setPixels(int x, int y, int w, int h, float fArray[]) {
+ sampleModel.setPixels(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, w, h, fArray, dataBuffer);
+ }
+
+ /**
+ * Sets a double array of samples for the specified rectangular area
+ * of pixels in this WritableRaster.
+ *
+ * @param x the X coordinate of rectangular area.
+ * @param y the Y coordinate of rectangular area.
+ * @param w the width of rectangular area.
+ * @param h the height of rectangular area.
+ * @param dArray the double array of samples.
+ */
+ public void setPixels(int x, int y, int w, int h, double dArray[]) {
+ sampleModel.setPixels(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, w, h, dArray, dataBuffer);
+ }
+
+ /**
+ * Sets the samples for the specified band and the specified
+ * rectangular area of pixels with an int array of samples.
+ *
+ * @param x the X coordinate of the area of pixels.
+ * @param y the Y coordinate of the area of pixels.
+ * @param w the width of the area of pixels.
+ * @param h the height of the area of pixels.
+ * @param b the specified band.
+ * @param iArray the int array of samples.
+
+ */
+ public void setSamples(int x, int y, int w, int h, int b, int iArray[]) {
+ sampleModel.setSamples(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, w, h, b, iArray, dataBuffer);
+ }
+
+ /**
+ * Sets the samples for the specified band and the specified
+ * rectangular area of pixels with a float array of samples.
+ *
+ * @param x the X coordinate of the area of pixels.
+ * @param y the Y coordinate of the area of pixels.
+ * @param w the width of the area of pixels.
+ * @param h the height of the area of pixels.
+ * @param b the specified band.
+ * @param fArray the float array of samples.
+ */
+ public void setSamples(int x, int y, int w, int h, int b, float fArray[]) {
+ sampleModel.setSamples(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, w, h, b, fArray, dataBuffer);
+ }
+
+ /**
+ * Sets the samples for the specified band and the specified
+ * rectangular area of pixels with a double array of samples.
+ *
+ * @param x the X coordinate of the area of pixels.
+ * @param y the Y coordinate of the area of pixels.
+ * @param w the width of the area of pixels.
+ * @param h the height of the area of pixels.
+ * @param b the specified band.
+ * @param dArray the double array of samples.
+ */
+ public void setSamples(int x, int y, int w, int h, int b, double dArray[]) {
+ sampleModel.setSamples(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, w, h, b, dArray, dataBuffer);
+ }
+
+ /**
+ * Sets the sample for the specified band and the specified
+ * pixel with an int sample.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the specified band.
+ * @param s the sample to be set.
+ */
+ public void setSample(int x, int y, int b, int s) {
+ sampleModel.setSample(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, b, s, dataBuffer);
+ }
+
+ /**
+ * Sets the sample for the specified band and the specified
+ * pixel with a float sample.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the specified band.
+ * @param s the sample to be set.
+ */
+ public void setSample(int x, int y, int b, float s) {
+ sampleModel.setSample(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, b, s, dataBuffer);
+ }
+
+ /**
+ * Sets the sample for the specified band and the specified
+ * pixel with a int sample.
+ *
+ * @param x the X coordinate of the pixel.
+ * @param y the Y coordinate of the pixel.
+ * @param b the specified band.
+ * @param s the sample to be set.
+ */
+ public void setSample(int x, int y, int b, double s) {
+ sampleModel.setSample(x - sampleModelTranslateX,
+ y - sampleModelTranslateY, b, s, dataBuffer);
+ }
+
+}
+
diff --git a/awt/java/awt/image/WritableRenderedImage.java b/awt/java/awt/image/WritableRenderedImage.java
new file mode 100644
index 0000000..ee1cb9e
--- /dev/null
+++ b/awt/java/awt/image/WritableRenderedImage.java
@@ -0,0 +1,101 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image;
+
+import java.awt.Point;
+
+/**
+ * The WriteableRenderedImage interface is interface for objects which
+ * contains Raster data of one or several tiles. This interface provides
+ * notification mehanism for obtaining tile's writing status.
+ */
+public interface WritableRenderedImage extends RenderedImage {
+
+ /**
+ * Gets and checks out the writable tile for writing.
+ *
+ * @param tileX the X index of the tile.
+ * @param tileY the Y index of the tile.
+ *
+ * @return the WritableRaster.
+ */
+ public WritableRaster getWritableTile(int tileX, int tileY);
+
+ /**
+ * Removes the registered TileObserver.
+ *
+ * @param to the TileObserver which is registered for this
+ * WritableRenderedImage.
+ */
+ public void removeTileObserver(TileObserver to);
+
+ /**
+ * Adds the specified TileObserver to this WritableRenderedImage.
+ *
+ * @param to the TileObserver object to be added.
+ */
+ public void addTileObserver(TileObserver to);
+
+ /**
+ * Sets this image to the contents of the specified Raster.
+ *
+ * @param r the specified Raster.
+ */
+ public void setData(Raster r);
+
+ /**
+ * Gets the array of points wich represent indices of tiles which
+ * are check out for writing.
+ *
+ * @return the array of Points.
+ */
+ public Point[] getWritableTileIndices();
+
+ /**
+ * Checks if the specified tile is writable or not.
+ *
+ * @param tileX the X index of tile.
+ * @param tileY the Y index of tile.
+ *
+ * @return true, if the specified tile is writable,
+ * false otherwise.
+ */
+ public boolean isTileWritable(int tileX, int tileY);
+
+ /**
+ * Release the specified writable tile. This method removes the writer
+ * from the tile.
+ *
+ * @param tileX the X index of the tile.
+ * @param tileY the Y index of the tile.
+ */
+ public void releaseWritableTile(int tileX, int tileY);
+
+ /**
+ * Checks if there is a tile which is checked out for writing.
+ *
+ * @return true, if any tile is checked out for writing, false if there
+ * is no such tile.
+ */
+ public boolean hasTileWriters();
+
+}
+
diff --git a/awt/java/awt/image/renderable/ContextualRenderedImageFactory.java b/awt/java/awt/image/renderable/ContextualRenderedImageFactory.java
new file mode 100644
index 0000000..3e96637
--- /dev/null
+++ b/awt/java/awt/image/renderable/ContextualRenderedImageFactory.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image.renderable;
+
+import java.awt.geom.Rectangle2D;
+import java.awt.image.RenderedImage;
+
+/**
+ * A factory for creating ContextualRenderedImage objects with utilities
+ * for manipulating the properties in the parameter block.
+ */
+public interface ContextualRenderedImageFactory extends RenderedImageFactory {
+
+ /**
+ * Maps a render context to a parameter block and a renderable image.
+ *
+ * @param a0 the index
+ * @param a1 the RenderContext
+ * @param a2 the ParameterBlock
+ * @param a3 the RenderableImage
+ *
+ * @return the render context
+ */
+ public RenderContext mapRenderContext(int a0, RenderContext a1, ParameterBlock a2, RenderableImage a3);
+
+ /**
+ * Gets the value of the property from the parameter block.
+ *
+ * @param a0 the parameter block to examine to find the property
+ * @param a1 the name of the property
+ *
+ * @return the value of the property
+ */
+ public Object getProperty(ParameterBlock a0, String a1);
+
+ /**
+ * Creates the rendered image determined by the render context and
+ * parameter block.
+ *
+ * @param a0 the RenderContext
+ * @param a1 the ParameterBlock
+ *
+ * @return the rendered image
+ */
+ public RenderedImage create(RenderContext a0, ParameterBlock a1);
+
+ /**
+ * Gets the bounding rectangle from the parameter block.
+ *
+ * @param a0 the parameter block to read the bounds from
+ *
+ * @return the bounding rectangle
+ */
+ public Rectangle2D getBounds2D(ParameterBlock a0);
+
+ /**
+ * Gets the names of all of the supported properties.
+ *
+ * @return the property names
+ */
+ public String[] getPropertyNames();
+
+ /**
+ * Checks if this image factory is dynamic.
+ *
+ * @return true, if this image factory is dynamic
+ */
+ public boolean isDynamic();
+
+}
+
diff --git a/awt/java/awt/image/renderable/ParameterBlock.java b/awt/java/awt/image/renderable/ParameterBlock.java
new file mode 100644
index 0000000..1555f45
--- /dev/null
+++ b/awt/java/awt/image/renderable/ParameterBlock.java
@@ -0,0 +1,548 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image.renderable;
+
+import java.awt.image.RenderedImage;
+import java.io.Serializable;
+import java.util.Vector;
+
+/**
+ * The Class ParameterBlock groups an indexed set of parameter data
+ * with a set of renderable (source) images. The mapping between
+ * the indexed parameters and their property names is provided
+ * by a {@link ContextualRenderedImageFactory}
+ */
+public class ParameterBlock implements Cloneable, Serializable {
+
+
+ /** The Constant serialVersionUID. */
+ private static final long serialVersionUID = -7577115551785240750L;
+
+ /** The sources (renderable images). */
+ protected Vector<Object> sources = new Vector<Object>();
+
+ /** The parameters. */
+ protected Vector<Object> parameters = new Vector<Object>();
+
+ /**
+ * Instantiates a new parameter block.
+ *
+ * @param sources the vector of source images
+ * @param parameters the vector of parameters
+ */
+ public ParameterBlock(Vector<Object> sources, Vector<Object> parameters) {
+ setSources(sources);
+ setParameters(parameters);
+ }
+
+ /**
+ * Instantiates a new parameter block with no parameters.
+ *
+ * @param sources the vector of source images
+ */
+ public ParameterBlock(Vector<Object> sources) {
+ setSources(sources);
+ }
+
+ /**
+ * Instantiates a new parameter block with no image or parameter vectors.
+ */
+ public ParameterBlock() {}
+
+ /**
+ * Sets the source image at the specified index.
+ *
+ * @param source the source image
+ * @param index the index where the source will be placed
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock setSource(Object source, int index) {
+ if(sources.size() < index + 1){
+ sources.setSize(index + 1);
+ }
+ sources.setElementAt(source, index);
+ return this;
+ }
+
+ /**
+ * Sets the parameter value object at the specified index.
+ *
+ * @param obj the parameter value to place at the desired index
+ * @param index the index where the object is to be placed in the
+ * vector of parameters
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock set(Object obj, int index) {
+ if(parameters.size() < index + 1){
+ parameters.setSize(index + 1);
+ }
+ parameters.setElementAt(obj, index);
+ return this;
+ }
+
+ /**
+ * Adds a source to the vector of sources.
+ *
+ * @param source the source to add
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock addSource(Object source) {
+ sources.addElement(source);
+ return this;
+ }
+
+ /**
+ * Adds the object to the vector of parameter values
+ *
+ * @param obj the obj to add
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock add(Object obj) {
+ parameters.addElement(obj);
+ return this;
+ }
+
+ /**
+ * Sets the vector of sources, replacing the existing
+ * vector of sources, if any.
+ *
+ * @param sources the new sources
+ */
+ public void setSources(Vector<Object> sources) {
+ this.sources = sources;
+ }
+
+ /**
+ * Sets the vector of parameters, replacing the existing
+ * vector of parameters, if any.
+ *
+ * @param parameters the new parameters
+ */
+ public void setParameters(Vector<Object> parameters) {
+ this.parameters = parameters;
+ }
+
+ /**
+ * Gets the vector of sources.
+ *
+ * @return the sources
+ */
+ public Vector<Object> getSources() {
+ return sources;
+ }
+
+ /**
+ * Gets the vector of parameters.
+ *
+ * @return the parameters
+ */
+ public Vector<Object> getParameters() {
+ return parameters;
+ }
+
+ /**
+ * Gets the source at the specified index.
+ *
+ * @param index the index
+ *
+ * @return the source object found at the specified index
+ */
+ public Object getSource(int index) {
+ return sources.elementAt(index);
+ }
+
+ /**
+ * Gets the object parameter found at the specified index.
+ *
+ * @param index the index
+ *
+ * @return the parameter object found at the specified index
+ */
+ public Object getObjectParameter(int index) {
+ return parameters.elementAt(index);
+ }
+
+ /**
+ * Shallow clone (clones using the superclass clone method).
+ *
+ * @return the clone of this object
+ */
+ public Object shallowClone() {
+ try{
+ return super.clone();
+ }catch(Exception e){
+ return null;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public Object clone() {
+ ParameterBlock replica;
+ try{
+ replica = (ParameterBlock)super.clone();
+ }catch(Exception e){
+ return null;
+ }
+ if(sources != null){
+ replica.setSources((Vector<Object>)(sources.clone()));
+ }
+ if(parameters != null){
+ replica.setParameters((Vector<Object>)(parameters.clone()));
+ }
+ return replica;
+ }
+
+ /**
+ * Gets an array of classes corresponding to all of the parameter
+ * values found in the array of parameters, in order.
+ *
+ * @return the parameter classes
+ */
+ public Class[] getParamClasses() {
+ int count = parameters.size();
+ Class paramClasses[] = new Class[count];
+
+ for(int i = 0; i < count; i++){
+ paramClasses[i] = parameters.elementAt(i).getClass();
+ }
+ return paramClasses;
+ }
+
+ /**
+ * Gets the renderable source image found at the specified index
+ * in the source array.
+ *
+ * @param index the index
+ *
+ * @return the renderable source image
+ */
+ public RenderableImage getRenderableSource(int index) {
+ return (RenderableImage)sources.elementAt(index);
+ }
+
+ /**
+ * Wraps the short value in a Short and places it in the
+ * parameter block at the specified index.
+ *
+ * @param s the short value of the parameter
+ * @param index the index
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock set(short s, int index) {
+ return set(new Short(s), index);
+ }
+
+ /**
+ * Wraps the short value in a Short and adds it to the
+ * parameter block.
+ *
+ * @param s the short value of the parameter
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock add(short s) {
+ return add(new Short(s));
+ }
+
+ /**
+ * Wraps the long value in a Long and places it in the
+ * parameter block at the specified index.
+ *
+ * @param l the long value of the parameter
+ * @param index the index
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock set(long l, int index) {
+ return set(new Long(l), index);
+ }
+
+ /**
+ * Wraps the long value in a Long and adds it to the
+ * parameter block.
+ *
+ * @param l the long value of the parameter
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock add(long l) {
+ return add(new Long(l));
+ }
+
+ /**
+ * Wraps the int value in an Integer and places it in the
+ * parameter block at the specified index.
+ *
+ * @param i the int value of the parameter
+ * @param index the index
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock set(int i, int index) {
+ return set(new Integer(i), index);
+ }
+
+ /**
+ * Wraps the int value in an Integer and adds it to the
+ * parameter block.
+ *
+ * @param i the int value of the parameter
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock add(int i) {
+ return add(new Integer(i));
+ }
+
+ /**
+ * Wraps the float value in a Float and places it in the
+ * parameter block at the specified index.
+ *
+ * @param f the float value of the parameter
+ * @param index the index
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock set(float f, int index) {
+ return set(new Float(f), index);
+ }
+
+ /**
+ * Wraps the float value in a Float and adds it to the
+ * parameter block.
+ *
+ * @param f the float value of the parameter
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock add(float f) {
+ return add(new Float(f));
+ }
+
+ /**
+ * Wraps the double value in a Double and places it in the
+ * parameter block at the specified index.
+ *
+ * @param d the double value of the parameter
+ * @param index the index
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock set(double d, int index) {
+ return set(new Double(d), index);
+ }
+
+ /**
+ * Wraps the double value in a Double and adds it to the
+ * parameter block.
+ *
+ * @param d the double value of the parameter
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock add(double d) {
+ return add(new Double(d));
+ }
+
+ /**
+ * Wraps the char value in a Character and places it in the
+ * parameter block at the specified index.
+ *
+ * @param c the char value of the parameter
+ * @param index the index
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock set(char c, int index) {
+ return set(new Character(c), index);
+ }
+
+ /**
+ * Wraps the char value in a Character and adds it to the
+ * parameter block.
+ *
+ * @param c the char value of the parameter
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock add(char c) {
+ return add(new Character(c));
+ }
+
+ /**
+ * Wraps the byte value in a Byte and places it in the
+ * parameter block at the specified index.
+ *
+ * @param b the byte value of the parameter
+ * @param index the index
+ *
+ * @return this parameter block
+ */
+ public ParameterBlock set(byte b, int index) {
+ return set(new Byte(b), index);
+ }
+
+ /**
+ * Wraps the byte value in a Byte and adds it to the
+ * parameter block.
+ *
+ * @param b the byte value of the parameter
+ *
+ * @return the parameter block
+ */
+ public ParameterBlock add(byte b) {
+ return add(new Byte(b));
+ }
+
+ /**
+ * Gets the RenderedImage at the specified index from the
+ * vector of source images.
+ *
+ * @param index the index
+ *
+ * @return the rendered image
+ */
+ public RenderedImage getRenderedSource(int index) {
+ return (RenderedImage)sources.elementAt(index);
+ }
+
+ /**
+ * Gets the short-valued parameter found at the desired index
+ * in the vector of parameter values.
+ *
+ * @param index the index
+ *
+ * @return the short parameter
+ */
+ public short getShortParameter(int index) {
+ return ((Short)parameters.elementAt(index)).shortValue();
+ }
+
+ /**
+ * Gets the long-valued parameter found at the desired index
+ * in the vector of parameter values.
+ *
+ * @param index the index
+ *
+ * @return the long parameter
+ */
+ public long getLongParameter(int index) {
+ return ((Long)parameters.elementAt(index)).longValue();
+ }
+
+ /**
+ * Gets the int-valued parameter found at the desired index
+ * in the vector of parameter values.
+ *
+ * @param index the index
+ *
+ * @return the int parameter
+ */
+ public int getIntParameter(int index) {
+ return ((Integer)parameters.elementAt(index)).intValue();
+ }
+
+ /**
+ * Gets the float-valued parameter found at the desired index
+ * in the vector of parameter values.
+ *
+ * @param index the index
+ *
+ * @return the float parameter
+ */
+ public float getFloatParameter(int index) {
+ return ((Float)parameters.elementAt(index)).floatValue();
+ }
+
+ /**
+ * Gets the double-valued parameter found at the desired index
+ * in the vector of parameter values.
+ *
+ * @param index the index
+ *
+ * @return the double parameter
+ */
+ public double getDoubleParameter(int index) {
+ return ((Double)parameters.elementAt(index)).doubleValue();
+ }
+
+ /**
+ * Gets the char-valued parameter found at the desired index
+ * in the vector of parameter values.
+ *
+ * @param index the index
+ *
+ * @return the char parameter
+ */
+ public char getCharParameter(int index) {
+ return ((Character)parameters.elementAt(index)).charValue();
+ }
+
+ /**
+ * Gets the byte-valued parameter found at the desired index
+ * in the vector of parameter values.
+ *
+ * @param index the index
+ *
+ * @return the byte parameter
+ */
+ public byte getByteParameter(int index) {
+ return ((Byte)parameters.elementAt(index)).byteValue();
+ }
+
+ /**
+ * Clears the vector of sources.
+ */
+ public void removeSources() {
+ sources.removeAllElements();
+ }
+
+ /**
+ * Clears the vector of parameters.
+ */
+ public void removeParameters() {
+ parameters.removeAllElements();
+ }
+
+ /**
+ * Gets the number of elements in the vector of sources.
+ *
+ * @return the number of elements in the vector of sources
+ */
+ public int getNumSources() {
+ return sources.size();
+ }
+
+ /**
+ * Gets the number of elements in the vector of parameters.
+ *
+ * @return the number of elements in the vector of parameters
+ */
+ public int getNumParameters() {
+ return parameters.size();
+ }
+}
diff --git a/awt/java/awt/image/renderable/RenderContext.java b/awt/java/awt/image/renderable/RenderContext.java
new file mode 100644
index 0000000..3a3b93c
--- /dev/null
+++ b/awt/java/awt/image/renderable/RenderContext.java
@@ -0,0 +1,196 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image.renderable;
+
+import java.awt.RenderingHints;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+
+/**
+ * The Class RenderContext stores data on how an image is to be
+ * rendered: the affine transform, the area of interest, and
+ * the rendering hints.
+ */
+public class RenderContext implements Cloneable {
+
+ /** The affine transform. */
+ AffineTransform transform;
+
+ /** The area of interest. */
+ Shape aoi;
+
+ /** The rendering hints. */
+ RenderingHints hints;
+
+ /**
+ * Instantiates a new render context.
+ *
+ * @param usr2dev the affine transform
+ * @param aoi the area of interest
+ * @param hints the rendering hints
+ */
+ public RenderContext(AffineTransform usr2dev, Shape aoi, RenderingHints hints) {
+ this.transform = (AffineTransform)usr2dev.clone();
+ this.aoi = aoi;
+ this.hints = hints;
+ }
+
+ /**
+ * Instantiates a new render context with no specified hints.
+ *
+ * @param usr2dev the affine transform
+ * @param aoi the area of interest
+ */
+ public RenderContext(AffineTransform usr2dev, Shape aoi) {
+ this(usr2dev, aoi, null);
+ }
+
+ /**
+ * Instantiates a new render context with no specified area of interest.
+ *
+ * @param usr2dev the affine transform
+ * @param hints the rendering hints
+ */
+ public RenderContext(AffineTransform usr2dev, RenderingHints hints) {
+ this(usr2dev, null, hints);
+ }
+
+ /**
+ * Instantiates a new render context with no rendering hints or
+ * area of interest.
+ *
+ * @param usr2dev the affine transform
+ */
+ public RenderContext(AffineTransform usr2dev) {
+ this(usr2dev, null, null);
+ }
+
+ @Override
+ public Object clone() {
+ return new RenderContext(transform, aoi, hints);
+ }
+
+ /**
+ * Sets the affine transform for this render context.
+ *
+ * @param newTransform the new affine transform
+ */
+ public void setTransform(AffineTransform newTransform) {
+ transform = (AffineTransform)newTransform.clone();
+ }
+
+ /**
+ * Concatenates the current transform with the specified transform
+ * (so they are applied with the specified transform acting first)
+ * and sets the resulting transform as the affine transform of
+ * this rendering context.
+ *
+ * @param modTransform the new transform which modifies the
+ * current transform
+ *
+ * @deprecated use {@link RenderContext#preConcatenateTransform(AffineTransform)}
+ */
+ @Deprecated
+ public void preConcetenateTransform(AffineTransform modTransform) {
+ preConcatenateTransform(modTransform);
+ }
+
+ /**
+ * Concatenates the current transform with the specified transform
+ * (so they are applied with the specified transform acting first)
+ * and sets the resulting transform as the affine transform of
+ * this rendering context.
+ *
+ * @param modTransform the new transform which modifies the
+ * current transform
+ */
+ public void preConcatenateTransform(AffineTransform modTransform) {
+ transform.preConcatenate(modTransform);
+ }
+
+ /**
+ * Concatenate the specified transform with the current transform.
+ *
+ * @param modTransform the new transform which modifies the
+ * current transform
+ *
+ * @deprecated use {@link RenderContext#concatenateTransform(AffineTransform)}
+ */
+ @Deprecated
+ public void concetenateTransform(AffineTransform modTransform) {
+ concatenateTransform(modTransform);
+ }
+
+ /**
+ * Concatenate the specified transform with the current transform.
+ *
+ * @param modTransform the new transform which modifies the
+ * current transform
+ */
+ public void concatenateTransform(AffineTransform modTransform) {
+ transform.concatenate(modTransform);
+ }
+
+ /**
+ * Gets the transform.
+ *
+ * @return the transform
+ */
+ public AffineTransform getTransform() {
+ return (AffineTransform)transform.clone();
+ }
+
+ /**
+ * Sets the area of interest.
+ *
+ * @param newAoi the new area of interest
+ */
+ public void setAreaOfInterest(Shape newAoi) {
+ aoi = newAoi;
+ }
+
+ /**
+ * Gets the area of interest.
+ *
+ * @return the area of interest
+ */
+ public Shape getAreaOfInterest() {
+ return aoi;
+ }
+
+ /**
+ * Sets the rendering hints.
+ *
+ * @param hints the new rendering hints
+ */
+ public void setRenderingHints(RenderingHints hints) {
+ this.hints = hints;
+ }
+
+ /**
+ * Gets the rendering hints.
+ *
+ * @return the rendering hints
+ */
+ public RenderingHints getRenderingHints() {
+ return hints;
+ }
+}
diff --git a/awt/java/awt/image/renderable/RenderableImage.java b/awt/java/awt/image/renderable/RenderableImage.java
new file mode 100644
index 0000000..885dc06
--- /dev/null
+++ b/awt/java/awt/image/renderable/RenderableImage.java
@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image.renderable;
+
+import java.awt.RenderingHints;
+import java.awt.image.RenderedImage;
+import java.util.Vector;
+
+/**
+ * The Interface RenderableImage is implemented by an object that
+ * collects all of the image-specific data that defines a single image
+ * that could be rendered to different rendering targets.
+ */
+public interface RenderableImage {
+
+ /** The Constant HINTS_OBSERVED indicates that the rendering
+ * hints are applied rather than ignored. */
+ public static final String HINTS_OBSERVED = "HINTS_OBSERVED"; //$NON-NLS-1$
+
+ /**
+ * Gets the property from the RenderableImage's parameter block.
+ *
+ * @param name the name of the property to get.
+ *
+ * @return the value of the property
+ */
+ public Object getProperty(String name);
+
+ /**
+ * Creates the rendered image based on the information contained
+ * in the parameters and the render context.
+ *
+ * @param renderContext the render context giving rendering specifications
+ * such as transformations
+ *
+ * @return the rendered image
+ */
+ public RenderedImage createRendering(RenderContext renderContext);
+
+ /**
+ * Creates the scaled rendered image based on the information contained
+ * in the parameters and the render context.
+ *
+ * @param w the desired width after scaling or zero if the scaling
+ * should be proportional, based on the height
+ * @param h the desired height after scaling or zero if the scaling
+ * should be proportional, based on the width
+ * @param hints the rendering hints to use
+ *
+ * @return the rendered image
+ *
+ * @throws IllegalArgumentException if both the height and width are zero
+ */
+ public RenderedImage createScaledRendering(int w, int h, RenderingHints hints);
+
+ /**
+ * Gets the vector of sources from the parameter block.
+ *
+ * @return the sources
+ */
+ public Vector<RenderableImage> getSources();
+
+ /**
+ * Gets the names of all of the supported properties in the current context.
+ *
+ * @return the property names
+ */
+ public String[] getPropertyNames();
+
+ /**
+ * Creates the default rendering (using the identity transform
+ * and default render context).
+ *
+ * @return the rendered image
+ */
+ public RenderedImage createDefaultRendering();
+
+ /**
+ * Checks if this context supports dynamic rendering.
+ *
+ * @return true, if this context supports dynamic rendering
+ */
+ public boolean isDynamic();
+
+ /**
+ * Gets the width of the image.
+ *
+ * @return the width of the image
+ */
+ public float getWidth();
+
+ /**
+ * Gets the y coordinate of the upper left corner.
+ *
+ * @return the y coordinate of the upper left corner
+ */
+ public float getMinY();
+
+ /**
+ * Gets the x coordinate of the upper left corner.
+ *
+ * @return the x coordinate of the upper left corner
+ */
+ public float getMinX();
+
+ /**
+ * Gets the height of the image.
+ *
+ * @return the height of the image
+ */
+ public float getHeight();
+
+}
+
diff --git a/awt/java/awt/image/renderable/RenderableImageOp.java b/awt/java/awt/image/renderable/RenderableImageOp.java
new file mode 100644
index 0000000..993ba5f
--- /dev/null
+++ b/awt/java/awt/image/renderable/RenderableImageOp.java
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image.renderable;
+
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.RenderedImage;
+import java.util.Vector;
+
+import org.apache.harmony.awt.internal.nls.Messages;
+
+/**
+ * The Class RenderableImageOp is a basic implementation of RenderableImage,
+ * with methods to access the parameter data and perform rendering
+ * operations.
+ */
+public class RenderableImageOp implements RenderableImage {
+
+ /** The CRIF. */
+ ContextualRenderedImageFactory CRIF;
+
+ /** The param block. */
+ ParameterBlock paramBlock;
+
+ /** The height. */
+ float minX, minY, width, height;
+
+ /**
+ * Instantiates a new renderable image op.
+ *
+ * @param CRIF the cRIF
+ * @param paramBlock the param block
+ */
+ public RenderableImageOp(ContextualRenderedImageFactory CRIF, ParameterBlock paramBlock) {
+ this.CRIF = CRIF;
+ this.paramBlock = (ParameterBlock) paramBlock.clone();
+ Rectangle2D r = CRIF.getBounds2D(paramBlock);
+ minX = (float) r.getMinX();
+ minY = (float) r.getMinY();
+ width = (float) r.getWidth();
+ height = (float) r.getHeight();
+ }
+
+ public Object getProperty(String name) {
+ return CRIF.getProperty(paramBlock, name);
+ }
+
+ /**
+ * Sets the parameter block.
+ *
+ * @param paramBlock the param block
+ *
+ * @return the parameter block
+ */
+ public ParameterBlock setParameterBlock(ParameterBlock paramBlock) {
+ ParameterBlock oldParam = this.paramBlock;
+ this.paramBlock = (ParameterBlock) paramBlock.clone();
+ return oldParam;
+ }
+
+ public RenderedImage createRendering(RenderContext renderContext) {
+
+ Vector<RenderableImage> sources = getSources();
+ ParameterBlock rdParam = (ParameterBlock) paramBlock.clone();
+
+ if (sources != null) {
+ Vector<Object> rdSources = new Vector<Object>();
+ int i = 0;
+ while (i < sources.size()) {
+ RenderContext newContext = CRIF.mapRenderContext(i, renderContext, paramBlock,
+ this);
+ RenderedImage rdim = sources.elementAt(i).createRendering(newContext);
+
+ if (rdim != null) {
+ rdSources.addElement(rdim);
+ }
+ i++;
+ }
+ if (rdSources.size() > 0) {
+ rdParam.setSources(rdSources);
+ }
+ }
+ return CRIF.create(renderContext, rdParam);
+ }
+
+ public RenderedImage createScaledRendering(int w, int h, RenderingHints hints) {
+ if(w == 0 && h == 0) {
+ // awt.60=Width and Height mustn't be equal zero both
+ throw new IllegalArgumentException(Messages.getString("awt.60")); //$NON-NLS-1$
+ }
+ if(w == 0){
+ w = Math.round(h*(getWidth()/getHeight()));
+ }
+
+ if(h == 0){
+ h = Math.round(w*(getHeight()/getWidth()));
+ }
+
+ double sx = (double)w/getWidth();
+ double sy = (double)h/getHeight();
+
+ AffineTransform at = AffineTransform.getScaleInstance(sx, sy);
+ RenderContext context = new RenderContext(at, hints);
+ return createRendering(context);
+ }
+
+ public Vector<RenderableImage> getSources() {
+ if(paramBlock.getNumSources() == 0) {
+ return null;
+ }
+ Vector<RenderableImage> v = new Vector<RenderableImage>();
+ int i = 0;
+ while(i < paramBlock.getNumSources()){
+ Object o = paramBlock.getSource(i);
+ if(o instanceof RenderableImage){
+ v.addElement((RenderableImage) o);
+ }
+ i++;
+ }
+ return v;
+ }
+
+ public String[] getPropertyNames() {
+ return CRIF.getPropertyNames();
+ }
+
+ /**
+ * Gets the parameter block.
+ *
+ * @return the parameter block
+ */
+ public ParameterBlock getParameterBlock() {
+ return paramBlock;
+ }
+
+ public RenderedImage createDefaultRendering() {
+ AffineTransform at = new AffineTransform();
+ RenderContext context = new RenderContext(at);
+ return createRendering(context);
+ }
+
+ public boolean isDynamic() {
+ return CRIF.isDynamic();
+ }
+
+ public float getWidth() {
+ return width;
+ }
+
+ public float getMinY() {
+ return minY;
+ }
+
+ public float getMinX() {
+ return minX;
+ }
+
+ public float getHeight() {
+ return height;
+ }
+
+}
+
diff --git a/awt/java/awt/image/renderable/RenderableImageProducer.java b/awt/java/awt/image/renderable/RenderableImageProducer.java
new file mode 100644
index 0000000..7fda98c
--- /dev/null
+++ b/awt/java/awt/image/renderable/RenderableImageProducer.java
@@ -0,0 +1,141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image.renderable;
+
+import java.awt.image.ColorModel;
+import java.awt.image.ImageConsumer;
+import java.awt.image.ImageProducer;
+import java.awt.image.Raster;
+import java.awt.image.RenderedImage;
+import java.util.Vector;
+
+/**
+ * The Class RenderableImageProducer provides the implementation for
+ * the image rendering.
+ */
+public class RenderableImageProducer implements ImageProducer, Runnable {
+
+ /** The rbl. */
+ RenderableImage rbl;
+
+ /** The rc. */
+ RenderContext rc;
+
+ /** The consumers. */
+ Vector<ImageConsumer> consumers = new Vector<ImageConsumer>();
+
+ /**
+ * Instantiates a new renderable image producer.
+ *
+ * @param rdblImage the rdbl image
+ * @param rc the rc
+ */
+ public RenderableImageProducer(RenderableImage rdblImage, RenderContext rc) {
+ this.rbl = rdblImage;
+ this.rc = rc;
+ }
+
+ /**
+ * Sets the render context.
+ *
+ * @param rc the new render context
+ */
+ public synchronized void setRenderContext(RenderContext rc) {
+ this.rc = rc;
+ }
+
+ public synchronized boolean isConsumer(ImageConsumer ic) {
+ return consumers.contains(ic);
+ }
+
+ public synchronized void startProduction(ImageConsumer ic) {
+ addConsumer(ic);
+ Thread t = new Thread(this, "RenderableImageProducer thread"); //$NON-NLS-1$
+ t.start();
+ }
+
+ public void requestTopDownLeftRightResend(ImageConsumer ic) {}
+
+ public synchronized void removeConsumer(ImageConsumer ic) {
+ if(ic != null) {
+ consumers.removeElement(ic);
+ }
+ }
+
+ public synchronized void addConsumer(ImageConsumer ic) {
+ if(ic != null && !consumers.contains(ic)){
+ consumers.addElement(ic);
+ }
+ }
+
+ /**
+ * Creates the rendered image in a new thread.
+ */
+ public void run() {
+ if(rbl == null) {
+ return;
+ }
+
+ RenderedImage rd;
+ if(rc != null) {
+ rd = rbl.createRendering(rc);
+ } else {
+ rd = rbl.createDefaultRendering();
+ }
+
+ ColorModel cm = rd.getColorModel();
+ if(cm == null) {
+ cm = ColorModel.getRGBdefault();
+ }
+
+ Raster r = rd.getData();
+ int w = r.getWidth();
+ int h = r.getHeight();
+
+ for (ImageConsumer c : consumers) {
+ c.setDimensions(w, h);
+ c.setHints(ImageConsumer.TOPDOWNLEFTRIGHT |
+ ImageConsumer.COMPLETESCANLINES |
+ ImageConsumer.SINGLEFRAME |
+ ImageConsumer.SINGLEPASS);
+ }
+
+ int scanLine[] = new int[w];
+ int pixel[] = null;
+
+ for(int y = 0; y < h; y++){
+ for(int x = 0; x < w; x++){
+ pixel = r.getPixel(x, y, pixel);
+ scanLine[x] = cm.getDataElement(pixel, 0);
+ }
+
+ for (ImageConsumer c : consumers) {
+ c.setPixels(0, y, w, 1, cm, scanLine, 0, w);
+ }
+ }
+
+ for (ImageConsumer c : consumers) {
+ c.imageComplete(ImageConsumer.STATICIMAGEDONE);
+ }
+ }
+
+}
+
diff --git a/awt/java/awt/image/renderable/RenderedImageFactory.java b/awt/java/awt/image/renderable/RenderedImageFactory.java
new file mode 100644
index 0000000..345d82c
--- /dev/null
+++ b/awt/java/awt/image/renderable/RenderedImageFactory.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Igor V. Stolyarov
+ * @version $Revision$
+ */
+package java.awt.image.renderable;
+
+import java.awt.RenderingHints;
+import java.awt.image.RenderedImage;
+
+/**
+ * A factory for creating RenderedImage objects based on parameters
+ * and rendering hints.
+ */
+public interface RenderedImageFactory {
+
+ /**
+ * Creates the rendered image.
+ *
+ * @param a0 the ParameterBlock
+ * @param a1 the RenderingHints
+ *
+ * @return the rendered image
+ */
+ public RenderedImage create(ParameterBlock a0, RenderingHints a1);
+
+}
+
diff --git a/awt/java/awt/peer/ButtonPeer.java b/awt/java/awt/peer/ButtonPeer.java
new file mode 100644
index 0000000..cc45b49
--- /dev/null
+++ b/awt/java/awt/peer/ButtonPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface ButtonPeer {
+
+}
diff --git a/awt/java/awt/peer/CanvasPeer.java b/awt/java/awt/peer/CanvasPeer.java
new file mode 100644
index 0000000..e276366
--- /dev/null
+++ b/awt/java/awt/peer/CanvasPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface CanvasPeer {
+
+}
diff --git a/awt/java/awt/peer/CheckboxMenuItemPeer.java b/awt/java/awt/peer/CheckboxMenuItemPeer.java
new file mode 100644
index 0000000..296f422
--- /dev/null
+++ b/awt/java/awt/peer/CheckboxMenuItemPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface CheckboxMenuItemPeer {
+
+}
diff --git a/awt/java/awt/peer/CheckboxPeer.java b/awt/java/awt/peer/CheckboxPeer.java
new file mode 100644
index 0000000..e9f8dd1
--- /dev/null
+++ b/awt/java/awt/peer/CheckboxPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface CheckboxPeer {
+
+}
diff --git a/awt/java/awt/peer/ChoicePeer.java b/awt/java/awt/peer/ChoicePeer.java
new file mode 100644
index 0000000..57b7629
--- /dev/null
+++ b/awt/java/awt/peer/ChoicePeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface ChoicePeer {
+
+}
diff --git a/awt/java/awt/peer/ComponentPeer.java b/awt/java/awt/peer/ComponentPeer.java
new file mode 100644
index 0000000..bc26791
--- /dev/null
+++ b/awt/java/awt/peer/ComponentPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface ComponentPeer {
+
+}
diff --git a/awt/java/awt/peer/DialogPeer.java b/awt/java/awt/peer/DialogPeer.java
new file mode 100644
index 0000000..8ae3049
--- /dev/null
+++ b/awt/java/awt/peer/DialogPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface DialogPeer {
+
+}
diff --git a/awt/java/awt/peer/FileDialogPeer.java b/awt/java/awt/peer/FileDialogPeer.java
new file mode 100644
index 0000000..0d15e48
--- /dev/null
+++ b/awt/java/awt/peer/FileDialogPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface FileDialogPeer {
+
+}
diff --git a/awt/java/awt/peer/FontPeer.java b/awt/java/awt/peer/FontPeer.java
new file mode 100644
index 0000000..fd9815f
--- /dev/null
+++ b/awt/java/awt/peer/FontPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface FontPeer {
+
+}
diff --git a/awt/java/awt/peer/FramePeer.java b/awt/java/awt/peer/FramePeer.java
new file mode 100644
index 0000000..9cfc40b
--- /dev/null
+++ b/awt/java/awt/peer/FramePeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface FramePeer {
+
+}
diff --git a/awt/java/awt/peer/LabelPeer.java b/awt/java/awt/peer/LabelPeer.java
new file mode 100644
index 0000000..052ca9d
--- /dev/null
+++ b/awt/java/awt/peer/LabelPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface LabelPeer {
+
+}
diff --git a/awt/java/awt/peer/LightweightPeer.java b/awt/java/awt/peer/LightweightPeer.java
new file mode 100644
index 0000000..1dee905
--- /dev/null
+++ b/awt/java/awt/peer/LightweightPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface LightweightPeer {
+
+}
diff --git a/awt/java/awt/peer/ListPeer.java b/awt/java/awt/peer/ListPeer.java
new file mode 100644
index 0000000..0a27885
--- /dev/null
+++ b/awt/java/awt/peer/ListPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface ListPeer {
+
+}
diff --git a/awt/java/awt/peer/MenuBarPeer.java b/awt/java/awt/peer/MenuBarPeer.java
new file mode 100644
index 0000000..3ad2c16
--- /dev/null
+++ b/awt/java/awt/peer/MenuBarPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface MenuBarPeer {
+
+}
diff --git a/awt/java/awt/peer/MenuComponentPeer.java b/awt/java/awt/peer/MenuComponentPeer.java
new file mode 100644
index 0000000..3ac3b34
--- /dev/null
+++ b/awt/java/awt/peer/MenuComponentPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface MenuComponentPeer {
+
+}
diff --git a/awt/java/awt/peer/MenuItemPeer.java b/awt/java/awt/peer/MenuItemPeer.java
new file mode 100644
index 0000000..b133897
--- /dev/null
+++ b/awt/java/awt/peer/MenuItemPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface MenuItemPeer {
+
+}
diff --git a/awt/java/awt/peer/MenuPeer.java b/awt/java/awt/peer/MenuPeer.java
new file mode 100644
index 0000000..d643ce7
--- /dev/null
+++ b/awt/java/awt/peer/MenuPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface MenuPeer {
+
+}
diff --git a/awt/java/awt/peer/MouseInfoPeer.java b/awt/java/awt/peer/MouseInfoPeer.java
new file mode 100644
index 0000000..9173a62
--- /dev/null
+++ b/awt/java/awt/peer/MouseInfoPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface MouseInfoPeer {
+
+}
diff --git a/awt/java/awt/peer/PanelPeer.java b/awt/java/awt/peer/PanelPeer.java
new file mode 100644
index 0000000..1faa1fe
--- /dev/null
+++ b/awt/java/awt/peer/PanelPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface PanelPeer {
+
+}
diff --git a/awt/java/awt/peer/PopupMenuPeer.java b/awt/java/awt/peer/PopupMenuPeer.java
new file mode 100644
index 0000000..cf1ef61
--- /dev/null
+++ b/awt/java/awt/peer/PopupMenuPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface PopupMenuPeer {
+
+}
diff --git a/awt/java/awt/peer/ScrollPanePeer.java b/awt/java/awt/peer/ScrollPanePeer.java
new file mode 100644
index 0000000..df3de83
--- /dev/null
+++ b/awt/java/awt/peer/ScrollPanePeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface ScrollPanePeer {
+
+}
diff --git a/awt/java/awt/peer/ScrollbarPeer.java b/awt/java/awt/peer/ScrollbarPeer.java
new file mode 100644
index 0000000..eec8961
--- /dev/null
+++ b/awt/java/awt/peer/ScrollbarPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface ScrollbarPeer {
+
+}
diff --git a/awt/java/awt/peer/TextAreaPeer.java b/awt/java/awt/peer/TextAreaPeer.java
new file mode 100644
index 0000000..636707f
--- /dev/null
+++ b/awt/java/awt/peer/TextAreaPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface TextAreaPeer {
+
+}
diff --git a/awt/java/awt/peer/TextFieldPeer.java b/awt/java/awt/peer/TextFieldPeer.java
new file mode 100644
index 0000000..2b8232a
--- /dev/null
+++ b/awt/java/awt/peer/TextFieldPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface TextFieldPeer {
+
+}
diff --git a/awt/java/awt/peer/WindowPeer.java b/awt/java/awt/peer/WindowPeer.java
new file mode 100644
index 0000000..384646f
--- /dev/null
+++ b/awt/java/awt/peer/WindowPeer.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+/**
+ * @author Pavel Dolgov
+ * @version $Revision$
+ */
+package java.awt.peer;
+
+public interface WindowPeer {
+
+}
diff --git a/awt/java/beans/FeatureDescriptor.java b/awt/java/beans/FeatureDescriptor.java
new file mode 100644
index 0000000..2945c65
--- /dev/null
+++ b/awt/java/beans/FeatureDescriptor.java
@@ -0,0 +1,234 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+/**
+ * Common base class for Descriptors.
+ */
+public class FeatureDescriptor {
+
+ private Map<String, Object> values;
+
+ boolean preferred, hidden, expert;
+
+ String shortDescription;
+
+ String name;
+
+ String displayName;
+
+ /**
+ * <p>
+ * Constructs an instance.
+ * </p>
+ */
+ public FeatureDescriptor() {
+ this.values = new HashMap<String, Object>();
+ }
+
+ /**
+ * <p>
+ * Sets the value for the named attribute.
+ * </p>
+ *
+ * @param attributeName
+ * The name of the attribute to set a value with.
+ * @param value
+ * The value to set.
+ */
+ public void setValue(String attributeName, Object value) {
+ if (attributeName == null || value == null) {
+ throw new NullPointerException();
+ }
+ values.put(attributeName, value);
+ }
+
+ /**
+ * <p>
+ * Gets the value associated with the named attribute.
+ * </p>
+ *
+ * @param attributeName
+ * The name of the attribute to get a value for.
+ * @return The attribute's value.
+ */
+ public Object getValue(String attributeName) {
+ Object result = null;
+ if (attributeName != null) {
+ result = values.get(attributeName);
+ }
+ return result;
+ }
+
+ /**
+ * <p>
+ * Enumerates the attribute names.
+ * </p>
+ *
+ * @return An instance of {@link Enumeration}.
+ */
+ public Enumeration<String> attributeNames() {
+ // Create a new list, so that the references are copied
+ return Collections.enumeration(new LinkedList<String>(values.keySet()));
+ }
+
+ /**
+ * <p>
+ * Sets the short description.
+ * </p>
+ *
+ * @param text
+ * The description to set.
+ */
+ public void setShortDescription(String text) {
+ this.shortDescription = text;
+ }
+
+ /**
+ * <p>
+ * Sets the name.
+ * </p>
+ *
+ * @param name
+ * The name to set.
+ */
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ /**
+ * <p>
+ * Sets the display name.
+ * </p>
+ *
+ * @param displayName
+ * The display name to set.
+ */
+ public void setDisplayName(String displayName) {
+ this.displayName = displayName;
+ }
+
+ /**
+ * <p>
+ * Gets the short description or {@link #getDisplayName()} if not set.
+ * </p>
+ *
+ * @return The description.
+ */
+ public String getShortDescription() {
+ return shortDescription == null ? getDisplayName() : shortDescription;
+ }
+
+ /**
+ * <p>
+ * Gets the name.
+ * </p>
+ *
+ * @return The name.
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * <p>
+ * Gets the display name or {@link #getName()} if not set.
+ * </p>
+ *
+ * @return The display name.
+ */
+ public String getDisplayName() {
+ return displayName == null ? getName() : displayName;
+ }
+
+ /**
+ * <p>
+ * Sets the preferred indicator.
+ * </p>
+ *
+ * @param preferred
+ * <code>true</code> if preferred, <code>false</code>
+ * otherwise.
+ */
+ public void setPreferred(boolean preferred) {
+ this.preferred = preferred;
+ }
+
+ /**
+ * <p>
+ * Sets the hidden indicator.
+ * </p>
+ *
+ * @param hidden
+ * <code>true</code> if hidden, <code>false</code> otherwise.
+ */
+ public void setHidden(boolean hidden) {
+ this.hidden = hidden;
+ }
+
+ /**
+ * <p>
+ * Sets the expert indicator.
+ * </p>
+ *
+ * @param expert
+ * <code>true</code> if expert, <code>false</code> otherwise.
+ */
+ public void setExpert(boolean expert) {
+ this.expert = expert;
+ }
+
+ /**
+ * <p>
+ * Indicates if this feature is preferred.
+ * </p>
+ *
+ * @return <code>true</code> if preferred, <code>false</code> otherwise.
+ */
+ public boolean isPreferred() {
+ return preferred;
+ }
+
+ /**
+ * <p>
+ * Indicates if this feature is hidden.
+ * </p>
+ *
+ * @return <code>true</code> if hidden, <code>false</code> otherwise.
+ */
+ public boolean isHidden() {
+ return hidden;
+ }
+
+ /**
+ * <p>
+ * Indicates if this feature is an expert feature.
+ * </p>
+ *
+ * @return <code>true</code> if hidden, <code>false</code> otherwise.
+ */
+ public boolean isExpert() {
+ return expert;
+ }
+}
diff --git a/awt/java/beans/IndexedPropertyChangeEvent.java b/awt/java/beans/IndexedPropertyChangeEvent.java
new file mode 100644
index 0000000..c9084c6
--- /dev/null
+++ b/awt/java/beans/IndexedPropertyChangeEvent.java
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+/**
+ * A type of {@link PropertyChangeEvent} that indicates that an indexed property
+ * has changed.
+ *
+ * @since 1.5
+ */
+public class IndexedPropertyChangeEvent extends PropertyChangeEvent {
+
+ private static final long serialVersionUID = -320227448495806870L;
+
+ private final int index;
+
+ /**
+ * Creates a new property changed event with an indication of the property
+ * index.
+ *
+ * @param source
+ * the changed bean.
+ * @param propertyName
+ * the changed property, or <code>null</code> to indicate an
+ * unspecified set of the properties have changed.
+ * @param oldValue
+ * the previous value of the property, or <code>null</code> if
+ * the <code>propertyName</code> is <code>null</code> or the
+ * previous value is unknown.
+ * @param newValue
+ * the new value of the property, or <code>null</code> if the
+ * <code>propertyName</code> is <code>null</code> or the new
+ * value is unknown..
+ * @param index
+ * the index of the property.
+ */
+ public IndexedPropertyChangeEvent(Object source, String propertyName,
+ Object oldValue, Object newValue, int index) {
+ super(source, propertyName, oldValue, newValue);
+ this.index = index;
+ }
+
+ /**
+ * Answer the index of the property that was changed in this event.
+ *
+ * @return The property element index.
+ */
+ public int getIndex() {
+ return index;
+ }
+}
diff --git a/awt/java/beans/IndexedPropertyDescriptor.java b/awt/java/beans/IndexedPropertyDescriptor.java
new file mode 100644
index 0000000..25667d9
--- /dev/null
+++ b/awt/java/beans/IndexedPropertyDescriptor.java
@@ -0,0 +1,227 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import org.apache.harmony.beans.internal.nls.Messages;
+
+public class IndexedPropertyDescriptor extends PropertyDescriptor {
+ private Method indexedGetter;
+
+ private Method indexedSetter;
+
+ public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass,
+ String getterName, String setterName, String indexedGetterName,
+ String indexedSetterName) throws IntrospectionException {
+ super(propertyName, beanClass, getterName, setterName);
+
+ // RI behaves like this
+ if (indexedGetterName == null && indexedSetterName == null &&
+ (getterName != null || setterName != null)) {
+ throw new IntrospectionException(Messages.getString("beans.50"));
+ }
+ setIndexedReadMethod(beanClass, indexedGetterName);
+ setIndexedWriteMethod(beanClass, indexedSetterName);
+ }
+
+ public IndexedPropertyDescriptor(String propertyName, Method getter, Method setter,
+ Method indexedGetter, Method indexedSetter) throws IntrospectionException {
+ super(propertyName, getter, setter);
+
+ // we need this in order to be compatible with RI
+ if (indexedGetter == null && indexedSetter == null &&
+ (getter != null || setter != null)) {
+ throw new IntrospectionException(Messages.getString("beans.50"));
+ }
+ setIndexedReadMethod(indexedGetter);
+ setIndexedWriteMethod(indexedSetter);
+ }
+
+ public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass)
+ throws IntrospectionException {
+ super(propertyName, beanClass, null, null);
+ String getterName;
+ String setterName;
+ String indexedGetterName;
+ String indexedSetterName;
+
+ // array getter
+ getterName = createDefaultMethodName(propertyName, "get"); //$NON-NLS-1$
+ if (hasMethod(beanClass, getterName)) {
+ setReadMethod(beanClass, getterName);
+ }
+ // array setter
+ setterName = createDefaultMethodName(propertyName, "set"); //$NON-NLS-1$
+ if (hasMethod(beanClass, setterName)) {
+ setWriteMethod(beanClass, setterName);
+ }
+ // indexed getter
+ indexedGetterName = createDefaultMethodName(propertyName, "get"); //$NON-NLS-1$
+ if (hasMethod(beanClass, indexedGetterName)) {
+ setIndexedReadMethod(beanClass, indexedGetterName);
+ }
+ // indexed setter
+ indexedSetterName = createDefaultMethodName(propertyName, "set"); //$NON-NLS-1$
+ if (hasMethod(beanClass, indexedSetterName)) {
+ setIndexedWriteMethod(beanClass, indexedSetterName);
+ }
+ // RI seems to behave a bit differently
+ if (indexedGetter == null && indexedSetter == null &&
+ getReadMethod() == null && getWriteMethod() == null) {
+ throw new IntrospectionException(
+ Messages.getString("beans.01", propertyName)); //$NON-NLS-1$
+ }
+ if (indexedGetter == null && indexedSetter == null) {
+ // not an indexed property indeed
+ throw new IntrospectionException(Messages.getString("beans.50"));
+ }
+ }
+
+ public void setIndexedReadMethod(Method indexedGetter) throws IntrospectionException {
+ if (indexedGetter != null) {
+ int modifiers = indexedGetter.getModifiers();
+ Class<?>[] parameterTypes;
+ Class<?> returnType;
+ Class<?> indexedPropertyType;
+
+ if (!Modifier.isPublic(modifiers)) {
+ throw new IntrospectionException(Messages.getString("beans.21")); //$NON-NLS-1$
+ }
+ parameterTypes = indexedGetter.getParameterTypes();
+ if (parameterTypes.length != 1) {
+ throw new IntrospectionException(Messages.getString("beans.22")); //$NON-NLS-1$
+ }
+ if (!parameterTypes[0].equals(int.class)) {
+ throw new IntrospectionException(Messages.getString("beans.23")); //$NON-NLS-1$
+ }
+ returnType = indexedGetter.getReturnType();
+ indexedPropertyType = getIndexedPropertyType();
+ if ((indexedPropertyType != null) && !returnType.equals(indexedPropertyType)) {
+ throw new IntrospectionException(Messages.getString("beans.24")); //$NON-NLS-1$
+ }
+ }
+ this.indexedGetter = indexedGetter;
+ }
+
+ public void setIndexedWriteMethod(Method indexedSetter) throws IntrospectionException {
+ if (indexedSetter != null) {
+ int modifiers = indexedSetter.getModifiers();
+ Class<?>[] parameterTypes;
+ Class<?> firstParameterType;
+ Class<?> secondParameterType;
+ Class<?> propType;
+
+ if (!Modifier.isPublic(modifiers)) {
+ throw new IntrospectionException(Messages.getString("beans.25")); //$NON-NLS-1$
+ }
+ parameterTypes = indexedSetter.getParameterTypes();
+ if (parameterTypes.length != 2) {
+ throw new IntrospectionException(Messages.getString("beans.26")); //$NON-NLS-1$
+ }
+ firstParameterType = parameterTypes[0];
+ if (!firstParameterType.equals(int.class)) {
+ throw new IntrospectionException(Messages.getString("beans.27")); //$NON-NLS-1$
+ }
+ secondParameterType = parameterTypes[1];
+ propType = getIndexedPropertyType();
+ if (propType != null && !secondParameterType.equals(propType)) {
+ throw new IntrospectionException(Messages.getString("beans.28")); //$NON-NLS-1$
+ }
+ }
+ this.indexedSetter = indexedSetter;
+ }
+
+ public Method getIndexedWriteMethod() {
+ return indexedSetter;
+ }
+
+ public Method getIndexedReadMethod() {
+ return indexedGetter;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ boolean result = super.equals(obj);
+
+ if (result) {
+ IndexedPropertyDescriptor pd = (IndexedPropertyDescriptor) obj;
+
+ if (indexedGetter != null) {
+ result = indexedGetter.equals(pd.getIndexedReadMethod());
+ } else if (result && indexedGetter == null) {
+ result = pd.getIndexedReadMethod() == null;
+ }
+
+ if (result) {
+ if (indexedSetter != null) {
+ result = indexedSetter.equals(pd.getIndexedWriteMethod());
+ } else if (indexedSetter == null) {
+ result = pd.getIndexedWriteMethod() == null;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ public Class<?> getIndexedPropertyType() {
+ Class<?> result = null;
+
+ if (indexedGetter != null) {
+ result = indexedGetter.getReturnType();
+ } else if (indexedSetter != null) {
+ Class<?>[] parameterTypes = indexedSetter.getParameterTypes();
+
+ result = parameterTypes[1];
+ }
+ return result;
+ }
+
+ private void setIndexedReadMethod(Class<?> beanClass, String indexedGetterName) {
+ Method[] getters = findMethods(beanClass, indexedGetterName);
+ boolean result = false;
+
+ for (Method element : getters) {
+ try {
+ setIndexedReadMethod(element);
+ result = true;
+ } catch (IntrospectionException ie) {}
+
+ if (result) {
+ break;
+ }
+ }
+ }
+
+ private void setIndexedWriteMethod(Class<?> beanClass, String indexedSetterName) {
+ Method[] setters = findMethods(beanClass, indexedSetterName);
+ boolean result = false;
+
+ for (Method element : setters) {
+ try {
+ setIndexedWriteMethod(element);
+ result = true;
+ } catch (IntrospectionException ie) {}
+
+ if (result) {
+ break;
+ }
+ }
+ }
+}
diff --git a/awt/java/beans/IntrospectionException.java b/awt/java/beans/IntrospectionException.java
new file mode 100644
index 0000000..c895afe
--- /dev/null
+++ b/awt/java/beans/IntrospectionException.java
@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+public class IntrospectionException extends Exception {
+
+ static final long serialVersionUID = -3728150539969542619L;
+
+ public IntrospectionException(String message) {
+ super(message);
+ }
+}
diff --git a/awt/java/beans/PropertyChangeEvent.java b/awt/java/beans/PropertyChangeEvent.java
new file mode 100644
index 0000000..97c703a
--- /dev/null
+++ b/awt/java/beans/PropertyChangeEvent.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.util.EventObject;
+
+public class PropertyChangeEvent extends EventObject {
+
+ private static final long serialVersionUID = 7042693688939648123L;
+
+ String propertyName;
+
+ Object oldValue;
+
+ Object newValue;
+
+ Object propagationId;
+
+ public PropertyChangeEvent(Object source, String propertyName,
+ Object oldValue, Object newValue) {
+ super(source);
+
+ this.propertyName = propertyName;
+ this.oldValue = oldValue;
+ this.newValue = newValue;
+ }
+
+ public String getPropertyName() {
+ return propertyName;
+ }
+
+ public void setPropagationId(Object propagationId) {
+ this.propagationId = propagationId;
+ }
+
+ public Object getPropagationId() {
+ return propagationId;
+ }
+
+ public Object getOldValue() {
+ return oldValue;
+ }
+
+ public Object getNewValue() {
+ return newValue;
+ }
+}
diff --git a/awt/java/beans/PropertyChangeListener.java b/awt/java/beans/PropertyChangeListener.java
new file mode 100644
index 0000000..94422c0
--- /dev/null
+++ b/awt/java/beans/PropertyChangeListener.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.util.EventListener;
+
+public interface PropertyChangeListener extends EventListener {
+
+ public void propertyChange(PropertyChangeEvent event);
+}
diff --git a/awt/java/beans/PropertyChangeListenerProxy.java b/awt/java/beans/PropertyChangeListenerProxy.java
new file mode 100644
index 0000000..f4f3aec
--- /dev/null
+++ b/awt/java/beans/PropertyChangeListenerProxy.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.util.EventListenerProxy;
+
+public class PropertyChangeListenerProxy extends EventListenerProxy implements
+ PropertyChangeListener {
+
+ String propertyName;
+
+ public PropertyChangeListenerProxy(String propertyName,
+ PropertyChangeListener listener) {
+ super(listener);
+ this.propertyName = propertyName;
+ }
+
+ public String getPropertyName() {
+ return propertyName;
+ }
+
+ public void propertyChange(PropertyChangeEvent event) {
+ PropertyChangeListener listener = (PropertyChangeListener) getListener();
+ listener.propertyChange(event);
+ }
+}
diff --git a/awt/java/beans/PropertyChangeSupport.java b/awt/java/beans/PropertyChangeSupport.java
new file mode 100644
index 0000000..d56e63a
--- /dev/null
+++ b/awt/java/beans/PropertyChangeSupport.java
@@ -0,0 +1,351 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class PropertyChangeSupport implements Serializable {
+
+ private static final long serialVersionUID = 6401253773779951803l;
+
+ private transient Object sourceBean;
+
+ private transient List<PropertyChangeListener> allPropertiesChangeListeners =
+ new ArrayList<PropertyChangeListener>();
+
+ private transient Map<String, List<PropertyChangeListener>>
+ selectedPropertiesChangeListeners =
+ new HashMap<String, List<PropertyChangeListener>>();
+
+ // fields for serialization compatibility
+ private Hashtable<String, List<PropertyChangeListener>> children;
+
+ private Object source;
+
+ private int propertyChangeSupportSerializedDataVersion = 1;
+
+ public PropertyChangeSupport(Object sourceBean) {
+ if (sourceBean == null) {
+ throw new NullPointerException();
+ }
+ this.sourceBean = sourceBean;
+ }
+
+ public void firePropertyChange(String propertyName, Object oldValue,
+ Object newValue) {
+ PropertyChangeEvent event = createPropertyChangeEvent(propertyName,
+ oldValue, newValue);
+ doFirePropertyChange(event);
+ }
+
+ public void fireIndexedPropertyChange(String propertyName, int index,
+ Object oldValue, Object newValue) {
+
+ // nulls and equals check done in doFire...
+ doFirePropertyChange(new IndexedPropertyChangeEvent(sourceBean,
+ propertyName, oldValue, newValue, index));
+ }
+
+ public synchronized void removePropertyChangeListener(String propertyName,
+ PropertyChangeListener listener) {
+ if ((propertyName != null) && (listener != null)) {
+ List<PropertyChangeListener> listeners =
+ selectedPropertiesChangeListeners.get(propertyName);
+
+ if (listeners != null) {
+ listeners.remove(listener);
+ }
+ }
+ }
+
+ public synchronized void addPropertyChangeListener(String propertyName,
+ PropertyChangeListener listener) {
+ if ((listener != null) && (propertyName != null)) {
+ List<PropertyChangeListener> listeners =
+ selectedPropertiesChangeListeners.get(propertyName);
+
+ if (listeners == null) {
+ listeners = new ArrayList<PropertyChangeListener>();
+ selectedPropertiesChangeListeners.put(propertyName, listeners);
+ }
+
+ // RI compatibility
+ if (listener instanceof PropertyChangeListenerProxy) {
+ PropertyChangeListenerProxy proxy =
+ (PropertyChangeListenerProxy) listener;
+
+ listeners.add(new PropertyChangeListenerProxy(
+ proxy.getPropertyName(),
+ (PropertyChangeListener) proxy.getListener()));
+ } else {
+ listeners.add(listener);
+ }
+ }
+ }
+
+ public synchronized PropertyChangeListener[] getPropertyChangeListeners(
+ String propertyName) {
+ List<PropertyChangeListener> listeners = null;
+
+ if (propertyName != null) {
+ listeners = selectedPropertiesChangeListeners.get(propertyName);
+ }
+
+ return (listeners == null) ? new PropertyChangeListener[] {}
+ : listeners.toArray(
+ new PropertyChangeListener[listeners.size()]);
+ }
+
+ public void firePropertyChange(String propertyName, boolean oldValue,
+ boolean newValue) {
+ PropertyChangeEvent event = createPropertyChangeEvent(propertyName,
+ oldValue, newValue);
+ doFirePropertyChange(event);
+ }
+
+ public void fireIndexedPropertyChange(String propertyName, int index,
+ boolean oldValue, boolean newValue) {
+
+ if (oldValue != newValue) {
+ fireIndexedPropertyChange(propertyName, index, Boolean
+ .valueOf(oldValue), Boolean.valueOf(newValue));
+ }
+ }
+
+ public void firePropertyChange(String propertyName, int oldValue,
+ int newValue) {
+ PropertyChangeEvent event = createPropertyChangeEvent(propertyName,
+ oldValue, newValue);
+ doFirePropertyChange(event);
+ }
+
+ public void fireIndexedPropertyChange(String propertyName, int index,
+ int oldValue, int newValue) {
+
+ if (oldValue != newValue) {
+ fireIndexedPropertyChange(propertyName, index,
+ new Integer(oldValue), new Integer(newValue));
+ }
+ }
+
+ public synchronized boolean hasListeners(String propertyName) {
+ boolean result = allPropertiesChangeListeners.size() > 0;
+ if (!result && (propertyName != null)) {
+ List<PropertyChangeListener> listeners =
+ selectedPropertiesChangeListeners.get(propertyName);
+ if (listeners != null) {
+ result = listeners.size() > 0;
+ }
+ }
+ return result;
+ }
+
+ public synchronized void removePropertyChangeListener(
+ PropertyChangeListener listener) {
+ if (listener != null) {
+ if (listener instanceof PropertyChangeListenerProxy) {
+ String name = ((PropertyChangeListenerProxy) listener)
+ .getPropertyName();
+ PropertyChangeListener lst = (PropertyChangeListener)
+ ((PropertyChangeListenerProxy) listener).getListener();
+
+ removePropertyChangeListener(name, lst);
+ } else {
+ allPropertiesChangeListeners.remove(listener);
+ }
+ }
+ }
+
+ public synchronized void addPropertyChangeListener(
+ PropertyChangeListener listener) {
+ if (listener != null) {
+ if (listener instanceof PropertyChangeListenerProxy) {
+ String name = ((PropertyChangeListenerProxy) listener)
+ .getPropertyName();
+ PropertyChangeListener lst = (PropertyChangeListener)
+ ((PropertyChangeListenerProxy) listener).getListener();
+ addPropertyChangeListener(name, lst);
+ } else {
+ allPropertiesChangeListeners.add(listener);
+ }
+ }
+ }
+
+ public synchronized PropertyChangeListener[] getPropertyChangeListeners() {
+ ArrayList<PropertyChangeListener> result =
+ new ArrayList<PropertyChangeListener>(
+ allPropertiesChangeListeners);
+
+ for (String propertyName : selectedPropertiesChangeListeners.keySet()) {
+ List<PropertyChangeListener> selectedListeners =
+ selectedPropertiesChangeListeners.get(propertyName);
+
+ if (selectedListeners != null) {
+
+ for (PropertyChangeListener listener : selectedListeners) {
+ result.add(new PropertyChangeListenerProxy(propertyName,
+ listener));
+ }
+ }
+ }
+
+ return result.toArray(new PropertyChangeListener[result.size()]);
+ }
+
+ private void writeObject(ObjectOutputStream oos) throws IOException {
+ List<PropertyChangeListener> allSerializedPropertiesChangeListeners =
+ new ArrayList<PropertyChangeListener>();
+
+ for (PropertyChangeListener pcl : allPropertiesChangeListeners) {
+ if (pcl instanceof Serializable) {
+ allSerializedPropertiesChangeListeners.add(pcl);
+ }
+ }
+
+ Map<String, List<PropertyChangeListener>>
+ selectedSerializedPropertiesChangeListeners =
+ new HashMap<String, List<PropertyChangeListener>>();
+
+ for (String propertyName : selectedPropertiesChangeListeners.keySet()) {
+ List<PropertyChangeListener> keyValues =
+ selectedPropertiesChangeListeners.get(propertyName);
+
+ if (keyValues != null) {
+ List<PropertyChangeListener> serializedPropertiesChangeListeners
+ = new ArrayList<PropertyChangeListener>();
+
+ for (PropertyChangeListener pcl : keyValues) {
+ if (pcl instanceof Serializable) {
+ serializedPropertiesChangeListeners.add(pcl);
+ }
+ }
+
+ if (!serializedPropertiesChangeListeners.isEmpty()) {
+ selectedSerializedPropertiesChangeListeners.put(
+ propertyName, serializedPropertiesChangeListeners);
+ }
+ }
+ }
+
+ children = new Hashtable<String, List<PropertyChangeListener>>(
+ selectedSerializedPropertiesChangeListeners);
+ children.put("", allSerializedPropertiesChangeListeners); //$NON-NLS-1$
+ oos.writeObject(children);
+
+ Object source = null;
+ if (sourceBean instanceof Serializable) {
+ source = sourceBean;
+ }
+ oos.writeObject(source);
+
+ oos.writeInt(propertyChangeSupportSerializedDataVersion);
+ }
+
+ @SuppressWarnings("unchecked")
+ private void readObject(ObjectInputStream ois) throws IOException,
+ ClassNotFoundException {
+ children = (Hashtable<String, List<PropertyChangeListener>>) ois
+ .readObject();
+
+ selectedPropertiesChangeListeners = new HashMap<String, List<PropertyChangeListener>>(
+ children);
+ allPropertiesChangeListeners = selectedPropertiesChangeListeners
+ .remove(""); //$NON-NLS-1$
+ if (allPropertiesChangeListeners == null) {
+ allPropertiesChangeListeners = new ArrayList<PropertyChangeListener>();
+ }
+
+ sourceBean = ois.readObject();
+ propertyChangeSupportSerializedDataVersion = ois.readInt();
+ }
+
+ public void firePropertyChange(PropertyChangeEvent event) {
+ doFirePropertyChange(event);
+ }
+
+ private PropertyChangeEvent createPropertyChangeEvent(String propertyName,
+ Object oldValue, Object newValue) {
+ return new PropertyChangeEvent(sourceBean, propertyName, oldValue,
+ newValue);
+ }
+
+ private PropertyChangeEvent createPropertyChangeEvent(String propertyName,
+ boolean oldValue, boolean newValue) {
+ return new PropertyChangeEvent(sourceBean, propertyName, oldValue,
+ newValue);
+ }
+
+ private PropertyChangeEvent createPropertyChangeEvent(String propertyName,
+ int oldValue, int newValue) {
+ return new PropertyChangeEvent(sourceBean, propertyName, oldValue,
+ newValue);
+ }
+
+ private void doFirePropertyChange(PropertyChangeEvent event) {
+ String propertyName = event.getPropertyName();
+ Object oldValue = event.getOldValue();
+ Object newValue = event.getNewValue();
+
+ if ((newValue != null) && (oldValue != null)
+ && newValue.equals(oldValue)) {
+ return;
+ }
+
+ /*
+ * Copy the listeners collections so they can be modified while we fire
+ * events.
+ */
+
+ // Listeners to all property change events
+ PropertyChangeListener[] listensToAll;
+ // Listens to a given property change
+ PropertyChangeListener[] listensToOne = null;
+ synchronized (this) {
+ listensToAll = allPropertiesChangeListeners
+ .toArray(new PropertyChangeListener[allPropertiesChangeListeners
+ .size()]);
+
+ List<PropertyChangeListener> listeners = selectedPropertiesChangeListeners
+ .get(propertyName);
+ if (listeners != null) {
+ listensToOne = listeners
+ .toArray(new PropertyChangeListener[listeners.size()]);
+ }
+ }
+
+ // Fire the listeners
+ for (PropertyChangeListener listener : listensToAll) {
+ listener.propertyChange(event);
+ }
+ if (listensToOne != null) {
+ for (PropertyChangeListener listener : listensToOne) {
+ listener.propertyChange(event);
+ }
+ }
+ }
+
+}
diff --git a/awt/java/beans/PropertyDescriptor.java b/awt/java/beans/PropertyDescriptor.java
new file mode 100644
index 0000000..9389152
--- /dev/null
+++ b/awt/java/beans/PropertyDescriptor.java
@@ -0,0 +1,300 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Vector;
+import org.apache.harmony.beans.internal.nls.Messages;
+
+public class PropertyDescriptor extends FeatureDescriptor {
+ private Method getter;
+
+ private Method setter;
+
+ private Class<?> propertyEditorClass;
+
+ private boolean constrained;
+
+ private boolean bound;
+
+ public PropertyDescriptor(String propertyName, Class<?> beanClass, String getterName,
+ String setterName) throws IntrospectionException {
+ super();
+ if (beanClass == null) {
+ throw new IntrospectionException(Messages.getString("beans.03")); //$NON-NLS-1$
+ }
+ if (propertyName == null || propertyName.length() == 0) {
+ throw new IntrospectionException(Messages.getString("beans.04")); //$NON-NLS-1$
+ }
+ this.setName(propertyName);
+ this.setDisplayName(propertyName);
+ if (setterName != null) {
+ if (hasMethod(beanClass, setterName)) {
+ setWriteMethod(beanClass, setterName);
+ } else {
+ throw new IntrospectionException(Messages.getString("beans.20")); //$NON-NLS-1$
+ }
+ }
+ if (getterName != null) {
+ if (hasMethod(beanClass, getterName)) {
+ setReadMethod(beanClass, getterName);
+ } else {
+ throw new IntrospectionException(Messages.getString("beans.1F")); //$NON-NLS-1$
+ }
+ }
+ }
+
+ public PropertyDescriptor(String propertyName, Method getter, Method setter)
+ throws IntrospectionException {
+ super();
+ if (propertyName == null || propertyName.length() == 0) {
+ throw new IntrospectionException(Messages.getString("beans.04")); //$NON-NLS-1$
+ }
+ this.setName(propertyName);
+ this.setDisplayName(propertyName);
+ setWriteMethod(setter);
+ setReadMethod(getter);
+ }
+
+ public PropertyDescriptor(String propertyName, Class<?> beanClass)
+ throws IntrospectionException {
+ String getterName;
+ String setterName;
+ if (beanClass == null) {
+ throw new IntrospectionException(Messages.getString("beans.03")); //$NON-NLS-1$
+ }
+ if (propertyName == null || propertyName.length() == 0) {
+ throw new IntrospectionException(Messages.getString("beans.04")); //$NON-NLS-1$
+ }
+ this.setName(propertyName);
+ this.setDisplayName(propertyName);
+ getterName = createDefaultMethodName(propertyName, "is"); //$NON-NLS-1$
+ if (hasMethod(beanClass, getterName)) {
+ setReadMethod(beanClass, getterName);
+ } else {
+ getterName = createDefaultMethodName(propertyName, "get"); //$NON-NLS-1$
+ if (hasMethod(beanClass, getterName)) {
+ setReadMethod(beanClass, getterName);
+ }
+ }
+ setterName = createDefaultMethodName(propertyName, "set"); //$NON-NLS-1$
+ if (hasMethod(beanClass, setterName)) {
+ setWriteMethod(beanClass, setterName);
+ }
+ if (getter == null && setter == null) {
+ throw new IntrospectionException(Messages.getString("beans.01", propertyName)); //$NON-NLS-1$
+ }
+ }
+
+ public void setWriteMethod(Method setter) throws IntrospectionException {
+ if (setter != null) {
+ int modifiers = setter.getModifiers();
+ if (!Modifier.isPublic(modifiers)) {
+ throw new IntrospectionException(Messages.getString("beans.05")); //$NON-NLS-1$
+ }
+ Class<?>[] parameterTypes = setter.getParameterTypes();
+ if (parameterTypes.length != 1) {
+ throw new IntrospectionException(Messages.getString("beans.06")); //$NON-NLS-1$
+ }
+ Class<?> parameterType = parameterTypes[0];
+ Class<?> propertyType = getPropertyType();
+ if (propertyType != null && !propertyType.equals(parameterType)) {
+ throw new IntrospectionException(Messages.getString("beans.07")); //$NON-NLS-1$
+ }
+ }
+ this.setter = setter;
+ }
+
+ public void setReadMethod(Method getter) throws IntrospectionException {
+ if (getter != null) {
+ int modifiers = getter.getModifiers();
+ if (!Modifier.isPublic(modifiers)) {
+ throw new IntrospectionException(Messages.getString("beans.0A")); //$NON-NLS-1$
+ }
+ Class<?>[] parameterTypes = getter.getParameterTypes();
+ if (parameterTypes.length != 0) {
+ throw new IntrospectionException(Messages.getString("beans.08")); //$NON-NLS-1$
+ }
+ Class<?> returnType = getter.getReturnType();
+ if (returnType.equals(Void.TYPE)) {
+ throw new IntrospectionException(Messages.getString("beans.33")); //$NON-NLS-1$
+ }
+ Class<?> propertyType = getPropertyType();
+ if ((propertyType != null) && !returnType.equals(propertyType)) {
+ throw new IntrospectionException(Messages.getString("beans.09")); //$NON-NLS-1$
+ }
+ }
+ this.getter = getter;
+ }
+
+ public Method getWriteMethod() {
+ return setter;
+ }
+
+ public Method getReadMethod() {
+ return getter;
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ boolean result = (object != null && object instanceof PropertyDescriptor);
+ if (result) {
+ PropertyDescriptor pd = (PropertyDescriptor) object;
+ boolean gettersAreEqual = (this.getter == null) && (pd.getReadMethod() == null)
+ || (this.getter != null) && (this.getter.equals(pd.getReadMethod()));
+ boolean settersAreEqual = (this.setter == null) && (pd.getWriteMethod() == null)
+ || (this.setter != null) && (this.setter.equals(pd.getWriteMethod()));
+ boolean propertyTypesAreEqual = this.getPropertyType() == pd.getPropertyType();
+ boolean propertyEditorClassesAreEqual = this.getPropertyEditorClass() == pd
+ .getPropertyEditorClass();
+ boolean boundPropertyAreEqual = this.isBound() == pd.isBound();
+ boolean constrainedPropertyAreEqual = this.isConstrained() == pd.isConstrained();
+ result = gettersAreEqual && settersAreEqual && propertyTypesAreEqual
+ && propertyEditorClassesAreEqual && boundPropertyAreEqual
+ && constrainedPropertyAreEqual;
+ }
+ return result;
+ }
+
+ public void setPropertyEditorClass(Class<?> propertyEditorClass) {
+ this.propertyEditorClass = propertyEditorClass;
+ }
+
+ public Class<?> getPropertyType() {
+ Class<?> result = null;
+ if (getter != null) {
+ result = getter.getReturnType();
+ } else if (setter != null) {
+ Class<?>[] parameterTypes = setter.getParameterTypes();
+ result = parameterTypes[0];
+ }
+ return result;
+ }
+
+ public Class<?> getPropertyEditorClass() {
+ return propertyEditorClass;
+ }
+
+ public void setConstrained(boolean constrained) {
+ this.constrained = constrained;
+ }
+
+ public void setBound(boolean bound) {
+ this.bound = bound;
+ }
+
+ public boolean isConstrained() {
+ return constrained;
+ }
+
+ public boolean isBound() {
+ return bound;
+ }
+
+ boolean hasMethod(Class<?> beanClass, String methodName) {
+ Method[] methods = findMethods(beanClass, methodName);
+ return (methods.length > 0);
+ }
+
+ String createDefaultMethodName(String propertyName, String prefix) {
+ String result = null;
+ if (propertyName != null) {
+ String bos = propertyName.substring(0, 1).toUpperCase();
+ String eos = propertyName.substring(1, propertyName.length());
+ result = prefix + bos + eos;
+ }
+ return result;
+ }
+
+ Method[] findMethods(Class<?> aClass, String methodName) {
+ Method[] allMethods = aClass.getMethods();
+ Vector<Method> matchedMethods = new Vector<Method>();
+ Method[] result;
+ for (Method method : allMethods) {
+ if (method.getName().equals(methodName)) {
+ matchedMethods.add(method);
+ }
+ }
+ result = new Method[matchedMethods.size()];
+ for (int j = 0; j < matchedMethods.size(); ++j) {
+ result[j] = matchedMethods.elementAt(j);
+ }
+ return result;
+ }
+
+ void setReadMethod(Class<?> beanClass, String getterName) {
+ boolean result = false;
+ Method[] getters = findMethods(beanClass, getterName);
+ for (Method element : getters) {
+ try {
+ setReadMethod(element);
+ result = true;
+ } catch (IntrospectionException ie) {
+ }
+ if (result) {
+ break;
+ }
+ }
+ }
+
+ void setWriteMethod(Class<?> beanClass, String setterName) throws IntrospectionException {
+ boolean result = false;
+ Method[] setters = findMethods(beanClass, setterName);
+ for (Method element : setters) {
+ try {
+ setWriteMethod(element);
+ result = true;
+ } catch (IntrospectionException ie) {
+ }
+ if (result) {
+ break;
+ }
+ }
+ }
+
+ public PropertyEditor createPropertyEditor(Object bean) {
+ PropertyEditor editor;
+ if (propertyEditorClass == null) {
+ return null;
+ }
+ if (!PropertyEditor.class.isAssignableFrom(propertyEditorClass)) {
+ // beans.48=Property editor is not assignable from the
+ // PropertyEditor interface
+ throw new ClassCastException(Messages.getString("beans.48")); //$NON-NLS-1$
+ }
+ try {
+ Constructor<?> constr;
+ try {
+ // try to look for the constructor with single Object argument
+ constr = propertyEditorClass.getConstructor(Object.class);
+ editor = (PropertyEditor) constr.newInstance(bean);
+ } catch (NoSuchMethodException e) {
+ // try no-argument constructor
+ constr = propertyEditorClass.getConstructor();
+ editor = (PropertyEditor) constr.newInstance();
+ }
+ } catch (Exception e) {
+ // beans.47=Unable to instantiate property editor
+ RuntimeException re = new RuntimeException(Messages.getString("beans.47"), e); //$NON-NLS-1$
+ throw re;
+ }
+ return editor;
+ }
+}
diff --git a/awt/java/beans/PropertyEditor.java b/awt/java/beans/PropertyEditor.java
new file mode 100644
index 0000000..65bedea
--- /dev/null
+++ b/awt/java/beans/PropertyEditor.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.awt.Component;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+
+public interface PropertyEditor {
+
+ public void paintValue(Graphics gfx, Rectangle box);
+
+ public void setAsText(String text) throws IllegalArgumentException;
+
+ public String[] getTags();
+
+ public String getJavaInitializationString();
+
+ public String getAsText();
+
+ public void setValue(Object value);
+
+ public Object getValue();
+
+ public void removePropertyChangeListener(PropertyChangeListener listener);
+
+ public void addPropertyChangeListener(PropertyChangeListener listener);
+
+ public Component getCustomEditor();
+
+ public boolean supportsCustomEditor();
+
+ public boolean isPaintable();
+}
diff --git a/awt/java/beans/PropertyEditorManager.java b/awt/java/beans/PropertyEditorManager.java
new file mode 100644
index 0000000..ed55829
--- /dev/null
+++ b/awt/java/beans/PropertyEditorManager.java
@@ -0,0 +1,114 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class PropertyEditorManager {
+
+ private static String[] path = { "org.apache.harmony.beans.editors" }; //$NON-NLS-1$
+
+ private static final Map<Class<?>, Class<?>> registeredEditors = new HashMap<Class<?>, Class<?>>();
+
+ public PropertyEditorManager() {
+ }
+
+ public static void registerEditor(Class<?> targetType, Class<?> editorClass) {
+ if (targetType == null) {
+ throw new NullPointerException();
+ }
+
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ sm.checkPropertiesAccess();
+ }
+ if (editorClass != null) {
+ registeredEditors.put(targetType, editorClass);
+ } else {
+ registeredEditors.remove(targetType);
+ }
+ }
+
+ public static synchronized PropertyEditor findEditor(Class<?> targetType) {
+ if (targetType == null) {
+ throw new NullPointerException();
+ }
+
+ Class<?> editorClass = null;
+ PropertyEditor editor = null;
+
+ editorClass = registeredEditors.get(targetType);
+
+ if (editorClass == null) {
+ String editorClassName = targetType.getName() + "Editor"; //$NON-NLS-1$
+ ClassLoader loader = targetType.getClassLoader();
+
+ if (loader == null) {
+ loader = Thread.currentThread().getContextClassLoader();
+ }
+
+ try {
+ editorClass = Class.forName(editorClassName, true, loader);
+ } catch (ClassNotFoundException cnfe) {
+ String shortEditorClassName = editorClassName
+ .substring(editorClassName.lastIndexOf(".") + 1); //$NON-NLS-1$
+
+ if (targetType.isPrimitive()) {
+ shortEditorClassName = shortEditorClassName.substring(0, 1)
+ .toUpperCase()
+ + shortEditorClassName.substring(1);
+ }
+
+ for (String element : path) {
+ editorClassName = element + "." + shortEditorClassName; //$NON-NLS-1$
+
+ try {
+ editorClass = Class.forName(editorClassName, true,
+ loader);
+ break;
+ } catch (Exception e) {
+ }
+ }
+ } catch (Exception e) {
+ }
+ }
+
+ if (editorClass != null) {
+ try {
+ editor = (PropertyEditor) editorClass.newInstance();
+ } catch (Exception e) {
+ }
+ }
+
+ return editor;
+ }
+
+ public static synchronized void setEditorSearchPath(String[] apath) {
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ sm.checkPropertiesAccess();
+ }
+
+ path = apath;
+ }
+
+ public static synchronized String[] getEditorSearchPath() {
+ return path;
+ }
+}
diff --git a/awt/java/beans/PropertyEditorSupport.java b/awt/java/beans/PropertyEditorSupport.java
new file mode 100644
index 0000000..c3929a1
--- /dev/null
+++ b/awt/java/beans/PropertyEditorSupport.java
@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+import java.awt.Component;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.harmony.beans.internal.nls.Messages;
+
+public class PropertyEditorSupport implements PropertyEditor {
+
+ Object source = null;
+
+ List<PropertyChangeListener> listeners = new ArrayList<PropertyChangeListener>();
+
+ Object oldValue = null;
+
+ Object newValue = null;
+
+ public PropertyEditorSupport(Object source) {
+ if (source == null) {
+ throw new NullPointerException(Messages.getString("beans.0C")); //$NON-NLS-1$
+ }
+ this.source = source;
+ }
+
+ public PropertyEditorSupport() {
+ source = this;
+ }
+
+ public void paintValue(Graphics gfx, Rectangle box) {
+ }
+
+ public void setAsText(String text) throws IllegalArgumentException {
+ if (newValue instanceof String) {
+ setValue(text);
+ } else {
+ throw new IllegalArgumentException(text);
+ }
+ }
+
+ public String[] getTags() {
+ return null;
+ }
+
+ public String getJavaInitializationString() {
+ return "???"; //$NON-NLS-1$
+ }
+
+ public String getAsText() {
+ return newValue == null ? "null" : newValue.toString(); //$NON-NLS-1$
+ }
+
+ public void setValue(Object value) {
+ this.oldValue = this.newValue;
+ this.newValue = value;
+ firePropertyChange();
+ }
+
+ public Object getValue() {
+ return newValue;
+ }
+
+ public void setSource(Object source) {
+ if (source == null) {
+ throw new NullPointerException(Messages.getString("beans.0C")); //$NON-NLS-1$
+ }
+ this.source = source;
+ }
+
+ public Object getSource() {
+ return source;
+ }
+
+ public synchronized void removePropertyChangeListener(
+ PropertyChangeListener listener) {
+ if (listeners != null) {
+ listeners.remove(listener);
+ }
+ }
+
+ public synchronized void addPropertyChangeListener(
+ PropertyChangeListener listener) {
+ listeners.add(listener);
+ }
+
+ public Component getCustomEditor() {
+ return null;
+ }
+
+ public boolean supportsCustomEditor() {
+ return false;
+ }
+
+ public boolean isPaintable() {
+ return false;
+ }
+
+ public void firePropertyChange() {
+ if (listeners.size() > 0) {
+ PropertyChangeEvent event = new PropertyChangeEvent(source, null,
+ oldValue, newValue);
+ Iterator<PropertyChangeListener> iterator = listeners.iterator();
+
+ while (iterator.hasNext()) {
+ PropertyChangeListener listener = iterator.next();
+ listener.propertyChange(event);
+ }
+ }
+ }
+}
diff --git a/awt/java/beans/PropertyVetoException.java b/awt/java/beans/PropertyVetoException.java
new file mode 100644
index 0000000..c7f092a
--- /dev/null
+++ b/awt/java/beans/PropertyVetoException.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 java.beans;
+
+/**
+ * Indicates that a proposed property change is unacceptable.
+ */
+public class PropertyVetoException extends Exception {
+
+ private static final long serialVersionUID = 129596057694162164L;
+
+ private final PropertyChangeEvent evt;
+
+ /**
+ * <p>
+ * Constructs an instance with a message and the change event.
+ * </p>
+ *
+ * @param message
+ * A description of the veto.
+ * @param event
+ * The event that was vetoed.
+ */
+ public PropertyVetoException(String message, PropertyChangeEvent event) {
+ super(message);
+ this.evt = event;
+ }
+
+ /**
+ * <p>
+ * Gets the property change event.
+ * </p>
+ *
+ * @return An instance of {@link PropertyChangeEvent}
+ */
+ public PropertyChangeEvent getPropertyChangeEvent() {
+ return evt;
+ }
+}