1 /*
   2  * Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /*
  27  * The Toolkit class has two functions: it instantiates the AWT
  28  * ToolkitPeer's native methods, and provides the DLL's core functions.
  29  *
  30  * There are two ways this DLL can be used: either as a dynamically-
  31  * loaded Java native library from the interpreter, or by a Windows-
  32  * specific app.  The first manner requires that the Toolkit provide
  33  * all support needed so the app can function as a first-class Windows
  34  * app, while the second assumes that the app will provide that
  35  * functionality.  Which mode this DLL functions in is determined by
  36  * which initialization paradigm is used. If the Toolkit is constructed
  37  * normally, then the Toolkit will have its own pump. If it is explicitly
  38  * initialized for an embedded environment (via a static method on
  39  * sun.awt.windows.WToolkit), then it will rely on an external message
  40  * pump.
  41  *
  42  * The most basic functionality needed is a Windows message pump (also
  43  * known as a message loop).  When an Java app is started as a console
  44  * app by the interpreter, the Toolkit needs to provide that message
  45  * pump if the AWT is dynamically loaded.
  46  */
  47 
  48 #ifndef AWT_TOOLKIT_H
  49 #define AWT_TOOLKIT_H
  50 
  51 #include "awt.h"
  52 #include "awtmsg.h"
  53 #include "Trace.h"
  54 
  55 #include "sun_awt_windows_WToolkit.h"
  56 
  57 class AwtObject;
  58 class AwtDialog;
  59 class AwtDropTarget;
  60 
  61 typedef VOID (CALLBACK* IDLEPROC)(VOID);
  62 typedef BOOL (CALLBACK* PEEKMESSAGEPROC)(MSG&);
  63 
  64 // Struct for _WInputMethod_enable|disableNativeIME method
  65 struct EnableNativeIMEStruct {
  66     jobject self;
  67     jobject peer;
  68     jint context;
  69     jboolean useNativeCompWindow;
  70 };
  71 
  72 /*
  73  * class JNILocalFrame
  74  * Push/PopLocalFrame helper
  75  */
  76 class JNILocalFrame {
  77   public:
  78     INLINE JNILocalFrame(JNIEnv *env, int size) {
  79         m_env = env;
  80         int result = m_env->PushLocalFrame(size);
  81         if (result < 0) {
  82             DASSERT(FALSE);
  83             throw std::bad_alloc();
  84         }
  85     }
  86     INLINE ~JNILocalFrame() { m_env->PopLocalFrame(NULL); }
  87   private:
  88     JNIEnv* m_env;
  89 };
  90 
  91 /*
  92  * class CriticalSection
  93  * ~~~~~ ~~~~~~~~~~~~~~~~
  94  * Lightweight intra-process thread synchronization. Can only be used with
  95  * other critical sections, and only within the same process.
  96  */
  97 class CriticalSection {
  98   public:
  99     INLINE  CriticalSection() { ::InitializeCriticalSection(&rep); }
 100     INLINE ~CriticalSection() { ::DeleteCriticalSection(&rep); }
 101 
 102     class Lock {
 103       public:
 104         INLINE Lock(const CriticalSection& cs) : critSec(cs) {
 105             (const_cast<CriticalSection &>(critSec)).Enter();
 106         }
 107         INLINE ~Lock() {
 108             (const_cast<CriticalSection &>(critSec)).Leave();
 109         }
 110       private:
 111         const CriticalSection& critSec;
 112     };
 113     friend class Lock;
 114 
 115   private:
 116     CRITICAL_SECTION rep;
 117 
 118     CriticalSection(const CriticalSection&);
 119     const CriticalSection& operator =(const CriticalSection&);
 120 
 121   public:
 122     virtual void Enter() {
 123         ::EnterCriticalSection(&rep);
 124     }
 125     virtual BOOL TryEnter() {
 126         return ::TryEnterCriticalSection(&rep);
 127     }
 128     virtual void Leave() {
 129         ::LeaveCriticalSection(&rep);
 130     }
 131 };
 132 
 133 // Macros for using CriticalSection objects that help trace
 134 // lock/unlock actions
 135 
 136 /* Use THIS_FILE when it is available. */
 137 #ifndef THIS_FILE
 138     #define THIS_FILE __FILE__
 139 #endif
 140 
 141 #define CRITICAL_SECTION_ENTER(cs) { \
 142     J2dTraceLn4(J2D_TRACE_VERBOSE2, \
 143                 "CS.Wait:  tid, cs, file, line = 0x%x, 0x%x, %s, %d", \
 144                 GetCurrentThreadId(), &(cs), THIS_FILE, __LINE__); \
 145     (cs).Enter(); \
 146     J2dTraceLn4(J2D_TRACE_VERBOSE2, \
 147                 "CS.Enter: tid, cs, file, line = 0x%x, 0x%x, %s, %d", \
 148                 GetCurrentThreadId(), &(cs), THIS_FILE, __LINE__); \
 149 }
 150 
 151 #define CRITICAL_SECTION_LEAVE(cs) { \
 152     J2dTraceLn4(J2D_TRACE_VERBOSE2, \
 153                 "CS.Leave: tid, cs, file, line = 0x%x, 0x%x, %s, %d", \
 154                 GetCurrentThreadId(), &(cs), THIS_FILE, __LINE__); \
 155     (cs).Leave(); \
 156     J2dTraceLn4(J2D_TRACE_VERBOSE2, \
 157                 "CS.Left:  tid, cs, file, line = 0x%x, 0x%x, %s, %d", \
 158                 GetCurrentThreadId(), &(cs), THIS_FILE, __LINE__); \
 159 }
 160 
 161 // Redefine WinAPI values related to touch input, if OS < Windows 7.
 162 #if (!defined(WINVER) || ((WINVER) < 0x0601))
 163     /*
 164      * RegisterTouchWindow flag values
 165      */
 166     #define TWF_FINETOUCH       (0x00000001)
 167     #define TWF_WANTPALM        (0x00000002)
 168 
 169     #define WM_TOUCH                        0x0240
 170 
 171     /*
 172      * Touch input handle
 173      */
 174     typedef HANDLE HTOUCHINPUT;
 175 
 176     typedef struct tagTOUCHINPUT {
 177         LONG x;
 178         LONG y;
 179         HANDLE hSource;
 180         DWORD dwID;
 181         DWORD dwFlags;
 182         DWORD dwMask;
 183         DWORD dwTime;
 184         ULONG_PTR dwExtraInfo;
 185         DWORD cxContact;
 186         DWORD cyContact;
 187     } TOUCHINPUT, *PTOUCHINPUT;
 188     typedef TOUCHINPUT const * PCTOUCHINPUT;
 189 
 190     /*
 191      * Touch input flag values (TOUCHINPUT.dwFlags)
 192      */
 193     #define TOUCHEVENTF_MOVE            0x0001
 194     #define TOUCHEVENTF_DOWN            0x0002
 195     #define TOUCHEVENTF_UP              0x0004
 196     #define TOUCHEVENTF_INRANGE         0x0008
 197     #define TOUCHEVENTF_PRIMARY         0x0010
 198     #define TOUCHEVENTF_NOCOALESCE      0x0020
 199     #define TOUCHEVENTF_PEN             0x0040
 200     #define TOUCHEVENTF_PALM            0x0080
 201 #endif
 202 
 203 /************************************************************************
 204  * AwtToolkit class
 205  */
 206 
 207 class AwtToolkit {
 208 public:
 209     enum {
 210         KB_STATE_SIZE = 256
 211     };
 212 
 213     /* java.awt.Toolkit method ids */
 214     static jmethodID getDefaultToolkitMID;
 215     static jmethodID getFontMetricsMID;
 216         static jmethodID insetsMID;
 217 
 218     /* sun.awt.windows.WToolkit ids */
 219     static jmethodID windowsSettingChangeMID;
 220     static jmethodID displayChangeMID;
 221 
 222     BOOL m_isDynamicLayoutSet;
 223 
 224     AwtToolkit();
 225     ~AwtToolkit();
 226 
 227     BOOL Initialize(BOOL localPump);
 228     BOOL Dispose();
 229 
 230     void SetDynamicLayout(BOOL dynamic);
 231     BOOL IsDynamicLayoutSet();
 232     BOOL IsDynamicLayoutSupported();
 233     BOOL IsDynamicLayoutActive();
 234     BOOL areExtraMouseButtonsEnabled();
 235     void setExtraMouseButtonsEnabled(BOOL enable);
 236     static UINT GetNumberOfButtons();
 237 
 238     bool IsWin8OrLater();
 239     bool IsTouchKeyboardAutoShowEnabled();
 240     bool IsAnyKeyboardAttached();
 241     bool IsTouchKeyboardAutoShowSystemEnabled();
 242     void ShowTouchKeyboard();
 243     void HideTouchKeyboard();
 244     BOOL TIRegisterTouchWindow(HWND hWnd, ULONG ulFlags);
 245     BOOL TIGetTouchInputInfo(HTOUCHINPUT hTouchInput,
 246         UINT cInputs, PTOUCHINPUT pInputs, int cbSize);
 247     BOOL TICloseTouchInputHandle(HTOUCHINPUT hTouchInput);
 248 
 249     INLINE BOOL localPump() { return m_localPump; }
 250     INLINE BOOL VerifyComponents() { return FALSE; } // TODO: Use new DebugHelper class to set this flag
 251     INLINE HWND GetHWnd() { return m_toolkitHWnd; }
 252 
 253     INLINE HMODULE GetModuleHandle() { return m_dllHandle; }
 254     INLINE void SetModuleHandle(HMODULE h) { m_dllHandle = h; }
 255 
 256     INLINE static DWORD MainThread() { return GetInstance().m_mainThreadId; }
 257     INLINE void VerifyActive() throw (awt_toolkit_shutdown) {
 258         if (!m_isActive && m_mainThreadId != ::GetCurrentThreadId()) {
 259             throw awt_toolkit_shutdown();
 260         }
 261     }
 262     INLINE BOOL IsDisposed() { return m_isDisposed; }
 263     static UINT GetMouseKeyState();
 264     static void GetKeyboardState(PBYTE keyboardState);
 265 
 266     static ATOM RegisterClass();
 267     static void UnregisterClass();
 268     INLINE LRESULT SendMessage(UINT msg, WPARAM wParam=0, LPARAM lParam=0) {
 269         if (!m_isDisposed) {
 270             return ::SendMessage(GetHWnd(), msg, wParam, lParam);
 271         } else {
 272             return NULL;
 273         }
 274     }
 275     static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam,
 276                                     LPARAM lParam);
 277     static LRESULT CALLBACK GetMessageFilter(int code, WPARAM wParam,
 278                                              LPARAM lParam);
 279     static LRESULT CALLBACK ForegroundIdleFilter(int code, WPARAM wParam,
 280                                                  LPARAM lParam);
 281     static LRESULT CALLBACK MouseLowLevelHook(int code, WPARAM wParam,
 282             LPARAM lParam);
 283 
 284     INLINE static AwtToolkit& GetInstance() { return theInstance; }
 285     INLINE void SetPeer(JNIEnv *env, jobject wToolkit) {
 286         AwtToolkit &tk = AwtToolkit::GetInstance();
 287         if (tk.m_peer != NULL) {
 288             env->DeleteGlobalRef(tk.m_peer);
 289         }
 290         tk.m_peer = (wToolkit != NULL) ? env->NewGlobalRef(wToolkit) : NULL;
 291     }
 292 
 293     INLINE jobject GetPeer() {
 294         return m_peer;
 295     }
 296 
 297     // is this thread the main thread?
 298 
 299     INLINE static BOOL IsMainThread() {
 300         return GetInstance().m_mainThreadId == ::GetCurrentThreadId();
 301     }
 302 
 303     // post a message to the message pump thread
 304 
 305     INLINE BOOL PostMessage(UINT msg, WPARAM wp=0, LPARAM lp=0) {
 306         return ::PostMessage(GetHWnd(), msg, wp, lp);
 307     }
 308 
 309     // cause the message pump thread to call the function synchronously now!
 310 
 311     INLINE void * InvokeFunction(void*(*ftn)(void)) {
 312         return (void *)SendMessage(WM_AWT_INVOKE_VOID_METHOD, (WPARAM)ftn, 0);
 313     }
 314     INLINE void InvokeFunction(void (*ftn)(void)) {
 315         InvokeFunction((void*(*)(void))ftn);
 316     }
 317     INLINE void * InvokeFunction(void*(*ftn)(void *), void* param) {
 318         return (void *)SendMessage(WM_AWT_INVOKE_METHOD, (WPARAM)ftn,
 319                                    (LPARAM)param);
 320     }
 321     INLINE void InvokeFunction(void (*ftn)(void *), void* param) {
 322         InvokeFunction((void*(*)(void*))ftn, param);
 323     }
 324 
 325     INLINE CriticalSection &GetSyncCS() { return m_Sync; }
 326 
 327     void *SyncCall(void*(*ftn)(void *), void* param);
 328     void SyncCall(void (*ftn)(void *), void *param);
 329     void *SyncCall(void *(*ftn)(void));
 330     void SyncCall(void (*ftn)(void));
 331 
 332     // cause the message pump thread to call the function later ...
 333 
 334     INLINE void InvokeFunctionLater(void (*ftn)(void *), void* param) {
 335         if (!PostMessage(WM_AWT_INVOKE_METHOD, (WPARAM)ftn, (LPARAM)param)) {
 336             JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 337             JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
 338         }
 339     }
 340 
 341    // cause the message pump thread to synchronously synchronize on the handle
 342 
 343     INLINE void WaitForSingleObject(HANDLE handle) {
 344         SendMessage(WM_AWT_WAIT_FOR_SINGLE_OBJECT, 0, (LPARAM)handle);
 345     }
 346 
 347     /*
 348      * Create an AwtXxxx C++ component using a given factory
 349      */
 350     typedef void (*ComponentFactory)(void*, void*);
 351     static void CreateComponent(void* hComponent, void* hParent,
 352                                 ComponentFactory compFactory, BOOL isParentALocalReference=TRUE);
 353 
 354     static void DestroyComponentHWND(HWND hwnd);
 355 
 356     // constants used to PostQuitMessage
 357 
 358     static const int EXIT_ENCLOSING_LOOP;
 359     static const int EXIT_ALL_ENCLOSING_LOOPS;
 360 
 361     // ...
 362 
 363     void QuitMessageLoop(int status);
 364 
 365     UINT MessageLoop(IDLEPROC lpIdleFunc, PEEKMESSAGEPROC lpPeekMessageFunc);
 366     BOOL PumpWaitingMessages(PEEKMESSAGEPROC lpPeekMessageFunc);
 367     void PumpToDestroy(class AwtComponent* p);
 368     void ProcessMsg(MSG& msg);
 369     BOOL PreProcessMsg(MSG& msg);
 370     BOOL PreProcessMouseMsg(class AwtComponent* p, MSG& msg);
 371     BOOL PreProcessKeyMsg(class AwtComponent* p, MSG& msg);
 372 
 373     /* Create an ID which maps to an AwtObject pointer, such as a menu. */
 374     UINT CreateCmdID(AwtObject* object);
 375 
 376     // removes cmd id mapping
 377     void RemoveCmdID(UINT id);
 378 
 379     /* Return the AwtObject associated with its ID. */
 380     AwtObject* LookupCmdID(UINT id);
 381 
 382     /* Return the current application icon. */
 383     HICON GetAwtIcon();
 384     HICON GetAwtIconSm();
 385 
 386     // Calculate a wave-like value out of the integer 'value' and
 387     // the specified period.
 388     // The argument 'value' is an integer 0, 1, 2, ... *infinity*.
 389     //
 390     // Examples:
 391     //    Period == 3
 392     //    Generated sequence: 0 1 2 1 0 .....
 393     //
 394     //    Period == 4
 395     //    Generated sequence: 0 1 2 3 2 1 0 .....
 396     static inline UINT CalculateWave(UINT value, const UINT period) {
 397         if (period < 2) {
 398             return 0;
 399         }
 400         // -2 is necessary to avoid repeating extreme values (0 and period-1)
 401         value %= period * 2 -2;
 402         if (value >= period) {
 403             value = period * 2 -2 - value;
 404         }
 405         return value;
 406     }
 407 
 408     HICON GetSecurityWarningIcon(UINT index, UINT w, UINT h);
 409 
 410     /* Turns on/off dialog modality for the system. */
 411     INLINE AwtDialog* SetModal(AwtDialog* frame) {
 412         AwtDialog* previousDialog = m_pModalDialog;
 413         m_pModalDialog = frame;
 414         return previousDialog;
 415     };
 416     INLINE void ResetModal(AwtDialog* oldFrame) { m_pModalDialog = oldFrame; };
 417     INLINE BOOL IsModal() { return (m_pModalDialog != NULL); };
 418     INLINE AwtDialog* GetModalDialog(void) { return m_pModalDialog; };
 419 
 420     /* Stops the current message pump (normally a modal dialog pump) */
 421     INLINE void StopMessagePump() { m_breakOnError = TRUE; }
 422 
 423     /* Debug settings */
 424     INLINE void SetVerbose(long flag)   { m_verbose = (flag != 0); }
 425     INLINE void SetVerify(long flag)    { m_verifyComponents = (flag != 0); }
 426     INLINE void SetBreak(long flag)     { m_breakOnError = (flag != 0); }
 427     INLINE void SetHeapCheck(long flag);
 428 
 429     static void SetBusy(BOOL busy);
 430 
 431     /* Set and get the default input method Window handler. */
 432     INLINE void SetInputMethodWindow(HWND inputMethodHWnd) { m_inputMethodHWnd = inputMethodHWnd; }
 433     INLINE HWND GetInputMethodWindow() { return m_inputMethodHWnd; }
 434 
 435     static VOID CALLBACK PrimaryIdleFunc();
 436     static VOID CALLBACK SecondaryIdleFunc();
 437     static BOOL CALLBACK CommonPeekMessageFunc(MSG& msg);
 438     static BOOL activateKeyboardLayout(HKL hkl);
 439 
 440     HANDLE m_waitEvent;
 441     DWORD eventNumber;
 442 private:
 443     HWND CreateToolkitWnd(LPCTSTR name);
 444 
 445     void InitTouchKeyboardExeFilePath();
 446     HWND GetTouchKeyboardWindow();
 447 
 448     BOOL m_localPump;
 449     DWORD m_mainThreadId;
 450     HWND m_toolkitHWnd;
 451     HWND m_inputMethodHWnd;
 452     BOOL m_verbose;
 453     BOOL m_isActive; // set to FALSE at beginning of Dispose
 454     BOOL m_isDisposed; // set to TRUE at end of Dispose
 455     BOOL m_areExtraMouseButtonsEnabled;
 456 
 457     typedef BOOL (WINAPI *RegisterTouchWindowFunc)(HWND hWnd, ULONG ulFlags);
 458     typedef BOOL (WINAPI *GetTouchInputInfoFunc)(HTOUCHINPUT hTouchInput,
 459         UINT cInputs, PTOUCHINPUT pInputs, int cbSize);
 460     typedef BOOL (WINAPI *CloseTouchInputHandleFunc)(HTOUCHINPUT hTouchInput);
 461     
 462     BOOL m_isWin8OrLater;
 463     BOOL m_touchKbrdAutoShowIsEnabled;
 464     TCHAR* m_touchKbrdExeFilePath;
 465     RegisterTouchWindowFunc m_pRegisterTouchWindow;
 466     GetTouchInputInfoFunc m_pGetTouchInputInfo;
 467     CloseTouchInputHandleFunc m_pCloseTouchInputHandle;
 468 
 469     BOOL m_vmSignalled; // set to TRUE if QUERYENDSESSION has successfully
 470                         // raised SIGTERM
 471 
 472     BOOL m_verifyComponents;
 473     BOOL m_breakOnError;
 474 
 475     BOOL  m_breakMessageLoop;
 476     UINT  m_messageLoopResult;
 477 
 478     class AwtComponent* m_lastMouseOver;
 479     BOOL                m_mouseDown;
 480 
 481     HHOOK m_hGetMessageHook;
 482     HHOOK m_hMouseLLHook;
 483     UINT_PTR  m_timer;
 484 
 485     class AwtCmdIDList* m_cmdIDs;
 486     BYTE                m_lastKeyboardState[KB_STATE_SIZE];
 487     CriticalSection     m_lockKB;
 488 
 489     static AwtToolkit theInstance;
 490 
 491     /* The current modal dialog frame (normally NULL). */
 492     AwtDialog* m_pModalDialog;
 493 
 494     /* The WToolkit peer instance */
 495     jobject m_peer;
 496 
 497     HMODULE m_dllHandle;  /* The module handle. */
 498 
 499     CriticalSection m_Sync;
 500 
 501 /* track display changes - used by palette-updating code.
 502    This is a workaround for a windows bug that prevents
 503    WM_PALETTECHANGED event from occurring immediately after
 504    a WM_DISPLAYCHANGED event.
 505   */
 506 private:
 507     BOOL m_displayChanged;  /* Tracks displayChanged events */
 508     // 0 means we are not embedded.
 509     DWORD m_embedderProcessID;
 510 
 511 public:
 512     BOOL HasDisplayChanged() { return m_displayChanged; }
 513     void ResetDisplayChanged() { m_displayChanged = FALSE; }
 514     void RegisterEmbedderProcessId(HWND);
 515     BOOL IsEmbedderProcessId(const DWORD processID) const
 516     {
 517         return m_embedderProcessID && (processID == m_embedderProcessID);
 518     }
 519 
 520  private:
 521     static JNIEnv *m_env;
 522     static DWORD m_threadId;
 523  public:
 524     static void SetEnv(JNIEnv *env);
 525     static JNIEnv* GetEnv();
 526 
 527     static BOOL GetScreenInsets(int screenNum, RECT * rect);
 528 
 529     // If the DWM is active, this function uses
 530     // DwmGetWindowAttribute()/DWMWA_EXTENDED_FRAME_BOUNDS.
 531     // Otherwise, fall back to regular ::GetWindowRect().
 532     // See 6711576 for more details.
 533     static void GetWindowRect(HWND hWnd, LPRECT lpRect);
 534 
 535  private:
 536     // The window handle of a toplevel window last seen under the mouse cursor.
 537     // See MouseLowLevelHook() for details.
 538     HWND m_lastWindowUnderMouse;
 539  public:
 540     HWND GetWindowUnderMouse() { return m_lastWindowUnderMouse; }
 541 
 542     void InstallMouseLowLevelHook();
 543     void UninstallMouseLowLevelHook();
 544 
 545 
 546 /* AWT preloading (early Toolkit thread start)
 547  */
 548 public:
 549     /* Toolkit preload action class.
 550      * Preload actions should be registered with
 551      * AwtToolkit::getInstance().GetPreloadThread().AddAction().
 552      * AwtToolkit thread calls InitImpl method at the beghining
 553      * and CleanImpl(false) before exiting for all registered actions.
 554      * If an application provides own Toolkit thread
 555      * (sun.awt.windows.WToolkit.embeddedInit), the thread calls Clean(true)
 556      * for each action.
 557      */
 558     class PreloadThread;    // forward declaration
 559     class PreloadAction {
 560         friend class PreloadThread;
 561     public:
 562         PreloadAction() : initThreadId(0), pNext(NULL) {}
 563         virtual ~PreloadAction() {}
 564 
 565     protected:
 566         // called by PreloadThread or as result
 567         // of EnsureInited() call (on Toolkit thread!).
 568         virtual void InitImpl() = 0;
 569 
 570         // called by PreloadThread (before exiting).
 571         // reInit == false: normal shutdown;
 572         // reInit == true: PreloadThread is shutting down due external
 573         //   Toolkit thread was provided.
 574         virtual void CleanImpl(bool reInit) = 0;
 575 
 576     public:
 577         // Initialized the action on the Toolkit thread if not yet initialized.
 578         bool EnsureInited();
 579 
 580         // returns thread ID which the action was inited on (0 if not inited)
 581         DWORD GetInitThreadID();
 582 
 583         // Allows to deinitialize action earlier.
 584         // The method must be called on the Toolkit thread only.
 585         // returns true on success,
 586         //         false if the action was inited on other thread.
 587         bool Clean();
 588 
 589     private:
 590         unsigned initThreadId;
 591         // lock for Init/Clean
 592         CriticalSection initLock;
 593 
 594         // Chain support (for PreloadThread)
 595         PreloadAction *pNext;   // for action chain used by PreloadThread
 596         void SetNext(PreloadAction *pNext) { this->pNext = pNext; }
 597         PreloadAction *GetNext() { return pNext; }
 598 
 599         // wrapper for AwtToolkit::InvokeFunction
 600         static void InitWrapper(void *param);
 601 
 602         void Init();
 603         void Clean(bool reInit);
 604 
 605     };
 606 
 607     /** Toolkit preload thread class.
 608      */
 609     class PreloadThread {
 610     public:
 611         PreloadThread();
 612         ~PreloadThread();
 613 
 614         // adds action & start the thread if not yet started
 615         bool AddAction(PreloadAction *pAction);
 616 
 617         // sets termination flag; returns true if the thread is running.
 618         // wrongThread specifies cause of the termination:
 619         //   false means termination on the application shutdown;
 620         // wrongThread is used as reInit parameter for action cleanup.
 621         bool Terminate(bool wrongThread);
 622         bool InvokeAndTerminate(void(_cdecl *fn)(void *), void *param);
 623 
 624         // waits for the the thread completion;
 625         // use the method after Terminate() only if Terminate() returned true
 626         INLINE void Wait4Finish() {
 627             ::WaitForSingleObject(hFinished, INFINITE);
 628         }
 629 
 630         INLINE unsigned GetThreadId() {
 631             CriticalSection::Lock lock(threadLock);
 632             return threadId;
 633         }
 634         INLINE bool IsWrongThread() {
 635             CriticalSection::Lock lock(threadLock);
 636             return wrongThread;
 637         }
 638         // returns true if the current thread is "preload" thread
 639         bool OnPreloadThread();
 640 
 641     private:
 642         // data access lock
 643         CriticalSection threadLock;
 644 
 645         // the thread status
 646         enum Status {
 647             None = -1,      // initial
 648             Preloading = 0, // preloading in progress
 649             RunningToolkit, // Running as Toolkit thread
 650             Cleaning,       // exited from Toolkit thread proc, cleaning
 651             Finished        //
 652         } status;
 653 
 654         // "wrong thread" flag
 655         bool wrongThread;
 656 
 657         // thread proc (calls (this)param->ThreadProc())
 658         static unsigned WINAPI StaticThreadProc(void *param);
 659         unsigned ThreadProc();
 660 
 661         INLINE void AwakeThread() {
 662             ::SetEvent(hAwake);
 663         }
 664 
 665         // if threadId != 0 -> we are running
 666         unsigned threadId;
 667         // ThreadProc sets the event on exit
 668         HANDLE hFinished;
 669         // ThreadProc waits on the event for NewAction/Terminate/InvokeAndTerminate
 670         HANDLE hAwake;
 671 
 672         // function/param to invoke (InvokeAndTerminate)
 673         // if execFunc == NULL => just terminate
 674         void(_cdecl *execFunc)(void *);
 675         void *execParam;
 676 
 677         // action chain
 678         PreloadAction *pActionChain;
 679         PreloadAction *pLastProcessedAction;
 680 
 681         // returns next action in the list (NULL if no more actions)
 682         PreloadAction* GetNextAction();
 683 
 684     };
 685 
 686     INLINE PreloadThread& GetPreloadThread() { return preloadThread; }
 687 
 688 private:
 689     PreloadThread preloadThread;
 690 
 691 };
 692 
 693 
 694 /*  creates an instance of T and assigns it to the argument, but only if
 695     the argument is initially NULL. Supposed to be thread-safe.
 696     returns the new value of the argument. I'm not using volatile here
 697     as InterlockedCompareExchange ensures volatile semantics
 698     and acquire/release.
 699     The function is useful when used with static POD NULL-initialized
 700     pointers, as they are guaranteed to be NULL before any dynamic
 701     initialization takes place. This function turns such a pointer
 702     into a thread-safe singleton, working regardless of dynamic
 703     initialization order. Destruction problem is not solved,
 704     we don't need it here.
 705 */
 706 
 707 template<typename T> inline T* SafeCreate(T* &pArg) {
 708     /*  this implementation has no locks, it just destroys the object if it
 709         fails to be the first to init. another way would be using a special
 710         flag pointer value to mark the pointer as "being initialized". */
 711     T* pTemp = (T*)InterlockedCompareExchangePointer((void**)&pArg, NULL, NULL);
 712     if (pTemp != NULL) return pTemp;
 713     T* pNew = new T;
 714     pTemp = (T*)InterlockedCompareExchangePointer((void**)&pArg, pNew, NULL);
 715     if (pTemp != NULL) {
 716         // we failed it - another thread has already initialized pArg
 717         delete pNew;
 718         return pTemp;
 719     } else {
 720         return pNew;
 721     }
 722 }
 723 
 724 #endif /* AWT_TOOLKIT_H */