2001-09-28 20:14:13 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-18 22:01:16 +00:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
2004-04-18 22:01:16 +00:00
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (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.mozilla.org/MPL/
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
2001-09-28 20:14:13 +00:00
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
1999-11-06 03:40:37 +00:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 22:01:16 +00:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-28 20:14:13 +00:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 03:40:37 +00:00
|
|
|
*
|
2001-09-28 20:14:13 +00:00
|
|
|
* Contributor(s):
|
2000-03-21 03:42:00 +00:00
|
|
|
* Robert O'Callahan <roc+moz@cs.cmu.edu>
|
2001-03-14 02:34:46 +00:00
|
|
|
* Dean Tessman <dean_tessman@hotmail.com>
|
2002-12-06 03:41:43 +00:00
|
|
|
* Makoto Kato <m_kato@ga2.so-net.ne.jp>
|
2004-07-27 19:14:44 +00:00
|
|
|
* Dainis Jonitis <Dainis_Jonitis@swh-t.lv>
|
2004-09-12 05:00:57 +00:00
|
|
|
* Masayuki Nakano <masayuki@d-toybox.com>
|
2001-09-28 20:14:13 +00:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-18 22:01:16 +00:00
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
2001-09-28 20:14:13 +00:00
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
2004-04-18 22:01:16 +00:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-28 20:14:13 +00:00
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
2004-04-18 22:01:16 +00:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-28 20:14:13 +00:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
2000-03-21 03:42:00 +00:00
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
#ifndef Window_h__
|
|
|
|
#define Window_h__
|
|
|
|
|
1998-09-23 19:19:23 +00:00
|
|
|
#include "nsBaseWidget.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
#include "nsdefs.h"
|
|
|
|
#include "nsSwitchToUIThread.h"
|
|
|
|
#include "nsToolkit.h"
|
|
|
|
|
|
|
|
#include "nsIWidget.h"
|
1999-11-15 20:57:41 +00:00
|
|
|
#include "nsIKBStateControl.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
|
|
|
|
#include "nsIMouseListener.h"
|
|
|
|
#include "nsIEventListener.h"
|
1998-04-17 23:45:07 +00:00
|
|
|
#include "nsString.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1998-08-13 23:01:01 +00:00
|
|
|
#include "nsVoidArray.h"
|
|
|
|
|
2003-03-14 23:35:18 +00:00
|
|
|
#include <imm.h>
|
|
|
|
|
1999-04-06 20:23:55 +00:00
|
|
|
class nsNativeDragTarget;
|
1999-09-21 11:25:03 +00:00
|
|
|
class nsIRollupListener;
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2000-01-31 22:53:35 +00:00
|
|
|
class nsIMenuBar;
|
2004-09-07 18:59:27 +00:00
|
|
|
class nsIFile;
|
2000-01-31 22:53:35 +00:00
|
|
|
|
2001-08-17 03:13:07 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
2003-04-01 20:02:51 +00:00
|
|
|
#include "OLEACC.H"
|
2001-04-17 23:06:38 +00:00
|
|
|
#include "nsIAccessible.h"
|
2001-08-17 03:13:07 +00:00
|
|
|
#endif
|
2001-04-17 23:06:38 +00:00
|
|
|
|
2002-10-01 02:47:41 +00:00
|
|
|
#define IME_MAX_CHAR_POS 64
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
#define NSRGB_2_COLOREF(color) \
|
|
|
|
RGB(NS_GET_R(color),NS_GET_G(color),NS_GET_B(color))
|
2001-05-25 14:48:31 +00:00
|
|
|
#define COLOREF_2_NSRGB(color) \
|
|
|
|
NS_RGB(GetRValue(color), GetGValue(color), GetBValue(color))
|
1999-03-12 00:21:11 +00:00
|
|
|
|
2004-05-20 03:14:41 +00:00
|
|
|
/*
|
|
|
|
* ::: IMPORTANT :::
|
|
|
|
* External apps and drivers depend on window class names.
|
2004-09-03 08:44:23 +00:00
|
|
|
* For example, changing the window classes
|
2004-05-20 03:14:41 +00:00
|
|
|
* could break touchpad scrolling or screen readers.
|
|
|
|
*/
|
2004-09-03 08:44:23 +00:00
|
|
|
const PRUint32 kMaxClassNameLength = 40;
|
2004-05-04 12:39:42 +00:00
|
|
|
const LPCWSTR kWClassNameHidden = L"MozillaHiddenWindowClass";
|
|
|
|
const LPCWSTR kWClassNameUI = L"MozillaUIWindowClass";
|
|
|
|
const LPCWSTR kWClassNameContent = L"MozillaContentWindowClass";
|
|
|
|
const LPCWSTR kWClassNameGeneral = L"MozillaWindowClass";
|
2004-09-03 08:44:23 +00:00
|
|
|
const LPCSTR kClassNameHidden = "MozillaHiddenWindowClass";
|
|
|
|
const LPCSTR kClassNameUI = "MozillaUIWindowClass";
|
|
|
|
const LPCSTR kClassNameContent = "MozillaContentWindowClass";
|
|
|
|
const LPCSTR kClassNameGeneral = "MozillaWindowClass";
|
2004-05-04 12:39:42 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
/**
|
2000-09-22 01:06:51 +00:00
|
|
|
* Native IMM wrapper
|
|
|
|
*/
|
2004-09-03 08:44:23 +00:00
|
|
|
class nsIMM
|
2000-09-22 01:06:51 +00:00
|
|
|
{
|
2004-09-03 08:44:23 +00:00
|
|
|
//prototypes for DLL function calls...
|
|
|
|
typedef LONG (CALLBACK *GetCompStrPtr) (HIMC, DWORD, LPVOID, DWORD);
|
|
|
|
typedef LONG (CALLBACK *GetContextPtr) (HWND);
|
|
|
|
typedef LONG (CALLBACK *RelContextPtr) (HWND, HIMC);
|
|
|
|
typedef LONG (CALLBACK *NotifyIMEPtr) (HIMC, DWORD, DWORD, DWORD);
|
|
|
|
typedef LONG (CALLBACK *SetCandWindowPtr)(HIMC, LPCANDIDATEFORM);
|
|
|
|
typedef LONG (CALLBACK *SetCompWindowPtr)(HIMC, LPCOMPOSITIONFORM);
|
|
|
|
typedef LONG (CALLBACK *GetCompWindowPtr)(HIMC, LPCOMPOSITIONFORM);
|
|
|
|
typedef LONG (CALLBACK *GetPropertyPtr) (HKL, DWORD);
|
|
|
|
typedef LONG (CALLBACK *GetDefaultIMEWndPtr) (HWND);
|
2004-09-12 05:00:57 +00:00
|
|
|
typedef BOOL (CALLBACK *GetOpenStatusPtr) (HIMC);
|
|
|
|
typedef BOOL (CALLBACK *SetOpenStatusPtr) (HIMC, BOOL);
|
2000-09-22 01:06:51 +00:00
|
|
|
public:
|
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
static nsIMM& LoadModule() {
|
|
|
|
static nsIMM gIMM;
|
|
|
|
return gIMM;
|
|
|
|
}
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
nsIMM(const char* aModuleName="IMM32.DLL") {
|
|
|
|
mInstance=::LoadLibrary(aModuleName);
|
|
|
|
NS_ASSERTION(mInstance!=NULL, "nsIMM.LoadLibrary failed.");
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mGetCompositionStringA=(mInstance) ? (GetCompStrPtr)GetProcAddress(mInstance, "ImmGetCompositionStringA") : 0;
|
|
|
|
NS_ASSERTION(mGetCompositionStringA!=NULL, "nsIMM.ImmGetCompositionStringA failed.");
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mGetCompositionStringW=(mInstance) ? (GetCompStrPtr)GetProcAddress(mInstance, "ImmGetCompositionStringW") : 0;
|
|
|
|
NS_ASSERTION(mGetCompositionStringW!=NULL, "nsIMM.ImmGetCompositionStringW failed.");
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mGetContext=(mInstance) ? (GetContextPtr)GetProcAddress(mInstance, "ImmGetContext") : 0;
|
|
|
|
NS_ASSERTION(mGetContext!=NULL, "nsIMM.ImmGetContext failed.");
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mReleaseContext=(mInstance) ? (RelContextPtr)GetProcAddress(mInstance, "ImmReleaseContext") : 0;
|
|
|
|
NS_ASSERTION(mReleaseContext!=NULL, "nsIMM.ImmReleaseContext failed.");
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mNotifyIME=(mInstance) ? (NotifyIMEPtr)GetProcAddress(mInstance, "ImmNotifyIME") : 0;
|
|
|
|
NS_ASSERTION(mNotifyIME!=NULL, "nsIMM.ImmNotifyIME failed.");
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mSetCandiateWindow=(mInstance) ? (SetCandWindowPtr)GetProcAddress(mInstance, "ImmSetCandidateWindow") : 0;
|
|
|
|
NS_ASSERTION(mSetCandiateWindow!=NULL, "nsIMM.ImmSetCandidateWindow failed.");
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mGetCompositionWindow=(mInstance) ? (GetCompWindowPtr)GetProcAddress(mInstance, "ImmGetCompositionWindow") : 0;
|
|
|
|
NS_ASSERTION(mGetCompositionWindow!=NULL, "nsIMM.ImmGetCompositionWindow failed.");
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mSetCompositionWindow=(mInstance) ? (SetCompWindowPtr)GetProcAddress(mInstance, "ImmSetCompositionWindow") : 0;
|
|
|
|
NS_ASSERTION(mSetCompositionWindow!=NULL, "nsIMM.ImmSetCompositionWindow failed.");
|
2002-05-23 22:03:49 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mGetProperty=(mInstance) ? (GetPropertyPtr)GetProcAddress(mInstance, "ImmGetProperty") : 0;
|
|
|
|
NS_ASSERTION(mGetProperty!=NULL, "nsIMM.ImmGetProperty failed.");
|
2000-09-22 01:06:51 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
mGetDefaultIMEWnd=(mInstance) ? (GetDefaultIMEWndPtr)GetProcAddress(mInstance, "ImmGetDefaultIMEWnd") : 0;
|
|
|
|
NS_ASSERTION(mGetDefaultIMEWnd!=NULL, "nsIMM.ImmGetDefaultIMEWnd failed.");
|
2004-09-12 05:00:57 +00:00
|
|
|
|
|
|
|
mGetOpenStatus=(mInstance) ? (GetOpenStatusPtr)GetProcAddress(mInstance,"ImmGetOpenStatus") : 0;
|
|
|
|
NS_ASSERTION(mGetOpenStatus!=NULL, "nsIMM.ImmGetOpenStatus failed.");
|
|
|
|
|
|
|
|
mSetOpenStatus=(mInstance) ? (SetOpenStatusPtr)GetProcAddress(mInstance,"ImmSetOpenStatus") : 0;
|
|
|
|
NS_ASSERTION(mSetOpenStatus!=NULL, "nsIMM.ImmSetOpenStatus failed.");
|
2004-09-03 08:44:23 +00:00
|
|
|
}
|
2002-05-08 20:24:55 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
~nsIMM() {
|
|
|
|
if(mInstance) {
|
|
|
|
::FreeLibrary(mInstance);
|
2002-10-01 02:47:41 +00:00
|
|
|
}
|
2004-09-03 08:44:23 +00:00
|
|
|
mGetCompositionStringA=0;
|
|
|
|
mGetCompositionStringW=0;
|
|
|
|
mGetContext=0;
|
|
|
|
mReleaseContext=0;
|
|
|
|
mNotifyIME=0;
|
|
|
|
mSetCandiateWindow=0;
|
|
|
|
mGetCompositionWindow=0;
|
|
|
|
mSetCompositionWindow=0;
|
|
|
|
mGetProperty=0;
|
|
|
|
mGetDefaultIMEWnd=0;
|
2004-09-12 05:00:57 +00:00
|
|
|
mGetOpenStatus=0;
|
|
|
|
mSetOpenStatus=0;
|
2004-09-03 08:44:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
LONG GetCompositionStringA(HIMC h, DWORD d1, LPVOID v, DWORD d2) {
|
|
|
|
return (mGetCompositionStringA) ? mGetCompositionStringA(h, d1, v, d2) : 0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
LONG GetCompositionStringW(HIMC h, DWORD d1, LPVOID v, DWORD d2) {
|
|
|
|
return (mGetCompositionStringW) ? mGetCompositionStringW(h, d1, v, d2) : 0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
LONG GetContext(HWND anHWND) {
|
|
|
|
return (mGetContext) ? mGetContext(anHWND) : 0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
LONG ReleaseContext(HWND anHWND, HIMC anIMC) {
|
|
|
|
return (mReleaseContext) ? mReleaseContext(anHWND, anIMC) : 0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
LONG NotifyIME(HIMC h, DWORD d1, DWORD d2, DWORD d3) {
|
|
|
|
return (mNotifyIME) ? mNotifyIME(h, d1, d2, d3) : 0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
LONG SetCandidateWindow(HIMC h, LPCANDIDATEFORM l) {
|
|
|
|
return (mSetCandiateWindow) ? mSetCandiateWindow(h, l) : 0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
LONG SetCompositionWindow(HIMC h, LPCOMPOSITIONFORM l) {
|
|
|
|
return (mSetCompositionWindow) ? mSetCompositionWindow(h, l) : 0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
LONG GetCompositionWindow(HIMC h,LPCOMPOSITIONFORM l) {
|
|
|
|
return (mGetCompositionWindow) ? mGetCompositionWindow(h, l) : 0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
LONG GetProperty(HKL hKL, DWORD dwIndex) {
|
|
|
|
return (mGetProperty) ? mGetProperty(hKL, dwIndex) : 0L;
|
|
|
|
}
|
|
|
|
|
|
|
|
LONG GetDefaultIMEWnd(HWND hWnd) {
|
|
|
|
return (mGetDefaultIMEWnd) ? mGetDefaultIMEWnd(hWnd) : 0L;
|
|
|
|
}
|
2002-10-01 02:47:41 +00:00
|
|
|
|
2004-09-12 05:00:57 +00:00
|
|
|
BOOL GetOpenStatus(HIMC h) {
|
|
|
|
return (mGetOpenStatus) ? mGetOpenStatus(h) : FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL SetOpenStatus(HIMC h, BOOL b) {
|
|
|
|
return (mSetOpenStatus) ? mSetOpenStatus(h,b) : FALSE;
|
|
|
|
}
|
|
|
|
|
2000-09-22 01:06:51 +00:00
|
|
|
private:
|
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
HINSTANCE mInstance;
|
|
|
|
GetCompStrPtr mGetCompositionStringA;
|
|
|
|
GetCompStrPtr mGetCompositionStringW;
|
|
|
|
GetContextPtr mGetContext;
|
|
|
|
RelContextPtr mReleaseContext;
|
|
|
|
NotifyIMEPtr mNotifyIME;
|
|
|
|
SetCandWindowPtr mSetCandiateWindow;
|
|
|
|
SetCompWindowPtr mSetCompositionWindow;
|
|
|
|
GetCompWindowPtr mGetCompositionWindow;
|
|
|
|
GetPropertyPtr mGetProperty;
|
|
|
|
GetDefaultIMEWndPtr mGetDefaultIMEWnd;
|
2004-09-12 05:00:57 +00:00
|
|
|
GetOpenStatusPtr mGetOpenStatus;
|
|
|
|
SetOpenStatusPtr mSetOpenStatus;
|
2000-09-22 01:06:51 +00:00
|
|
|
};
|
|
|
|
|
1998-04-14 23:20:49 +00:00
|
|
|
/**
|
2004-09-03 08:44:23 +00:00
|
|
|
* Native WIN32 window wrapper.
|
1998-04-14 23:20:49 +00:00
|
|
|
*/
|
|
|
|
|
1999-04-19 19:04:12 +00:00
|
|
|
class nsWindow : public nsSwitchToUIThread,
|
1999-11-15 20:57:41 +00:00
|
|
|
public nsBaseWidget,
|
|
|
|
public nsIKBStateControl
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
public:
|
2004-09-03 08:44:23 +00:00
|
|
|
nsWindow();
|
|
|
|
virtual ~nsWindow();
|
|
|
|
|
|
|
|
// nsISupports
|
|
|
|
NS_IMETHOD_(nsrefcnt) AddRef(void);
|
|
|
|
NS_IMETHOD_(nsrefcnt) Release(void);
|
|
|
|
NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr);
|
|
|
|
|
|
|
|
// nsIWidget interface
|
|
|
|
NS_IMETHOD Create(nsIWidget *aParent,
|
|
|
|
const nsRect &aRect,
|
|
|
|
EVENT_CALLBACK aHandleEventFunction,
|
|
|
|
nsIDeviceContext *aContext,
|
|
|
|
nsIAppShell *aAppShell = nsnull,
|
|
|
|
nsIToolkit *aToolkit = nsnull,
|
|
|
|
nsWidgetInitData *aInitData = nsnull);
|
|
|
|
NS_IMETHOD Create(nsNativeWidget aParent,
|
|
|
|
const nsRect &aRect,
|
|
|
|
EVENT_CALLBACK aHandleEventFunction,
|
|
|
|
nsIDeviceContext *aContext,
|
|
|
|
nsIAppShell *aAppShell = nsnull,
|
|
|
|
nsIToolkit *aToolkit = nsnull,
|
|
|
|
nsWidgetInitData *aInitData = nsnull);
|
|
|
|
|
|
|
|
// Utility method for implementing both Create(nsIWidget ...) and
|
|
|
|
// Create(nsNativeWidget...)
|
|
|
|
|
|
|
|
virtual nsresult StandardWindowCreate(nsIWidget *aParent,
|
|
|
|
const nsRect &aRect,
|
|
|
|
EVENT_CALLBACK aHandleEventFunction,
|
|
|
|
nsIDeviceContext *aContext,
|
|
|
|
nsIAppShell *aAppShell,
|
|
|
|
nsIToolkit *aToolkit,
|
|
|
|
nsWidgetInitData *aInitData,
|
|
|
|
nsNativeWidget aNativeParent = nsnull);
|
|
|
|
|
|
|
|
NS_IMETHOD Destroy();
|
|
|
|
NS_IMETHOD SetParent(nsIWidget *aNewParent);
|
|
|
|
virtual nsIWidget* GetParent(void);
|
|
|
|
NS_IMETHOD Show(PRBool bState);
|
|
|
|
NS_IMETHOD IsVisible(PRBool & aState);
|
|
|
|
NS_IMETHOD PlaceBehind(nsTopLevelWidgetZPlacement aPlacement, nsIWidget *aWidget, PRBool aActivate);
|
|
|
|
NS_IMETHOD SetSizeMode(PRInt32 aMode);
|
|
|
|
NS_IMETHOD ModalEventFilter(PRBool aRealEvent, void *aEvent, PRBool *aForWindow);
|
|
|
|
NS_IMETHOD CaptureMouse(PRBool aCapture);
|
|
|
|
NS_IMETHOD ConstrainPosition(PRBool aAllowSlop, PRInt32 *aX, PRInt32 *aY);
|
|
|
|
NS_IMETHOD Move(PRInt32 aX, PRInt32 aY);
|
|
|
|
NS_IMETHOD Resize(PRInt32 aWidth, PRInt32 aHeight, PRBool aRepaint);
|
|
|
|
NS_IMETHOD Resize(PRInt32 aX, PRInt32 aY, PRInt32 aWidth, PRInt32 aHeight, PRBool aRepaint);
|
|
|
|
NS_IMETHOD Enable(PRBool aState);
|
|
|
|
NS_IMETHOD IsEnabled(PRBool *aState);
|
|
|
|
NS_IMETHOD SetFocus(PRBool aRaise);
|
|
|
|
NS_IMETHOD GetBounds(nsRect &aRect);
|
|
|
|
NS_IMETHOD GetClientBounds(nsRect &aRect);
|
|
|
|
NS_IMETHOD GetScreenBounds(nsRect &aRect);
|
|
|
|
NS_IMETHOD SetBackgroundColor(const nscolor &aColor);
|
|
|
|
virtual nsIFontMetrics* GetFont(void);
|
|
|
|
NS_IMETHOD SetFont(const nsFont &aFont);
|
|
|
|
NS_IMETHOD SetCursor(nsCursor aCursor);
|
|
|
|
NS_IMETHOD HideWindowChrome(PRBool aShouldHide);
|
|
|
|
NS_IMETHOD Validate();
|
|
|
|
NS_IMETHOD Invalidate(PRBool aIsSynchronous);
|
|
|
|
NS_IMETHOD Invalidate(const nsRect & aRect, PRBool aIsSynchronous);
|
|
|
|
NS_IMETHOD InvalidateRegion(const nsIRegion *aRegion, PRBool aIsSynchronous);
|
|
|
|
NS_IMETHOD Update();
|
|
|
|
virtual void* GetNativeData(PRUint32 aDataType);
|
|
|
|
virtual void FreeNativeData(void * data, PRUint32 aDataType);//~~~
|
|
|
|
NS_IMETHOD SetColorMap(nsColorMap *aColorMap);
|
|
|
|
//XXX-Scroll is obsolete it is going away soon
|
|
|
|
NS_IMETHOD Scroll(PRInt32 aDx, PRInt32 aDy, nsRect *aClipRect);
|
|
|
|
NS_IMETHOD ScrollWidgets(PRInt32 aDx, PRInt32 aDy);
|
|
|
|
NS_IMETHOD ScrollRect(nsRect &aRect, PRInt32 aDx, PRInt32 aDy);
|
|
|
|
NS_IMETHOD SetTitle(const nsAString& aTitle);
|
|
|
|
NS_IMETHOD SetIcon(const nsAString& aIconSpec);
|
|
|
|
NS_IMETHOD SetMenuBar(nsIMenuBar * aMenuBar) { return NS_ERROR_FAILURE; }
|
|
|
|
NS_IMETHOD ShowMenuBar(PRBool aShow) { return NS_ERROR_FAILURE; }
|
|
|
|
NS_IMETHOD WidgetToScreen(const nsRect& aOldRect, nsRect& aNewRect);
|
|
|
|
NS_IMETHOD ScreenToWidget(const nsRect& aOldRect, nsRect& aNewRect);
|
|
|
|
NS_IMETHOD BeginResizingChildren(void);
|
|
|
|
NS_IMETHOD EndResizingChildren(void);
|
|
|
|
NS_IMETHOD GetPreferredSize(PRInt32& aWidth, PRInt32& aHeight);
|
|
|
|
NS_IMETHOD SetPreferredSize(PRInt32 aWidth, PRInt32 aHeight);
|
|
|
|
NS_IMETHOD DispatchEvent(nsGUIEvent* event, nsEventStatus & aStatus);
|
|
|
|
NS_IMETHOD EnableDragDrop(PRBool aEnable);
|
|
|
|
|
|
|
|
virtual void SetUpForPaint(HDC aHDC);
|
|
|
|
virtual void ConvertToDeviceCoordinates(nscoord& aX,nscoord& aY) {}
|
|
|
|
|
|
|
|
NS_IMETHOD CaptureRollupEvents(nsIRollupListener * aListener, PRBool aDoCapture, PRBool aConsumeRollupEvent);
|
|
|
|
|
|
|
|
NS_IMETHOD GetAttention(PRInt32 aCycleCount);
|
|
|
|
NS_IMETHOD GetLastInputEventTime(PRUint32& aTime);
|
1999-12-10 07:20:51 +00:00
|
|
|
|
2004-07-27 19:14:44 +00:00
|
|
|
#ifdef MOZ_XUL
|
|
|
|
NS_IMETHOD SetWindowTranslucency(PRBool aTransparent);
|
|
|
|
NS_IMETHOD GetWindowTranslucency(PRBool& aTransparent);
|
|
|
|
NS_IMETHOD UpdateTranslucentWindowAlpha(const nsRect& aRect, PRUint8* aAlphas);
|
|
|
|
private:
|
|
|
|
nsresult SetWindowTranslucencyInner(PRBool aTransparent);
|
|
|
|
PRBool GetWindowTranslucencyInner() { return mIsTranslucent; }
|
|
|
|
void UpdateTranslucentWindowAlphaInner(const nsRect& aRect, PRUint8* aAlphas);
|
2004-12-09 17:56:46 +00:00
|
|
|
nsWindow* GetTopLevelWindow();
|
2004-07-27 19:14:44 +00:00
|
|
|
void ResizeTranslucentWindow(PRInt32 aNewWidth, PRInt32 aNewHeight);
|
|
|
|
nsresult UpdateTranslucentWindow();
|
2004-12-09 17:56:46 +00:00
|
|
|
nsresult SetupTranslucentWindowMemoryBitmap(PRBool aTranslucent);
|
|
|
|
void SetWindowRegionToAlphaMask();
|
2004-07-27 19:14:44 +00:00
|
|
|
public:
|
|
|
|
#endif
|
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
// nsIKBStateControl interface
|
1999-11-15 20:57:41 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
NS_IMETHOD ResetInputState();
|
2004-09-12 05:00:57 +00:00
|
|
|
NS_IMETHOD SetIMEOpenState(PRBool aState);
|
|
|
|
NS_IMETHOD GetIMEOpenState(PRBool* aState);
|
2004-11-13 11:27:09 +00:00
|
|
|
NS_IMETHOD CancelIMEComposition();
|
1999-11-15 20:57:41 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
PRBool IMEMouseHandling(PRUint32 aEventType, PRInt32 aAction, LPARAM lParam);
|
|
|
|
PRBool IMECompositionHitTest(PRUint32 aEventType, POINT * ptPos);
|
|
|
|
PRBool HandleMouseActionOfIME(PRInt32 aAction, POINT* ptPos);
|
|
|
|
void GetCompositionWindowPos(HIMC hIMC, PRUint32 aEventType, COMPOSITIONFORM *cpForm);
|
2002-10-01 02:47:41 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
// nsSwitchToUIThread interface
|
|
|
|
virtual BOOL CallMethod(MethodInfo *info);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
HWND GetWindowHandle() { return mWnd; }
|
|
|
|
WNDPROC GetPrevWindowProc() { return mPrevWndProc; }
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
virtual PRBool DispatchMouseEvent(PRUint32 aEventType, WPARAM wParam = NULL, nsPoint* aPoint = nsnull);
|
2001-08-17 03:13:07 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
2004-09-03 08:44:23 +00:00
|
|
|
virtual PRBool DispatchAccessibleEvent(PRUint32 aEventType, nsIAccessible** aAccessible, nsPoint* aPoint = nsnull);
|
|
|
|
void CreateRootAccessible();
|
|
|
|
void ClearRootAccessible();
|
2001-08-17 03:13:07 +00:00
|
|
|
#endif
|
2004-09-03 08:44:23 +00:00
|
|
|
virtual PRBool AutoErase();
|
|
|
|
nsPoint* GetLastPoint() { return &mLastPoint; }
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
PRInt32 GetNewCmdMenuId() { mMenuCmdId++; return mMenuCmdId; }
|
1999-02-17 14:30:47 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
void InitEvent(nsGUIEvent& event, nsPoint* aPoint = nsnull);
|
1999-03-09 23:48:58 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
void SuppressBlurEvents(PRBool aSuppress);
|
|
|
|
PRBool BlurEventsSuppressed();
|
2003-02-24 20:15:59 +00:00
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
protected:
|
2004-09-03 08:44:23 +00:00
|
|
|
// special callback hook methods for pop ups
|
|
|
|
static LRESULT CALLBACK MozSpecialMsgFilter(int code, WPARAM wParam, LPARAM lParam);
|
|
|
|
static LRESULT CALLBACK MozSpecialWndProc(int code, WPARAM wParam, LPARAM lParam);
|
|
|
|
static LRESULT CALLBACK MozSpecialMouseProc(int code, WPARAM wParam, LPARAM lParam);
|
|
|
|
static VOID CALLBACK HookTimerForPopups( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime );
|
|
|
|
static void ScheduleHookTimer(HWND aWnd, UINT aMsgId);
|
|
|
|
|
|
|
|
static void RegisterSpecialDropdownHooks();
|
|
|
|
static void UnregisterSpecialDropdownHooks();
|
|
|
|
|
|
|
|
static BOOL DealWithPopups (UINT inMsg, WPARAM inWParam, LPARAM inLParam, LRESULT* outResult);
|
|
|
|
|
|
|
|
static PRBool EventIsInsideWindow(UINT Msg, nsWindow* aWindow);
|
|
|
|
|
2004-12-09 17:56:46 +00:00
|
|
|
static nsWindow* GetNSWindowPtr(HWND aWnd);
|
2004-09-03 08:44:23 +00:00
|
|
|
static BOOL SetNSWindowPtr(HWND aWnd, nsWindow * ptr);
|
2004-12-09 17:56:46 +00:00
|
|
|
nsWindow* GetParent(PRBool aStopOnFirstTopLevel);
|
2004-09-03 08:44:23 +00:00
|
|
|
|
|
|
|
void DispatchPendingEvents();
|
|
|
|
virtual PRBool ProcessMessage(UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *aRetValue);
|
|
|
|
virtual PRBool DispatchWindowEvent(nsGUIEvent* event);
|
|
|
|
virtual PRBool DispatchWindowEvent(nsGUIEvent*event, nsEventStatus &aStatus);
|
|
|
|
|
|
|
|
// Allow Derived classes to modify the height that is passed
|
|
|
|
// when the window is created or resized.
|
|
|
|
virtual PRInt32 GetHeight(PRInt32 aProposedHeight);
|
|
|
|
virtual LPCWSTR WindowClassW();
|
|
|
|
virtual LPCWSTR WindowPopupClassW();
|
|
|
|
virtual LPCTSTR WindowClass();
|
|
|
|
virtual LPCTSTR WindowPopupClass();
|
|
|
|
virtual DWORD WindowStyle();
|
|
|
|
virtual DWORD WindowExStyle();
|
|
|
|
|
|
|
|
virtual void SubclassWindow(BOOL bState);
|
|
|
|
|
|
|
|
virtual void OnDestroy();
|
|
|
|
virtual PRBool OnMove(PRInt32 aX, PRInt32 aY);
|
|
|
|
virtual PRBool OnPaint(HDC aDC = nsnull);
|
|
|
|
virtual PRBool OnResize(nsRect &aWindowRect);
|
|
|
|
|
|
|
|
BOOL OnChar(UINT charCode);
|
|
|
|
|
|
|
|
BOOL OnKeyDown( UINT aVirtualKeyCode, UINT aScanCode, LPARAM aKeyCode);
|
|
|
|
BOOL OnKeyUp( UINT aVirtualKeyCode, UINT aScanCode, LPARAM aKeyCode);
|
|
|
|
UINT MapFromNativeToDOM(UINT aNativeKeyCode);
|
|
|
|
|
|
|
|
|
|
|
|
BOOL OnInputLangChange(HKL aHKL, LRESULT *oResult);
|
|
|
|
BOOL OnIMEChar(BYTE aByte1, BYTE aByte2, LPARAM aKeyState);
|
|
|
|
BOOL OnIMEComposition(LPARAM aGCS);
|
|
|
|
BOOL OnIMECompositionFull();
|
|
|
|
BOOL OnIMEEndComposition();
|
|
|
|
BOOL OnIMENotify(WPARAM aIMN, LPARAM aData, LRESULT *oResult);
|
2004-12-06 15:07:36 +00:00
|
|
|
BOOL OnIMERequest(WPARAM aIMR, LPARAM aData, LRESULT *oResult, PRBool aUseUnicode = PR_FALSE);
|
2004-09-03 08:44:23 +00:00
|
|
|
BOOL OnIMESelect(BOOL aSelected, WORD aLangID);
|
|
|
|
BOOL OnIMESetContext(BOOL aActive, LPARAM& aISC);
|
|
|
|
BOOL OnIMEStartComposition();
|
|
|
|
BOOL OnIMEReconvert(LPARAM aData, LRESULT *oResult, PRBool aUseUnicode);
|
|
|
|
|
2004-09-08 19:30:22 +00:00
|
|
|
void GetCompositionString(HIMC aHIMC, DWORD aIndex, nsString* aStrUnicode, nsCString* aStrAnsi);
|
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
virtual PRBool DispatchKeyEvent(PRUint32 aEventType, WORD aCharCode, UINT aVirtualCharCode, LPARAM aKeyCode);
|
|
|
|
|
|
|
|
virtual PRBool DispatchFocus(PRUint32 aEventType, PRBool isMozWindowTakingFocus);
|
|
|
|
virtual PRBool OnScroll(UINT scrollCode, int cPos);
|
|
|
|
virtual HBRUSH OnControlColor();
|
|
|
|
|
|
|
|
static LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
|
|
|
static LRESULT CALLBACK DefaultWindowProc(HWND hWns, UINT msg, WPARAM wParam, LPARAM lParam);
|
|
|
|
|
|
|
|
static PRBool ConvertStatus(nsEventStatus aStatus);
|
|
|
|
|
|
|
|
PRBool DispatchStandardEvent(PRUint32 aMsg);
|
|
|
|
PRBool DispatchAppCommandEvent(PRUint32 aEventCommand);
|
|
|
|
void RelayMouseEvent(UINT aMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
|
|
|
|
void GetNonClientBounds(nsRect &aRect);
|
|
|
|
void HandleTextEvent(HIMC hIMEContext, PRBool aCheckAttr=PR_TRUE);
|
|
|
|
BOOL HandleStartComposition(HIMC hIMEContext);
|
|
|
|
void HandleEndComposition(void);
|
2004-09-08 19:30:22 +00:00
|
|
|
void GetTextRangeList(PRUint32* textRangeListLengthResult, nsTextRangeArray* textRangeListResult);
|
2004-09-03 08:44:23 +00:00
|
|
|
|
|
|
|
void ConstrainZLevel(HWND *aAfter);
|
2000-04-01 22:16:43 +00:00
|
|
|
|
1999-07-09 12:23:24 +00:00
|
|
|
private:
|
|
|
|
|
2001-05-17 23:52:32 +00:00
|
|
|
|
1999-07-09 12:23:24 +00:00
|
|
|
#ifdef DEBUG
|
2004-09-03 08:44:23 +00:00
|
|
|
void DebugPrintEvent(nsGUIEvent& aEvent, HWND aWnd);
|
1999-07-09 12:23:24 +00:00
|
|
|
#endif
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
protected:
|
2004-09-08 19:30:22 +00:00
|
|
|
// Count of nsWindow instances. Used to manage IME buffers
|
|
|
|
static PRUint32 sInstanceCount;
|
|
|
|
|
|
|
|
// For Input Method Support
|
|
|
|
// Only one set of IME buffers is needed for a process.
|
|
|
|
static PRBool sIMEIsComposing;
|
|
|
|
static PRBool sIMEIsStatusChanged;
|
|
|
|
|
|
|
|
static DWORD sIMEProperty;
|
|
|
|
static nsString* sIMECompUnicode;
|
|
|
|
static PRUint8* sIMEAttributeArray;
|
|
|
|
static PRInt32 sIMEAttributeArrayLength;
|
|
|
|
static PRInt32 sIMEAttributeArraySize;
|
|
|
|
static PRUint32* sIMECompClauseArray;
|
|
|
|
static PRInt32 sIMECompClauseArrayLength;
|
|
|
|
static PRInt32 sIMECompClauseArraySize;
|
|
|
|
static long sIMECursorPosition;
|
|
|
|
static PRUnichar* sIMEReconvertUnicode; // reconvert string
|
|
|
|
|
|
|
|
// For describing composing frame
|
|
|
|
static RECT* sIMECompCharPos;
|
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
nsSize mLastSize;
|
|
|
|
static nsWindow* gCurrentWindow;
|
|
|
|
nsPoint mLastPoint;
|
|
|
|
HWND mWnd;
|
2004-07-27 19:14:44 +00:00
|
|
|
HWND mBorderlessParent;
|
2001-08-09 20:22:39 +00:00
|
|
|
#if 0
|
2004-09-03 08:44:23 +00:00
|
|
|
HPALETTE mPalette;
|
2001-08-09 20:22:39 +00:00
|
|
|
#endif
|
2004-09-03 08:44:23 +00:00
|
|
|
WNDPROC mPrevWndProc;
|
|
|
|
HBRUSH mBrush;
|
2002-06-11 22:20:39 +00:00
|
|
|
|
2004-07-27 19:14:44 +00:00
|
|
|
#ifdef MOZ_XUL
|
2004-12-09 17:56:46 +00:00
|
|
|
union
|
|
|
|
{
|
|
|
|
// Windows 2000 and newer use layered windows to support full 256 level alpha translucency
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
HDC mMemoryDC;
|
|
|
|
HBITMAP mMemoryBitmap;
|
|
|
|
} w2k;
|
|
|
|
// Windows NT and 9x use complex shaped window regions to support 1-bit transparency masks
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
PRPackedBool mPerformingSetWindowRgn;
|
|
|
|
} w9x;
|
|
|
|
};
|
2004-07-27 19:14:44 +00:00
|
|
|
PRUint8* mAlphaMask;
|
|
|
|
PRPackedBool mIsTranslucent;
|
2004-12-09 17:56:46 +00:00
|
|
|
PRPackedBool mIsTopTranslucent; // Topmost window itself or any of it's child windows has tranlucency enabled
|
2004-07-27 19:14:44 +00:00
|
|
|
#endif
|
2004-09-03 08:44:23 +00:00
|
|
|
PRPackedBool mIsTopWidgetWindow;
|
|
|
|
PRPackedBool mHas3DBorder;
|
|
|
|
PRPackedBool mIsShiftDown;
|
|
|
|
PRPackedBool mIsControlDown;
|
|
|
|
PRPackedBool mIsAltDown;
|
|
|
|
PRPackedBool mIsDestroying;
|
|
|
|
PRPackedBool mOnDestroyCalled;
|
|
|
|
PRPackedBool mIsVisible;
|
|
|
|
PRPackedBool mIsInMouseCapture;
|
|
|
|
PRPackedBool mIsInMouseWheelProcessing;
|
|
|
|
PRPackedBool mUnicodeWidget;
|
|
|
|
|
|
|
|
char mLeadByte;
|
|
|
|
PRUint32 mBlurEventSuppressionLevel;
|
|
|
|
nsContentType mContentType;
|
|
|
|
|
|
|
|
// XXX Temporary, should not be caching the font
|
|
|
|
nsFont * mFont;
|
|
|
|
|
|
|
|
PRInt32 mPreferredWidth;
|
|
|
|
PRInt32 mPreferredHeight;
|
|
|
|
|
|
|
|
PRInt32 mMenuCmdId;
|
1999-02-17 14:30:47 +00:00
|
|
|
|
2002-02-20 03:33:52 +00:00
|
|
|
// Window styles used by this window before chrome was hidden
|
2004-09-03 08:44:23 +00:00
|
|
|
DWORD mOldStyle;
|
|
|
|
DWORD mOldExStyle;
|
|
|
|
|
|
|
|
static UINT gCurrentKeyboardCP;
|
|
|
|
static HKL gKeyboardLayout;
|
|
|
|
|
|
|
|
// Drag & Drop
|
|
|
|
nsNativeDragTarget * mNativeDragTarget;
|
|
|
|
|
|
|
|
// Enumeration of the methods which are accessable on the "main GUI thread"
|
|
|
|
// via the CallMethod(...) mechanism...
|
|
|
|
// see nsSwitchToUIThread
|
|
|
|
enum {
|
|
|
|
CREATE = 0x0101,
|
|
|
|
CREATE_NATIVE,
|
|
|
|
DESTROY,
|
|
|
|
SET_FOCUS,
|
|
|
|
SET_CURSOR,
|
|
|
|
CREATE_HACK
|
|
|
|
};
|
|
|
|
|
|
|
|
static BOOL sIsRegistered;
|
|
|
|
static BOOL sIsPopupClassRegistered;
|
|
|
|
|
|
|
|
HDWP mDeferredPositioner;
|
|
|
|
static UINT uMSH_MOUSEWHEEL;
|
|
|
|
|
|
|
|
// IME special message
|
|
|
|
static UINT uWM_MSIME_RECONVERT; // reconvert message for MSIME
|
|
|
|
static UINT uWM_MSIME_MOUSE; // mouse message for MSIME
|
|
|
|
static UINT uWM_ATOK_RECONVERT; // reconvert message for ATOK
|
|
|
|
|
|
|
|
// Heap dump
|
|
|
|
static UINT uWM_HEAP_DUMP; // Dump heap to a file
|
2002-02-27 02:18:12 +00:00
|
|
|
|
2001-08-17 03:13:07 +00:00
|
|
|
#ifdef ACCESSIBILITY
|
2004-09-03 08:44:23 +00:00
|
|
|
nsIAccessible* mRootAccessible;
|
|
|
|
static BOOL gIsAccessibilityOn;
|
|
|
|
static HINSTANCE gmAccLib;
|
|
|
|
static LPFNLRESULTFROMOBJECT gmLresultFromObject;
|
|
|
|
static STDMETHODIMP_(LRESULT) LresultFromObject(REFIID riid, WPARAM wParam, LPUNKNOWN pAcc);
|
2001-08-17 03:13:07 +00:00
|
|
|
#endif
|
2002-06-04 17:47:54 +00:00
|
|
|
|
2004-09-03 08:44:23 +00:00
|
|
|
static BOOL CALLBACK BroadcastMsgToChildren(HWND aWnd, LPARAM aMsg);
|
|
|
|
static BOOL CALLBACK BroadcastMsg(HWND aTopWindow, LPARAM aMsg);
|
|
|
|
static BOOL CALLBACK DispatchStarvedPaints(HWND aTopWindow, LPARAM aMsg);
|
2002-09-20 01:24:36 +00:00
|
|
|
|
2002-06-04 17:47:54 +00:00
|
|
|
public:
|
2004-09-03 08:44:23 +00:00
|
|
|
static void GlobalMsgWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
1998-04-13 20:24:54 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
//
|
|
|
|
// A child window is a window with different style
|
|
|
|
//
|
|
|
|
class ChildWindow : public nsWindow {
|
|
|
|
|
|
|
|
public:
|
2004-09-03 08:44:23 +00:00
|
|
|
ChildWindow() {}
|
|
|
|
PRBool DispatchMouseEvent(PRUint32 aEventType, WPARAM wParam = NULL, nsPoint* aPoint = nsnull);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
|
|
|
protected:
|
2004-09-03 08:44:23 +00:00
|
|
|
virtual DWORD WindowStyle();
|
1998-04-13 20:24:54 +00:00
|
|
|
};
|
|
|
|
|
1998-04-17 23:45:07 +00:00
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
#endif // Window_h__
|