INTEGRATION: CWS sdk02 (1.1.2); FILE ADDED

2003/05/21 16:14:43 af 1.1.2.2: #109790# Adaption to recent UAA changes.
2003/05/09 10:31:12 jsc 1.1.2.1: #109045# insert new and remove example zip file

odk/examples/DevelopersGuide/Accessibility/EventListenerProxy.java

+import com.sun.star.accessibility.XAccessible;
+import com.sun.star.accessibility.XAccessibleEventListener;
+import com.sun.star.accessibility.AccessibleEventObject;
+import com.sun.star.lang.EventObject;
+import com.sun.star.awt.XTopWindowListener;
+import com.sun.star.uno.UnoRuntime;
+
+import java.util.LinkedList;
+
+/** This class acts as a proxy for the simple screen reader.  It waits for
+    two types of events:
+    1. Accessibility events signal modifications concerning accessibility
+       objects.
+    2. Top window events inform the listener about new or removed windows.
+
+    This class exists because events had to be handled in a seperate thread
+    to avoid dead locks: The thread that receives an event must no call back
+    to the Office directly.
+
+    Soon this should not be necessary anymore.  There is now a flag which
+    switches between synchronous and asynchronous callbacks.
+
+    All reveived events are eventually forwarded to the actual listener.  In
+    this way it decouples the Office from the listener.
+*/
+class EventListenerProxy
+    implements Runnable, XAccessibleEventListener, XTopWindowListener
+{
+    public EventListenerProxy (EventHandler aListener)
+    {
+        maListener = aListener;
+        mbAsynchron = true;
+        if (mbAsynchron)
+        {
+            maEventQueue = new LinkedList();
+            new Thread (this, "EventListenerProxy").start();
+        }
+    }
+
+    private void addEvent (Runnable aEventObject)
+    {
+        if (mbAsynchron)
+            synchronized (maEventQueue)
+            {
+                maEventQueue.addLast (aEventObject);
+                // Tell the queue that there is a new event in the queue.
+                maEventQueue.notify();
+            }
+        else
+        {
+            System.out.println ("running " + aEventObject);
+            aEventObject.run();
+            System.out.println ("  done");
+        }
+    }
+
+
+
+
+    /** In an infinite loop, check for events to deliver, then wait on lock
+        (which will be notified when new events arrive)
+    */
+    public void run ()
+    {
+        while (true)
+        {
+            // Process all events that are currently in the queue.
+            Runnable aEvent;
+            do
+            {
+                synchronized (maEventQueue)
+                {
+                    if (maEventQueue.size() > 0)
+                        aEvent = (Runnable)maEventQueue.removeFirst();
+                    else
+                        aEvent = null;
+                }
+
+                if (aEvent != null)
+                {
+                    try
+                    {
+                        aEvent.run();
+                    }
+                    catch (Throwable aException)
+                    {
+                        MessageArea.println(
+                            "Exception during event delivery: " + aException);
+                        aException.printStackTrace();
+                    }
+                }
+            }
+            while (aEvent != null);
+
+            // Now that the queue is empty go to sleep again.
+            try
+            {
+                synchronized (maEventQueue)
+                {
+                    maEventQueue.wait();
+                }
+            }
+            catch (Exception aException)
+            {
+                // Ignore this exception since there is not much
+                // that we can do about it.
+            }
+        }
+    }
+
+
+    public void disposing( final EventObject aEvent)
+    {
+        addEvent (new Runnable()
+            {
+                public void run()
+                {
+                    maListener.disposing (aEvent);
+                }
+            } );
+    }
+
+    public void notifyEvent (final AccessibleEventObject aEvent)
+    {
+        addEvent (
+            new Runnable()
+            {
+                public void run()
+                {
+                    maListener.notifyEvent (aEvent);
+                }
+            } );
+    }
+
+    public void windowOpened (final com.sun.star.lang.EventObject aEvent)
+    {
+        addEvent (
+            new Runnable()
+            {
+                public void run()
+                {
+                    maListener.windowOpened (
+                        (XAccessible) UnoRuntime.queryInterface(
+                            XAccessible.class,
+                            aEvent.Source));
+                }
+            } );
+    }
+    public void windowClosing (final com.sun.star.lang.EventObject aEvent)
+    {
+        // Ignored.
+    }
+    public void windowClosed (final com.sun.star.lang.EventObject aEvent)
+    {
+        addEvent (
+            new Runnable()
+            {
+                public void run()
+                {
+                    maListener.windowClosed (
+                        (XAccessible) UnoRuntime.queryInterface(
+                            XAccessible.class,
+                            aEvent.Source));
+                }
+                } );
+    }
+    public void windowMinimized (com.sun.star.lang.EventObject aEvent)
+    {
+        // Ignored.
+    }
+    public void windowNormalized (com.sun.star.lang.EventObject aEvent)
+    {
+        // Ignored.
+    }
+    public void windowActivated (com.sun.star.lang.EventObject aEvent)
+    {
+        // Ignored.
+    }
+    public void windowDeactivated (com.sun.star.lang.EventObject aEvent)
+    {
+        // Ignored.
+    }
+
+    /** The queue of event objects, LinkedList<Runnable>.
+        The queue object will also serve as lock for the consumer/producer type
+        syncronization.
+    */
+    private LinkedList maEventQueue;
+
+    /** This is the actual listener that the events will eventually forwarded to.
+    */
+    private EventHandler maListener;
+
+    /** This flag determines whether event forwarding is done asynchroniously
+        or synchroniously.
+    */
+    private boolean mbAsynchron;
+}

