toolkit/test/accessibility/EventQueue.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 import java.util.LinkedList;
  20
  21 /** The event queue singleton dispatches events received from OpenOffice.org
  22     applications in a thread separate from the AWB main thread.
  23
  24     The queue of event objects, LinkedList<Runnable> The queue object will
  25     also serve as lock for the consumer/producer type syncronization.
  26 */
  27 class EventQueue
  28     implements Runnable
  29 {
  30     public boolean mbVerbose = false;
  31     public boolean mbHandleDisposingEventsSynchronous = true;
  32
  33     public synchronized static EventQueue Instance ()
  34     {
  35         if (maInstance == null)
  36             maInstance = new EventQueue ();
  37         return maInstance;
  38     }
  39
  40     public void addEvent (Runnable aEvent)
  41     {
  42         synchronized (maMonitor)
  43         {
  44             if (mbVerbose)
  45                 System.out.println ("queing regular event " + aEvent);
  46             maRegularQueue.addLast (aEvent);
  47             maMonitor.notify ();
  48         }
  49     }
  50
  51
  52     public void addDisposingEvent (Runnable aEvent)
  53     {
  54         if (mbHandleDisposingEventsSynchronous)
  55             aEvent.run ();
  56         else
  57             synchronized (maMonitor)
  58             {
  59                 if (mbVerbose)
  60                     System.out.println ("queing disposing event " + aEvent);
  61                 maDisposingQueue.addLast (aEvent);
  62                 maMonitor.notify ();
  63             }
  64     }
  65
  66
  67     private EventQueue ()
  68     {
  69         maMonitor = new Boolean (true);
  70         maRegularQueue = new LinkedList<Runnable>();
  71         maDisposingQueue = new LinkedList<Runnable>();
  72         new Thread(this, "AWB.EventQueue").start();
  73     }
  74
  75
  76     /// This thread's main method: deliver all events
  77     public void run()
  78     {
  79         // in an infinite loop, check for events to deliver, then
  80         // wait on lock (which will be notified when new events arrive)
  81         while( true )
  82         {
  83             Runnable aEvent = null;
  84             do
  85             {
  86                 synchronized (maMonitor)
  87                 {
  88                     if (maDisposingQueue.size() > 0)
  89                     {
  90                         aEvent = maDisposingQueue.removeFirst();
  91                         if (mbVerbose)
  92                             System.out.println ("delivering disposing event " + aEvent);
  93                     }
  94                     else if (maRegularQueue.size() > 0)
  95                     {
  96                         aEvent = maRegularQueue.removeFirst();
  97                         if (mbVerbose)
  98                             System.out.println ("delivering regular event " + aEvent);
  99                     }
 100                     else
 101                         aEvent = null;
 102                 }
 103                 if (aEvent != null)
 104                 {
 105                     try
 106                     {
 107                         aEvent.run();
 108                     }
 109                     catch( Throwable e )
 110                     {
 111                         System.out.println(
 112                             "caught exception during event delivery: " + e );
 113                         e.printStackTrace();
 114                     }
 115                 }
 116             }
 117             while( aEvent != null );
 118
 119             try
 120             {
 121                 synchronized (maMonitor)
 122                 {
 123                     maMonitor.wait();
 124                 }
 125             }
 126             catch (Exception e)
 127             {
 128                 // can't wait? odd!
 129                 System.err.println("Can't wait!");
 130                 e.printStackTrace();
 131             }
 132         }
 133     }
 134
 135     private static EventQueue maInstance = null;
 136     private Object maMonitor;
 137     private LinkedList<Runnable> maRegularQueue;
 138     private LinkedList<Runnable> maDisposingQueue;
 139 }
 140
 141