odk/examples/DevelopersGuide/Accessibility/GraphicalDisplay.java

+import javax.swing.*;
+import java.awt.Dimension;
+import java.awt.*;
+import java.awt.geom.*;
+
+import com.sun.star.accessibility.XAccessible;
+import com.sun.star.accessibility.XAccessibleContext;
+import com.sun.star.accessibility.XAccessibleComponent;
+
+import com.sun.star.awt.Point;
+import com.sun.star.awt.Size;
+import com.sun.star.uno.UnoRuntime;
+
+
+/** Display the currently focused accessible object graphically.
+*/
+public class GraphicalDisplay
+    extends JPanel
+    implements IAccessibleObjectDisplay
+{
+    /** Create a new graphical widget the displays some of the geometrical
+        information availbable from accessible objects.
+    */
+    public GraphicalDisplay ()
+    {
+        setPreferredSize (new Dimension (300,200));
+    }
+
+
+    /** Paint some or all of the area of this widget with the outlines of
+        the currently focues object and its ancestors.
+     */
+    public synchronized void paintComponent (Graphics g)
+    {
+        super.paintComponent (g);
+
+        setupTransformation ();
+
+        // Draw the screen representation to give a hint of the location of the
+        // accessible object on the screen.
+        Dimension aScreenSize = Toolkit.getDefaultToolkit().getScreenSize();
+        // Fill the screen rectangle.
+        g.setColor (new Color (250,240,230));
+        g.fillRect (
+            (int)(mnHOffset+0.5),
+            (int)(mnVOffset+0.5),
+            (int)(mnScale*aScreenSize.getWidth()),
+            (int)(mnScale*aScreenSize.getHeight()));
+        // Draw a frame arround the screen rectangle to increase its visibility.
+        g.setColor (Color.BLACK);
+        g.drawRect (
+            (int)(mnHOffset+0.5),
+            (int)(mnVOffset+0.5),
+            (int)(mnScale*aScreenSize.getWidth()),
+            (int)(mnScale*aScreenSize.getHeight()));
+
+        // Now do the actual display of the accessible object.
+        drawAccessibleObject (g, mxContext, Color.GREEN);
+    }
+    public synchronized void paintChildren (Graphics g)
+    {
+    }
+    public synchronized void paintBorder (Graphics g)
+    {
+    }
+
+
+
+
+    /** Draw a simple representation of the given accessible object in the
+        specified color.
+    */
+    public void drawAccessibleObject (Graphics g, XAccessibleContext xContext, Color aColor)
+    {
+        if (xContext != null)
+        {
+            // First draw our parent.
+            XAccessible xParent = xContext.getAccessibleParent();
+            if (xParent != null)
+                drawAccessibleObject (g, xParent.getAccessibleContext(), Color.GRAY);
+
+            // When the context supports the XAccessibleComponent interface
+            // then draw its outline.
+            XAccessibleComponent xComponent =
+                (XAccessibleComponent)UnoRuntime.queryInterface(
+                    XAccessibleComponent.class, xContext);
+            if (xComponent != null)
+            {
+                // Get size and location on screen and transform them to fit
+                // everything inside this widget.
+                Point aLocation = xComponent.getLocationOnScreen();
+                Size aSize = xComponent.getSize();
+                g.setColor (aColor);
+                g.drawRect (
+                    (int)(mnHOffset + mnScale*aLocation.X+0.5),
+                    (int)(mnVOffset + mnScale*aLocation.Y+0.5),
+                    (int)(mnScale*aSize.Width),
+                    (int)(mnScale*aSize.Height));
+            }
+        }
+    }
+
+
+    public synchronized void setAccessibleObject (XAccessibleContext xContext)
+    {
+        mxContext = xContext;
+        repaint ();
+    }
+
+    public synchronized void updateAccessibleObject (XAccessibleContext xContext)
+    {
+        repaint ();
+    }
+
+
+    /** Set up the transformation so that the graphical display can show a
+        centered representation of the whole screen.
+    */
+    private void setupTransformation ()
+    {
+        Dimension aScreenSize = Toolkit.getDefaultToolkit().getScreenSize();
+        Dimension aWidgetSize = getSize();
+        if ((aScreenSize.getWidth() > 0) && (aScreenSize.getHeight() > 0))
+        {
+            // Calculate the scales that would map the screen onto the
+            // widget in both of the coordinate axes and select the smaller
+            // of the two: it maps the screen onto the widget in both axes
+            // at the same time.
+            double nHScale = (aWidgetSize.getWidth() - 10) / aScreenSize.getWidth();
+            double nVScale = (aWidgetSize.getHeight() - 10) / aScreenSize.getHeight();
+            if (nHScale < nVScale)
+                mnScale = nHScale;
+            else
+                mnScale = nVScale;
+
+            // Calculate offsets that center the scaled screen inside the widget.
+            mnHOffset = (aWidgetSize.getWidth() - mnScale*aScreenSize.getWidth()) / 2.0;
+            mnVOffset = (aWidgetSize.getHeight() - mnScale*aScreenSize.getHeight()) / 2.0;
+        }
+        else
+        {
+            // In case of a degenerate (not yet initialized?) screen size
+            // use some meaningless default values.
+            mnScale = 1;
+            mnHOffset = 0;
+            mnVOffset = 0;
+        }
+    }
+
+
+    private XAccessibleContext mxContext;
+    private double mnScale;
+    private double mnHOffset;
+    private double mnVOffset;
+}