gecko-dev/widget/src/windows/nsWindow.cpp

2064 lines
58 KiB
C++
Raw Normal View History

1998-04-13 20:24:54 +00:00
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
#include "nsWindow.h"
#include "nsIAppShell.h"
1998-04-13 20:24:54 +00:00
#include "nsIFontMetrics.h"
#include "nsFont.h"
1998-04-13 20:24:54 +00:00
#include "nsGUIEvent.h"
#include "nsIRenderingContext.h"
#include "nsIDeviceContext.h"
#include "nsRect.h"
#include "nsTransform2D.h"
#include "nsStringUtil.h"
1998-04-13 20:24:54 +00:00
#include <windows.h>
#include "nsGfxCIID.h"
#include "resource.h"
1998-04-17 00:16:11 +00:00
#include <commctrl.h>
1998-04-13 20:24:54 +00:00
#include "prtime.h"
#include "nsIRenderingContextWin.h"
1998-04-13 20:24:54 +00:00
BOOL nsWindow::sIsRegistered = FALSE;
1998-05-29 22:44:13 +00:00
nsWindow* nsWindow::gCurrentWindow = nsnull;
#define IS_VK_DOWN(a) (PRBool)(((GetKeyState(a) & 0x80)) ? (PR_TRUE) : (PR_FALSE))
// Global variable
// g_hinst - handle of the application instance
extern HINSTANCE g_hinst;
1998-04-13 20:24:54 +00:00
static NS_DEFINE_IID(kIWidgetIID, NS_IWIDGET_IID);
//-------------------------------------------------------------------------
//
// nsWindow constructor
//
//-------------------------------------------------------------------------
nsWindow::nsWindow() : nsBaseWidget()
{
NS_INIT_REFCNT();
mWnd = 0;
mPrevWndProc = NULL;
mBackground = ::GetSysColor(COLOR_BTNFACE);
mBrush = ::CreateSolidBrush(NSRGB_2_COLOREF(mBackground));
mForeground = ::GetSysColor(COLOR_WINDOWTEXT);
mPalette = NULL;
mIsShiftDown = PR_FALSE;
mIsControlDown = PR_FALSE;
mIsAltDown = PR_FALSE;
mIsDestroying = PR_FALSE;
mOnDestroyCalled = PR_FALSE;
mTooltip = NULL;
mDeferredPositioner = NULL;
mLastPoint.x = 0;
mLastPoint.y = 0;
mPreferredWidth = 0;
mPreferredHeight = 0;
mFont = nsnull;
mIsVisible = PR_FALSE;
mHas3DBorder = PR_FALSE;
}
//-------------------------------------------------------------------------
//
// nsWindow destructor
//
//-------------------------------------------------------------------------
nsWindow::~nsWindow()
{
mIsDestroying = PR_TRUE;
if (gCurrentWindow == this) {
gCurrentWindow = nsnull;
}
MouseTrailer * mouseTrailer = MouseTrailer::GetMouseTrailer(0);
if (mouseTrailer->GetMouseTrailerWindow() == this) {
mouseTrailer->DestroyTimer();
}
// If the widget was released without calling Destroy() then the native
// window still exists, and we need to destroy it
if (NULL != mWnd) {
Destroy();
}
//XXX Temporary: Should not be caching the font
delete mFont;
}
1998-05-14 21:34:08 +00:00
//-------------------------------------------------------------------------
//
// Default for height modification is to do nothing
//
//-------------------------------------------------------------------------
PRInt32 nsWindow::GetHeight(PRInt32 aProposedHeight)
{
return(aProposedHeight);
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Deferred Window positioning
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::BeginResizingChildren(void)
{
if (NULL == mDeferredPositioner)
mDeferredPositioner = ::BeginDeferWindowPos(1);
return NS_OK;
}
NS_METHOD nsWindow::EndResizingChildren(void)
{
if (NULL != mDeferredPositioner) {
::EndDeferWindowPos(mDeferredPositioner);
mDeferredPositioner = NULL;
}
return NS_OK;
}
// DoCreateTooltip - creates a tooltip control and adds some tools
// to it.
// Returns the handle of the tooltip control if successful or NULL
// otherwise.
// hwndOwner - handle of the owner window
//
void nsWindow::AddTooltip(HWND hwndOwner,nsRect* aRect, int aId)
{
TOOLINFO ti; // tool information
memset(&ti, 0, sizeof(TOOLINFO));
// Make sure the common control DLL is loaded
InitCommonControls();
// Create a tooltip control for the window if needed
if (mTooltip == (HWND) NULL) {
mTooltip = CreateWindow(TOOLTIPS_CLASS, (LPSTR) NULL, TTS_ALWAYSTIP,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
NULL, (HMENU) NULL,
nsToolkit::mDllInstance,
NULL);
}
if (mTooltip == (HWND) NULL)
return;
ti.cbSize = sizeof(TOOLINFO);
ti.uFlags = TTF_SUBCLASS;
ti.hwnd = hwndOwner;
ti.hinst = nsToolkit::mDllInstance;
ti.uId = aId;
ti.lpszText = (LPSTR)" "; // must set text to
// something for tooltip to give events;
ti.rect.left = aRect->x;
ti.rect.top = aRect->y;
ti.rect.right = aRect->x + aRect->width;
ti.rect.bottom = aRect->y + aRect->height;
if (!SendMessage(mTooltip, TTM_ADDTOOL, 0,
(LPARAM) (LPTOOLINFO) &ti))
return;
}
NS_METHOD nsWindow::WidgetToScreen(const nsRect& aOldRect, nsRect& aNewRect)
{
POINT point;
point.x = aOldRect.x;
point.y = aOldRect.y;
::ClientToScreen((HWND)GetNativeData(NS_NATIVE_WINDOW), &point);
aNewRect.x = point.x;
aNewRect.y = point.y;
aNewRect.width = aOldRect.width;
aNewRect.height = aOldRect.height;
return NS_OK;
}
NS_METHOD nsWindow::ScreenToWidget(const nsRect& aOldRect, nsRect& aNewRect)
{
POINT point;
point.x = aOldRect.x;
point.y = aOldRect.y;
::ScreenToClient((HWND)GetNativeData(NS_NATIVE_WINDOW), &point);
aNewRect.x = point.x;
aNewRect.y = point.y;
aNewRect.width = aOldRect.width;
aNewRect.height = aOldRect.height;
return NS_OK;
}
//-------------------------------------------------------------------------
//
// Setup initial tooltip rectangles
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::SetTooltips(PRUint32 aNumberOfTips,nsRect* aTooltipAreas[])
{
RemoveTooltips();
for (int i = 0; i < (int)aNumberOfTips; i++) {
AddTooltip(mWnd, aTooltipAreas[i], i);
}
return NS_OK;
}
//-------------------------------------------------------------------------
//
// Update all tooltip rectangles
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::UpdateTooltips(nsRect* aNewTips[])
{
TOOLINFO ti;
memset(&ti, 0, sizeof(TOOLINFO));
ti.cbSize = sizeof(TOOLINFO);
ti.hwnd = mWnd;
// Get the number of tooltips
UINT count = ::SendMessage(mTooltip, TTM_GETTOOLCOUNT, 0, 0);
NS_ASSERTION(count > 0, "Called UpdateTooltips before calling SetTooltips");
for (UINT i = 0; i < count; i++) {
ti.uId = i;
int result =::SendMessage(mTooltip, TTM_ENUMTOOLS, i, (LPARAM) (LPTOOLINFO)&ti);
nsRect* newTip = aNewTips[i];
ti.rect.left = newTip->x;
ti.rect.top = newTip->y;
ti.rect.right = newTip->x + newTip->width;
ti.rect.bottom = newTip->y + newTip->height;
::SendMessage(mTooltip, TTM_NEWTOOLRECT, 0, (LPARAM) (LPTOOLINFO)&ti);
}
return NS_OK;
}
//-------------------------------------------------------------------------
//
// Remove all tooltip rectangles
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::RemoveTooltips()
{
TOOLINFO ti;
memset(&ti, 0, sizeof(TOOLINFO));
ti.cbSize = sizeof(TOOLINFO);
long val;
if (mTooltip == NULL)
return NS_ERROR_FAILURE;
// Get the number of tooltips
UINT count = ::SendMessage(mTooltip, TTM_GETTOOLCOUNT, 0, (LPARAM)&val);
for (UINT i = 0; i < count; i++) {
ti.uId = i;
ti.hwnd = mWnd;
::SendMessage(mTooltip, TTM_DELTOOL, 0, (LPARAM) (LPTOOLINFO)&ti);
}
return NS_OK;
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Convert nsEventStatus value to a windows boolean
//
//-------------------------------------------------------------------------
PRBool nsWindow::ConvertStatus(nsEventStatus aStatus)
{
switch(aStatus) {
1998-09-15 00:14:11 +00:00
case nsEventStatus_eIgnore:
return PR_FALSE;
case nsEventStatus_eConsumeNoDefault:
return PR_TRUE;
case nsEventStatus_eConsumeDoDefault:
return PR_FALSE;
default:
NS_ASSERTION(0, "Illegal nsEventStatus enumeration value");
1998-04-13 20:24:54 +00:00
break;
}
1998-09-15 00:14:11 +00:00
return PR_FALSE;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Initialize an event to dispatch
//
//-------------------------------------------------------------------------
1998-05-29 22:44:13 +00:00
void nsWindow::InitEvent(nsGUIEvent& event, PRUint32 aEventType, nsPoint* aPoint)
{
event.widget = this;
NS_ADDREF(event.widget);
1998-05-29 22:44:13 +00:00
if (nsnull == aPoint) { // use the point from the event
// get the message position in client coordinates and in twips
DWORD pos = ::GetMessagePos();
POINT cpos;
1998-05-29 22:44:13 +00:00
cpos.x = LOWORD(pos);
cpos.y = HIWORD(pos);
if (mWnd != NULL) {
::ScreenToClient(mWnd, &cpos);
event.point.x = cpos.x;
event.point.y = cpos.y;
1998-08-04 21:06:35 +00:00
} else {
event.point.x = 0;
event.point.y = 0;
}
1998-05-29 22:44:13 +00:00
}
else { // use the point override if provided
event.point.x = aPoint->x;
event.point.y = aPoint->y;
}
event.time = ::GetMessageTime();
event.message = aEventType;
1998-05-29 22:44:13 +00:00
mLastPoint.x = event.point.x;
mLastPoint.y = event.point.y;
}
//-------------------------------------------------------------------------
//
// Invokes callback and ProcessEvent method on Event Listener object
//
//-------------------------------------------------------------------------
NS_IMETHODIMP nsWindow::DispatchEvent(nsGUIEvent* event, nsEventStatus & aStatus)
{
aStatus = nsEventStatus_eIgnore;
if (nsnull != mEventCallback) {
aStatus = (*mEventCallback)(event);
}
// Dispatch to event listener if event was not consumed
if ((aStatus != nsEventStatus_eIgnore) && (nsnull != mEventListener)) {
aStatus = mEventListener->ProcessEvent(*event);
}
nsWindow * thisPtr = this;
return NS_OK;
}
//-------------------------------------------------------------------------
PRBool nsWindow::DispatchWindowEvent(nsGUIEvent* event)
{
nsEventStatus status;
DispatchEvent(event, status);
return ConvertStatus(status);
}
//-------------------------------------------------------------------------
//
// Dispatch standard event
//
//-------------------------------------------------------------------------
PRBool nsWindow::DispatchStandardEvent(PRUint32 aMsg)
{
nsGUIEvent event;
event.eventStructType = NS_GUI_EVENT;
InitEvent(event, aMsg);
PRBool result = DispatchWindowEvent(&event);
NS_RELEASE(event.widget);
return result;
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// the nsWindow procedure for all nsWindows in this toolkit
//
//-------------------------------------------------------------------------
LRESULT CALLBACK nsWindow::WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
1998-04-17 00:16:11 +00:00
// Get the window which caused the event and ask it to process the message
1998-04-13 20:24:54 +00:00
nsWindow *someWindow = (nsWindow*)::GetWindowLong(hWnd, GWL_USERDATA);
1998-04-17 00:16:11 +00:00
// Re-direct a tab change message destined for it's parent window to the
// the actual window which generated the event.
if (msg == WM_NOTIFY) {
LPNMHDR pnmh = (LPNMHDR) lParam;
if (pnmh->code == TCN_SELCHANGE) {
someWindow = (nsWindow*)::GetWindowLong(pnmh->hwndFrom, GWL_USERDATA);
}
}
1998-04-13 20:24:54 +00:00
if (nsnull != someWindow) {
LRESULT retValue;
if (PR_TRUE == someWindow->ProcessMessage(msg, wParam, lParam, &retValue)) {
return retValue;
}
}
#if defined(STRICT)
return ::CallWindowProc((WNDPROC)someWindow->GetPrevWindowProc(), hWnd,
msg, wParam, lParam);
#else
return ::CallWindowProc((FARPROC)someWindow->GetPrevWindowProc(), hWnd,
msg, wParam, lParam);
#endif
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Utility method for implementing both Create(nsIWidget ...) and
// Create(nsNativeWidget...)
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
nsresult nsWindow::StandardWindowCreate(nsIWidget *aParent,
1998-04-13 20:24:54 +00:00
const nsRect &aRect,
EVENT_CALLBACK aHandleEventFunction,
nsIDeviceContext *aContext,
nsIAppShell *aAppShell,
nsIToolkit *aToolkit,
nsWidgetInitData *aInitData,
nsNativeWidget aNativeParent)
1998-04-13 20:24:54 +00:00
{
BaseCreate(aParent, aRect, aHandleEventFunction, aContext,
aAppShell, aToolkit, aInitData);
// See if the caller wants to explictly set clip children
DWORD style = WindowStyle();
if (nsnull != aInitData) {
if (aInitData->clipChildren) {
style |= WS_CLIPCHILDREN;
} else {
style &= ~WS_CLIPCHILDREN;
}
}
1998-04-13 20:24:54 +00:00
// Switch to the "main gui thread" if necessary... This method must
// be executed on the "gui thread"...
//
nsToolkit* toolkit = (nsToolkit *)mToolkit;
if (! toolkit->IsGuiThread()) {
1998-04-13 20:24:54 +00:00
DWORD args[5];
args[0] = (DWORD)aParent;
args[1] = (DWORD)&aRect;
args[2] = (DWORD)aHandleEventFunction;
args[3] = (DWORD)aContext;
args[4] = (DWORD)aToolkit;
args[5] = (DWORD)aInitData;
1998-04-13 20:24:54 +00:00
if (nsnull != aParent) {
// nsIWidget parent dispatch
MethodInfo info(this, nsWindow::CREATE, 6, args);
toolkit->CallMethod(&info);
return NS_OK;
}
else {
// Native parent dispatch
MethodInfo info(this, nsWindow::CREATE_NATIVE, 5, args);
toolkit->CallMethod(&info);
return NS_OK;
}
}
HWND parent;
if (nsnull != aParent) { // has a nsIWidget parent
parent = ((aParent) ? (HWND)aParent->GetNativeData(NS_NATIVE_WINDOW) : nsnull);
} else { // has a nsNative parent
parent = (HWND)aNativeParent;
}
DWORD extendedStyle = WindowExStyle();
1998-11-02 19:13:05 +00:00
if (nsnull != aInitData) {
if (aInitData->mBorderStyle == eBorderStyle_dialog ||
aInitData->mBorderStyle == eBorderStyle_none) {
extendedStyle &= ~WS_EX_CLIENTEDGE;
1998-11-02 19:13:05 +00:00
} else if (aInitData->mBorderStyle == eBorderStyle_3DChildWindow) {
extendedStyle |= WS_EX_CLIENTEDGE;
}
}
mHas3DBorder = (extendedStyle & WS_EX_CLIENTEDGE) > 0;
mWnd = ::CreateWindowEx(extendedStyle,
1998-04-13 20:24:54 +00:00
WindowClass(),
"",
style,
1998-04-13 20:24:54 +00:00
aRect.x,
aRect.y,
aRect.width,
1998-05-14 21:34:08 +00:00
GetHeight(aRect.height),
parent,
1998-04-13 20:24:54 +00:00
NULL,
nsToolkit::mDllInstance,
NULL);
VERIFY(mWnd);
1998-04-13 20:24:54 +00:00
// call the event callback to notify about creation
DispatchStandardEvent(NS_CREATE);
1998-04-13 20:24:54 +00:00
SubclassWindow(TRUE);
return(NS_OK);
}
//-------------------------------------------------------------------------
//
// Create the proper widget
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Create(nsIWidget *aParent,
const nsRect &aRect,
EVENT_CALLBACK aHandleEventFunction,
nsIDeviceContext *aContext,
nsIAppShell *aAppShell,
nsIToolkit *aToolkit,
nsWidgetInitData *aInitData)
{
return(StandardWindowCreate(aParent, aRect, aHandleEventFunction,
aContext, aAppShell, aToolkit, aInitData,
nsnull));
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// create with a native parent
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Create(nsNativeWidget aParent,
1998-04-13 20:24:54 +00:00
const nsRect &aRect,
EVENT_CALLBACK aHandleEventFunction,
nsIDeviceContext *aContext,
nsIAppShell *aAppShell,
nsIToolkit *aToolkit,
1998-05-14 21:34:08 +00:00
nsWidgetInitData *aInitData)
1998-04-13 20:24:54 +00:00
{
return(StandardWindowCreate(nsnull, aRect, aHandleEventFunction,
aContext, aAppShell, aToolkit, aInitData,
aParent));
1998-04-13 20:24:54 +00:00
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Close this nsWindow
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Destroy()
1998-04-13 20:24:54 +00:00
{
// Switch to the "main gui thread" if necessary... This method must
// be executed on the "gui thread"...
nsToolkit* toolkit = (nsToolkit *)mToolkit;
if (toolkit != nsnull && !toolkit->IsGuiThread()) {
MethodInfo info(this, nsWindow::DESTROY);
toolkit->CallMethod(&info);
return NS_ERROR_FAILURE;
}
1998-04-13 20:24:54 +00:00
// disconnect from the parent
if (!mIsDestroying) {
nsBaseWidget::Destroy();
}
// destroy the HWND
if (mWnd) {
// prevent the widget from causing additional events
mEventCallback = nsnull;
VERIFY(::DestroyWindow(mWnd));
mWnd = NULL;
//our windows can be subclassed by
//others and these namless, faceless others
//may not let us know about WM_DESTROY. so,
//if OnDestroy() didn't get called, just call
//it now. MMP
if (PR_FALSE == mOnDestroyCalled)
OnDestroy();
}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Get this nsWindow parent
//
//-------------------------------------------------------------------------
nsIWidget* nsWindow::GetParent(void)
{
nsWindow* widget = NULL;
1998-04-13 20:24:54 +00:00
if (mWnd) {
HWND parent = ::GetParent(mWnd);
if (parent) {
widget = (nsWindow *)::GetWindowLong(parent, GWL_USERDATA);
if (widget) {
// If the widget is in the process of being destroyed then
// do NOT return it
if (widget->mIsDestroying) {
widget = NULL;
} else {
NS_ADDREF(widget);
}
}
1998-04-13 20:24:54 +00:00
}
}
return (nsIWidget*)widget;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Hide or show this component
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Show(PRBool bState)
1998-04-13 20:24:54 +00:00
{
if (mWnd) {
if (bState) {
::SetWindowPos(mWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW);
}
else
::ShowWindow(mWnd, SW_HIDE);
}
mIsVisible = bState;
return NS_OK;
}
//-------------------------------------------------------------------------
//
// Return PR_TRUE if the whether the component is visible, PR_FALSE otherwise
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::IsVisible(PRBool & bState)
{
bState = mIsVisible;
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Move this component
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Move(PRUint32 aX, PRUint32 aY)
1998-04-13 20:24:54 +00:00
{
mBounds.x = aX;
mBounds.y = aY;
1998-04-13 20:24:54 +00:00
if (mWnd) {
nsIWidget *par = GetParent();
HDWP deferrer = NULL;
if (nsnull != par) {
deferrer = ((nsWindow *)par)->mDeferredPositioner;
}
if (NULL != deferrer) {
VERIFY(((nsWindow *)par)->mDeferredPositioner = ::DeferWindowPos(deferrer,
mWnd, NULL, aX, aY, 0, 0,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE));
}
else {
VERIFY(::SetWindowPos(mWnd, NULL, aX, aY, 0, 0,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE));
}
NS_IF_RELEASE(par);
1998-04-13 20:24:54 +00:00
}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Resize this component
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Resize(PRUint32 aWidth, PRUint32 aHeight, PRBool aRepaint)
1998-04-13 20:24:54 +00:00
{
// Set cached value for lightweight and printing
mBounds.width = aWidth;
mBounds.height = aHeight;
1998-04-13 20:24:54 +00:00
if (mWnd) {
nsIWidget *par = GetParent();
HDWP deferrer = NULL;
if (nsnull != par) {
deferrer = ((nsWindow *)par)->mDeferredPositioner;
}
UINT flags = SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE;
if (!aRepaint) {
flags |= SWP_NOREDRAW;
}
if (NULL != deferrer) {
VERIFY(((nsWindow *)par)->mDeferredPositioner = ::DeferWindowPos(deferrer,
mWnd, NULL, 0, 0, aWidth, GetHeight(aHeight), flags));
}
else {
1998-05-14 21:34:08 +00:00
VERIFY(::SetWindowPos(mWnd, NULL, 0, 0, aWidth, GetHeight(aHeight),
flags));
}
NS_IF_RELEASE(par);
1998-04-13 20:24:54 +00:00
}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Resize this component
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Resize(PRUint32 aX,
PRUint32 aY,
PRUint32 aWidth,
PRUint32 aHeight,
PRBool aRepaint)
1998-04-13 20:24:54 +00:00
{
// Set cached value for lightweight and printing
mBounds.x = aX;
mBounds.y = aY;
mBounds.width = aWidth;
mBounds.height = aHeight;
1998-04-13 20:24:54 +00:00
if (mWnd) {
nsIWidget *par = GetParent();
HDWP deferrer = NULL;
if (nsnull != par) {
deferrer = ((nsWindow *)par)->mDeferredPositioner;
}
UINT flags = SWP_NOZORDER | SWP_NOACTIVATE;
if (!aRepaint) {
flags |= SWP_NOREDRAW;
}
if (NULL != deferrer) {
VERIFY(((nsWindow *)par)->mDeferredPositioner = ::DeferWindowPos(deferrer,
mWnd, NULL, aX, aY, aWidth, GetHeight(aHeight),
flags));
}
else {
1998-05-14 21:34:08 +00:00
VERIFY(::SetWindowPos(mWnd, NULL, aX, aY, aWidth, GetHeight(aHeight),
flags));
}
NS_IF_RELEASE(par);
1998-04-13 20:24:54 +00:00
}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Enable/disable this component
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Enable(PRBool bState)
1998-04-13 20:24:54 +00:00
{
if (mWnd) {
::EnableWindow(mWnd, bState);
}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Give the focus to this component
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::SetFocus(void)
1998-04-13 20:24:54 +00:00
{
//
// Switch to the "main gui thread" if necessary... This method must
// be executed on the "gui thread"...
//
nsToolkit* toolkit = (nsToolkit *)mToolkit;
if (!toolkit->IsGuiThread()) {
1998-04-13 20:24:54 +00:00
MethodInfo info(this, nsWindow::SET_FOCUS);
toolkit->CallMethod(&info);
return NS_ERROR_FAILURE;
1998-04-13 20:24:54 +00:00
}
if (mWnd) {
::SetFocus(mWnd);
}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Get this component dimension
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::GetBounds(nsRect &aRect)
1998-04-13 20:24:54 +00:00
{
if (mWnd) {
RECT r;
VERIFY(::GetWindowRect(mWnd, &r));
// assign size
aRect.width = r.right - r.left;
aRect.height = r.bottom - r.top;
// convert coordinates if parent exists
HWND parent = ::GetParent(mWnd);
if (parent) {
RECT pr;
VERIFY(::GetWindowRect(parent, &pr));
r.left -= pr.left;
r.top -= pr.top;
}
aRect.x = r.left;
aRect.y = r.top;
} else {
aRect = mBounds;
}
1998-04-13 20:24:54 +00:00
return NS_OK;
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Get this component dimension
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::GetClientBounds(nsRect &aRect)
{
if (mWnd) {
RECT r;
VERIFY(::GetClientRect(mWnd, &r));
// assign size
aRect.x = 0;
aRect.y = 0;
aRect.width = r.right - r.left;
aRect.height = r.bottom - r.top;
} else {
aRect.SetRect(0,0,0,0);
}
return NS_OK;
}
//get the bounds, but don't take into account the client size
void nsWindow::GetNonClientBounds(nsRect &aRect)
{
if (mWnd) {
RECT r;
VERIFY(::GetWindowRect(mWnd, &r));
// assign size
aRect.width = r.right - r.left;
aRect.height = r.bottom - r.top;
// convert coordinates if parent exists
HWND parent = ::GetParent(mWnd);
if (parent) {
RECT pr;
VERIFY(::GetWindowRect(parent, &pr));
r.left -= pr.left;
r.top -= pr.top;
}
aRect.x = r.left;
aRect.y = r.top;
} else {
aRect.SetRect(0,0,0,0);
}
1998-04-13 20:24:54 +00:00
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Set the background color
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::SetBackgroundColor(const nscolor &aColor)
1998-04-13 20:24:54 +00:00
{
nsBaseWidget::SetBackgroundColor(aColor);
if (mBrush)
::DeleteObject(mBrush);
1998-04-13 20:24:54 +00:00
mBrush = ::CreateSolidBrush(NSRGB_2_COLOREF(mBackground));
if (mWnd != NULL) {
SetClassLong(mWnd, GCL_HBRBACKGROUND, (LONG)mBrush);
}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Get this component font
//
//-------------------------------------------------------------------------
nsIFontMetrics* nsWindow::GetFont(void)
{
NS_NOTYETIMPLEMENTED("GetFont not yet implemented"); // to be implemented
return NULL;
}
//-------------------------------------------------------------------------
//
// Set this component font
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::SetFont(const nsFont &aFont)
1998-04-13 20:24:54 +00:00
{
// Cache Font for owner draw
if (mFont == nsnull) {
mFont = new nsFont(aFont);
} else {
*mFont = aFont;
}
// Bail out if there is no context
if (nsnull == mContext) {
return NS_ERROR_FAILURE;
}
nsIFontMetrics* metrics;
mContext->GetMetricsFor(aFont, metrics);
nsFontHandle fontHandle;
metrics->GetFontHandle(fontHandle);
HFONT hfont = (HFONT)fontHandle;
// Draw in the new font
::SendMessage(mWnd, WM_SETFONT, (WPARAM)hfont, (LPARAM)0);
NS_RELEASE(metrics);
return NS_OK;
1998-04-13 20:24:54 +00:00
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Set this component cursor
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::SetCursor(nsCursor aCursor)
1998-04-13 20:24:54 +00:00
{
1998-04-13 20:24:54 +00:00
// Only change cursor if it's changing
//XXX mCursor isn't always right. Scrollbars and others change it, too.
//XXX If we want this optimization we need a better way to do it.
//if (aCursor != mCursor) {
1998-04-13 20:24:54 +00:00
HCURSOR newCursor = NULL;
switch(aCursor) {
case eCursor_select:
newCursor = ::LoadCursor(NULL, IDC_IBEAM);
break;
case eCursor_wait:
newCursor = ::LoadCursor(NULL, IDC_WAIT);
break;
case eCursor_hyperlink: {
newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_SELECTANCHOR));
1998-04-13 20:24:54 +00:00
break;
}
case eCursor_standard:
newCursor = ::LoadCursor(NULL, IDC_ARROW);
break;
case eCursor_sizeWE:
newCursor = ::LoadCursor(NULL, IDC_SIZEWE);
break;
case eCursor_sizeNS:
newCursor = ::LoadCursor(NULL, IDC_SIZENS);
break;
1998-08-07 14:45:46 +00:00
case eCursor_arrow_north:
newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ARROWNORTH));
1998-08-07 14:45:46 +00:00
break;
case eCursor_arrow_north_plus:
newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ARROWNORTHPLUS));
1998-08-07 14:45:46 +00:00
break;
case eCursor_arrow_south:
newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ARROWSOUTH));
1998-08-07 14:45:46 +00:00
break;
case eCursor_arrow_south_plus:
newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ARROWSOUTHPLUS));
1998-08-07 14:45:46 +00:00
break;
case eCursor_arrow_east:
newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ARROWEAST));
1998-08-07 14:45:46 +00:00
break;
case eCursor_arrow_east_plus:
newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ARROWEASTPLUS));
1998-08-07 14:45:46 +00:00
break;
case eCursor_arrow_west:
newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ARROWWEST));
1998-08-07 14:45:46 +00:00
break;
case eCursor_arrow_west_plus:
newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ARROWWESTPLUS));
1998-08-07 14:45:46 +00:00
break;
1998-04-13 20:24:54 +00:00
default:
NS_ASSERTION(0, "Invalid cursor type");
break;
}
if (NULL != newCursor) {
mCursor = aCursor;
HCURSOR oldCursor = ::SetCursor(newCursor);
}
//}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Invalidate this component visible area
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Invalidate(PRBool aIsSynchronous)
1998-04-13 20:24:54 +00:00
{
if (mWnd) {
VERIFY(::InvalidateRect(mWnd, NULL, TRUE));
if (aIsSynchronous) {
VERIFY(::UpdateWindow(mWnd));
}
}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Invalidate this component visible area
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Invalidate(const nsRect & aRect, PRBool aIsSynchronous)
{
RECT rect;
if (mWnd) {
rect.left = aRect.x;
rect.top = aRect.y;
rect.right = aRect.x + aRect.width;
rect.bottom = aRect.y + aRect.height;
VERIFY(::InvalidateRect(mWnd, &rect, TRUE));
if (aIsSynchronous) {
VERIFY(::UpdateWindow(mWnd));
}
}
return NS_OK;
}
//-------------------------------------------------------------------------
//
// Force a synchronous repaint of the window
//
//-------------------------------------------------------------------------
NS_IMETHODIMP nsWindow::Update()
{
VERIFY(::UpdateWindow(mWnd));
return NS_OK;
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Return some native data according to aDataType
//
//-------------------------------------------------------------------------
void* nsWindow::GetNativeData(PRUint32 aDataType)
{
switch(aDataType) {
case NS_NATIVE_WIDGET:
1998-04-13 20:24:54 +00:00
case NS_NATIVE_WINDOW:
return (void*)mWnd;
case NS_NATIVE_GRAPHIC:
// XXX: This is sleezy!! Remember to Release the DC after using it!
1998-04-13 20:24:54 +00:00
return (void*)::GetDC(mWnd);
case NS_NATIVE_COLORMAP:
default:
break;
}
return NULL;
}
//-------------------------------------------------------------------------
//
// Set the colormap of the window
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::SetColorMap(nsColorMap *aColorMap)
1998-04-13 20:24:54 +00:00
{
if (mPalette != NULL) {
::DeleteObject(mPalette);
}
PRUint8 *map = aColorMap->Index;
LPLOGPALETTE pLogPal = (LPLOGPALETTE) new char[2 * sizeof(WORD) +
aColorMap->NumColors * sizeof(PALETTEENTRY)];
pLogPal->palVersion = 0x300;
pLogPal->palNumEntries = aColorMap->NumColors;
for(int i = 0; i < aColorMap->NumColors; i++)
{
pLogPal->palPalEntry[i].peRed = *map++;
pLogPal->palPalEntry[i].peGreen = *map++;
pLogPal->palPalEntry[i].peBlue = *map++;
pLogPal->palPalEntry[i].peFlags = 0;
}
mPalette = ::CreatePalette(pLogPal);
delete pLogPal;
NS_ASSERTION(mPalette != NULL, "Null palette");
if (mPalette != NULL) {
HDC hDC = ::GetDC(mWnd);
HPALETTE hOldPalette = ::SelectPalette(hDC, mPalette, TRUE);
::RealizePalette(hDC);
::SelectPalette(hDC, hOldPalette, TRUE);
::ReleaseDC(mWnd, hDC);
}
return NS_OK;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Scroll the bits of a window
//
//-------------------------------------------------------------------------
NS_METHOD nsWindow::Scroll(PRInt32 aDx, PRInt32 aDy, nsRect *aClipRect)
1998-04-13 20:24:54 +00:00
{
RECT trect;
if (nsnull != aClipRect)
{
trect.left = aClipRect->x;
trect.top = aClipRect->y;
trect.right = aClipRect->XMost();
trect.bottom = aClipRect->YMost();
}
::ScrollWindowEx(mWnd, aDx, aDy, (nsnull != aClipRect) ? &trect : NULL, NULL,
NULL, NULL, SW_INVALIDATE | SW_SCROLLCHILDREN);
1998-04-13 20:24:54 +00:00
::UpdateWindow(mWnd);
return NS_OK;
1998-04-13 20:24:54 +00:00
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Every function that needs a thread switch goes through this function
// by calling SendMessage (..WM_CALLMETHOD..) in nsToolkit::CallMethod.
//
//-------------------------------------------------------------------------
BOOL nsWindow::CallMethod(MethodInfo *info)
{
BOOL bRet = TRUE;
switch (info->methodId) {
case nsWindow::CREATE:
NS_ASSERTION(info->nArgs == 7, "Wrong number of arguments to CallMethod");
1998-04-13 20:24:54 +00:00
Create((nsIWidget*)(info->args[0]),
(nsRect&)*(nsRect*)(info->args[1]),
(EVENT_CALLBACK)(info->args[2]),
(nsIDeviceContext*)(info->args[3]),
(nsIAppShell *)(info->args[4]),
(nsIToolkit*)(info->args[5]),
(nsWidgetInitData*)(info->args[6]));
1998-04-13 20:24:54 +00:00
break;
case nsWindow::CREATE_NATIVE:
NS_ASSERTION(info->nArgs == 7, "Wrong number of arguments to CallMethod");
Create((nsNativeWidget)(info->args[0]),
1998-04-13 20:24:54 +00:00
(nsRect&)*(nsRect*)(info->args[1]),
(EVENT_CALLBACK)(info->args[2]),
(nsIDeviceContext*)(info->args[3]),
(nsIAppShell *)(info->args[4]),
(nsIToolkit*)(info->args[5]),
(nsWidgetInitData*)(info->args[6]));
1998-04-13 20:24:54 +00:00
return TRUE;
case nsWindow::DESTROY:
NS_ASSERTION(info->nArgs == 0, "Wrong number of arguments to CallMethod");
Destroy();
break;
case nsWindow::SET_FOCUS:
NS_ASSERTION(info->nArgs == 0, "Wrong number of arguments to CallMethod");
SetFocus();
break;
default:
bRet = FALSE;
break;
}
return bRet;
}
//-------------------------------------------------------------------------
//
// OnKey
//
//-------------------------------------------------------------------------
PRBool nsWindow::OnKey(PRUint32 aEventType, PRUint32 aKeyCode)
{
nsKeyEvent event;
nsPoint point;
point.x = 0;
point.y = 0;
InitEvent(event, aEventType, &point);
event.keyCode = aKeyCode;
event.isShift = mIsShiftDown;
event.isControl = mIsControlDown;
event.isAlt = mIsAltDown;
event.eventStructType = NS_KEY_EVENT;
PRBool result = DispatchWindowEvent(&event);
NS_RELEASE(event.widget);
return result;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
void nsWindow::SetUpForPaint(HDC aHDC)
{
::SetBkColor (aHDC, NSRGB_2_COLOREF(mBackground));
::SetTextColor(aHDC, NSRGB_2_COLOREF(mForeground));
::SetBkMode (aHDC, TRANSPARENT);
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Process all nsWindows messages
//
//-------------------------------------------------------------------------
PRBool nsWindow::ProcessMessage(UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *aRetValue)
{
PRBool result = PR_FALSE; // call the default nsWindow proc
nsPaletteInfo palInfo;
1998-04-13 20:24:54 +00:00
*aRetValue = 0;
switch (msg) {
case WM_COMMAND: {
WORD wNotifyCode = HIWORD(wParam); // notification code
if (wNotifyCode == 0) { // Menu selection
nsMenuEvent event;
event.mCommand = LOWORD(wParam);
event.eventStructType = NS_MENU_EVENT;
InitEvent(event, NS_MENU_SELECTED);
result = DispatchWindowEvent(&event);
NS_RELEASE(event.widget);
}
}
break;
1998-04-17 00:16:11 +00:00
case WM_NOTIFY:
// TAB change
{
LPNMHDR pnmh = (LPNMHDR) lParam;
switch (pnmh->code) {
case TCN_SELCHANGE: {
DispatchStandardEvent(NS_TABCHANGE);
result = PR_TRUE;
}
break;
case TTN_SHOW: {
nsTooltipEvent event;
InitEvent(event, NS_SHOW_TOOLTIP);
event.tipIndex = (PRUint32)wParam;
event.eventStructType = NS_TOOLTIP_EVENT;
result = DispatchWindowEvent(&event);
NS_RELEASE(event.widget);
}
break;
case TTN_POP:
result = DispatchStandardEvent(NS_HIDE_TOOLTIP);
break;
}
1998-04-17 00:16:11 +00:00
}
break;
case WM_MOVE: // Window moved
{
1998-05-29 22:44:13 +00:00
PRInt32 x = (PRInt32)LOWORD(lParam); // horizontal position in screen coordinates
PRInt32 y = (PRInt32)HIWORD(lParam); // vertical position in screen coordinates
result = OnMove(x, y);
}
break;
1998-04-17 00:16:11 +00:00
1998-04-13 20:24:54 +00:00
case WM_DESTROY:
// clean up.
OnDestroy();
result = PR_TRUE;
break;
case WM_PAINT:
result = OnPaint();
break;
case WM_KEYUP:
mIsShiftDown = IS_VK_DOWN(NS_VK_SHIFT);
mIsControlDown = IS_VK_DOWN(NS_VK_CONTROL);
mIsAltDown = IS_VK_DOWN(NS_VK_ALT);
1998-04-13 20:24:54 +00:00
result = OnKey(NS_KEY_UP, wParam);
break;
case WM_KEYDOWN:
mIsShiftDown = IS_VK_DOWN(NS_VK_SHIFT);
mIsControlDown = IS_VK_DOWN(NS_VK_CONTROL);
mIsAltDown = IS_VK_DOWN(NS_VK_ALT);
1998-04-13 20:24:54 +00:00
result = OnKey(NS_KEY_DOWN, wParam);
break;
// say we've dealt with erase background if widget does
// not need auto-erasing
case WM_ERASEBKGND:
1998-05-05 19:58:27 +00:00
if (! AutoErase()) {
*aRetValue = 1;
result = PR_TRUE;
}
1998-04-13 20:24:54 +00:00
break;
case WM_MOUSEMOVE:
//RelayMouseEvent(msg,wParam, lParam);
1998-04-13 20:24:54 +00:00
result = DispatchMouseEvent(NS_MOUSE_MOVE);
break;
case WM_LBUTTONDOWN:
//RelayMouseEvent(msg,wParam, lParam);
1998-04-13 20:24:54 +00:00
result = DispatchMouseEvent(NS_MOUSE_LEFT_BUTTON_DOWN);
break;
case WM_LBUTTONUP:
//RelayMouseEvent(msg,wParam, lParam);
1998-04-13 20:24:54 +00:00
result = DispatchMouseEvent(NS_MOUSE_LEFT_BUTTON_UP);
break;
case WM_LBUTTONDBLCLK:
result = DispatchMouseEvent(NS_MOUSE_LEFT_BUTTON_DOWN);
if (result == PR_FALSE)
result = DispatchMouseEvent(NS_MOUSE_LEFT_DOUBLECLICK);
1998-04-13 20:24:54 +00:00
break;
case WM_MBUTTONDOWN:
result = DispatchMouseEvent(NS_MOUSE_MIDDLE_BUTTON_DOWN);
break;
case WM_MBUTTONUP:
result = DispatchMouseEvent(NS_MOUSE_MIDDLE_BUTTON_UP);
break;
case WM_MBUTTONDBLCLK:
result = DispatchMouseEvent(NS_MOUSE_MIDDLE_BUTTON_DOWN);
1998-04-13 20:24:54 +00:00
break;
case WM_RBUTTONDOWN:
result = DispatchMouseEvent(NS_MOUSE_RIGHT_BUTTON_DOWN);
1998-04-13 20:24:54 +00:00
break;
case WM_RBUTTONUP:
result = DispatchMouseEvent(NS_MOUSE_RIGHT_BUTTON_UP);
break;
case WM_RBUTTONDBLCLK:
result = DispatchMouseEvent(NS_MOUSE_RIGHT_BUTTON_DOWN);
if (result == PR_FALSE)
result = DispatchMouseEvent(NS_MOUSE_RIGHT_DOUBLECLICK);
1998-04-13 20:24:54 +00:00
break;
case WM_HSCROLL:
case WM_VSCROLL:
// check for the incoming nsWindow handle to be null in which case
// we assume the message is coming from a horizontal scrollbar inside
// a listbox and we don't bother processing it (well, we don't have to)
if (lParam) {
nsWindow* scrollbar = (nsWindow*)::GetWindowLong((HWND)lParam, GWL_USERDATA);
if (scrollbar) {
result = scrollbar->OnScroll(LOWORD(wParam), (short)HIWORD(wParam));
}
}
break;
case WM_CTLCOLORLISTBOX:
1998-04-13 20:24:54 +00:00
case WM_CTLCOLOREDIT:
case WM_CTLCOLORBTN:
//case WM_CTLCOLORSCROLLBAR: //XXX causes a the scrollbar to be drawn incorrectly
1998-04-13 20:24:54 +00:00
case WM_CTLCOLORSTATIC:
if (lParam) {
nsWindow* control = (nsWindow*)::GetWindowLong((HWND)lParam, GWL_USERDATA);
if (control) {
control->SetUpForPaint((HDC)wParam);
1998-04-13 20:24:54 +00:00
*aRetValue = (LPARAM)control->OnControlColor();
}
1998-04-13 20:24:54 +00:00
}
result = PR_TRUE;
break;
case WM_SETFOCUS:
1998-04-13 20:24:54 +00:00
result = DispatchFocus(NS_GOTFOCUS);
break;
case WM_KILLFOCUS:
result = DispatchFocus(NS_LOSTFOCUS);
break;
1998-04-13 20:24:54 +00:00
case WM_WINDOWPOSCHANGED:
{
WINDOWPOS *wp = (LPWINDOWPOS)lParam;
// We only care about a resize, so filter out things like z-order
// changes. Note: there's a WM_MOVE handler above which is why we're
// not handling them here...
if (0 == (wp->flags & SWP_NOSIZE)) {
// XXX Why are we using the client size area? If the size notification
// is for the client area then the origin should be (0,0) and not
// the window origin in screen coordinates...
RECT r;
::GetWindowRect(mWnd, &r);
1998-06-19 02:46:25 +00:00
PRInt32 newWidth, newHeight;
newWidth = PRInt32(r.right - r.left);
newHeight = PRInt32(r.bottom - r.top);
nsRect rect(wp->x, wp->y, newWidth, newHeight);
//if (newWidth != mBounds.width)
1998-06-19 02:46:25 +00:00
{
RECT drect;
//getting wider
drect.left = wp->x + mBounds.width;
1998-06-19 02:46:25 +00:00
drect.top = wp->y;
drect.right = drect.left + (newWidth - mBounds.width);
1998-06-19 02:46:25 +00:00
drect.bottom = drect.top + newHeight;
// ::InvalidateRect(mWnd, NULL, FALSE);
1998-06-19 02:46:25 +00:00
// ::InvalidateRect(mWnd, &drect, FALSE);
::RedrawWindow(mWnd, &drect, NULL,
RDW_INVALIDATE | RDW_NOERASE | RDW_NOINTERNALPAINT | RDW_ERASENOW | RDW_ALLCHILDREN);
}
//if (newHeight != mBounds.height)
1998-06-19 02:46:25 +00:00
{
RECT drect;
//getting taller
drect.left = wp->x;
drect.top = wp->y + mBounds.height;
1998-06-19 02:46:25 +00:00
drect.right = drect.left + newWidth;
drect.bottom = drect.top + (newHeight - mBounds.height);
1998-06-19 02:46:25 +00:00
// ::InvalidateRect(mWnd, NULL, FALSE);
1998-06-19 02:46:25 +00:00
// ::InvalidateRect(mWnd, &drect, FALSE);
::RedrawWindow(mWnd, &drect, NULL,
RDW_INVALIDATE | RDW_NOERASE | RDW_NOINTERNALPAINT | RDW_ERASENOW | RDW_ALLCHILDREN);
}
mBounds.width = newWidth;
mBounds.height = newHeight;
///nsRect rect(wp->x, wp->y, wp->cx, wp->cy);
// recalculate the width and height
// this time based on the client area
if (::GetClientRect(mWnd, &r)) {
rect.width = PRInt32(r.right - r.left);
rect.height = PRInt32(r.bottom - r.top);
}
result = OnResize(rect);
}
1998-04-13 20:24:54 +00:00
break;
}
case WM_PALETTECHANGED:
if ((HWND)wParam == mWnd) {
// We caused the WM_PALETTECHANGED message so avoid realizing
// another foreground palette
result = PR_TRUE;
break;
1998-04-13 20:24:54 +00:00
}
// fall thru...
case WM_QUERYNEWPALETTE:
mContext->GetPaletteInfo(palInfo);
if (palInfo.isPaletteDevice && palInfo.palette) {
1998-04-13 20:24:54 +00:00
HDC hDC = ::GetDC(mWnd);
HPALETTE hOldPal = ::SelectPalette(hDC, (HPALETTE)palInfo.palette, FALSE);
1998-04-13 20:24:54 +00:00
// Realize the drawing palette
1998-04-13 20:24:54 +00:00
int i = ::RealizePalette(hDC);
1998-08-19 05:06:59 +00:00
// Did any of our colors change?
if (i > 0) {
// Yes, so repaint
::InvalidateRect(mWnd, (LPRECT)NULL, TRUE);
1998-04-13 20:24:54 +00:00
}
::SelectPalette(hDC, hOldPal, TRUE);
::RealizePalette(hDC);
1998-04-13 20:24:54 +00:00
::ReleaseDC(mWnd, hDC);
*aRetValue = TRUE;
}
result = PR_TRUE;
break;
1998-04-13 20:24:54 +00:00
}
return result;
}
//-------------------------------------------------------------------------
//
// return the window class name and initialize the class if needed
//
//-------------------------------------------------------------------------
LPCTSTR nsWindow::WindowClass()
{
1998-05-05 19:58:27 +00:00
const LPCTSTR className = "NetscapeWindowClass";
1998-04-13 20:24:54 +00:00
if (!nsWindow::sIsRegistered) {
WNDCLASS wc;
1998-06-19 02:46:25 +00:00
// wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
1998-06-02 05:27:08 +00:00
wc.style = CS_DBLCLKS;
1998-04-13 20:24:54 +00:00
wc.lpfnWndProc = ::DefWindowProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = nsToolkit::mDllInstance;
wc.hIcon = ::LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = NULL;
wc.hbrBackground = mBrush;
1998-04-13 20:24:54 +00:00
wc.lpszMenuName = NULL;
1998-05-05 19:58:27 +00:00
wc.lpszClassName = className;
1998-04-13 20:24:54 +00:00
nsWindow::sIsRegistered = ::RegisterClass(&wc);
}
1998-05-05 19:58:27 +00:00
return className;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// return nsWindow styles
//
//-------------------------------------------------------------------------
DWORD nsWindow::WindowStyle()
{
return WS_OVERLAPPEDWINDOW;
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// return nsWindow extended styles
//
//-------------------------------------------------------------------------
DWORD nsWindow::WindowExStyle()
{
return WS_EX_CLIENTEDGE;
}
// -----------------------------------------------------------------------
//
// Subclass (or remove the subclass from) this component's nsWindow
//
// -----------------------------------------------------------------------
void nsWindow::SubclassWindow(BOOL bState)
{
if (NULL != mWnd) {
1998-04-13 20:24:54 +00:00
NS_PRECONDITION(::IsWindow(mWnd), "Invalid window handle");
if (bState) {
// change the nsWindow proc
mPrevWndProc = (WNDPROC)::SetWindowLong(mWnd, GWL_WNDPROC,
(LONG)nsWindow::WindowProc);
NS_ASSERTION(mPrevWndProc, "Null standard window procedure");
// connect the this pointer to the nsWindow handle
::SetWindowLong(mWnd, GWL_USERDATA, (LONG)this);
}
else {
::SetWindowLong(mWnd, GWL_WNDPROC, (LONG)mPrevWndProc);
::SetWindowLong(mWnd, GWL_USERDATA, (LONG)NULL);
1998-04-13 20:24:54 +00:00
mPrevWndProc = NULL;
}
}
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// WM_DESTROY has been called
//
//-------------------------------------------------------------------------
void nsWindow::OnDestroy()
{
mOnDestroyCalled = PR_TRUE;
1998-04-13 20:24:54 +00:00
SubclassWindow(FALSE);
mWnd = NULL;
1998-04-13 20:24:54 +00:00
1998-08-06 05:06:24 +00:00
// free GDI objects
if (mBrush) {
VERIFY(::DeleteObject(mBrush));
mBrush = NULL;
}
if (mPalette) {
VERIFY(::DeleteObject(mPalette));
mPalette = NULL;
}
// free tooltip window
if (mTooltip) {
VERIFY(::DestroyWindow(mTooltip));
mTooltip = NULL;
1998-04-13 20:24:54 +00:00
}
// if we were in the middle of deferred window positioning then
// free the memory for the multiple-window position structure
if (mDeferredPositioner) {
VERIFY(::EndDeferWindowPos(mDeferredPositioner));
mDeferredPositioner = NULL;
}
// release references to children, device context, toolkit, and app shell
nsBaseWidget::OnDestroy();
1998-08-06 05:06:24 +00:00
// dispatch the event
if (!mIsDestroying) {
1998-08-06 05:06:24 +00:00
// dispatching of the event may cause the reference count to drop to 0
// and result in this object being destroyed. To avoid that, add a reference
// and then release it after dispatching the event
AddRef();
DispatchStandardEvent(NS_DESTROY);
Release();
}
1998-04-13 20:24:54 +00:00
}
1998-05-29 22:44:13 +00:00
//-------------------------------------------------------------------------
//
// Move
//
//-------------------------------------------------------------------------
PRBool nsWindow::OnMove(PRInt32 aX, PRInt32 aY)
{
nsGUIEvent event;
InitEvent(event, NS_MOVE);
event.point.x = aX;
event.point.y = aY;
event.eventStructType = NS_GUI_EVENT;
PRBool result = DispatchWindowEvent(&event);
NS_RELEASE(event.widget);
return result;
1998-05-29 22:44:13 +00:00
}
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Paint
//
//-------------------------------------------------------------------------
PRBool nsWindow::OnPaint()
{
nsRect bounds;
PRBool result = PR_TRUE;
PAINTSTRUCT ps;
#ifdef PAINT_DEBUG
HRGN rgn = ::CreateRectRgn(0, 0, 0, 0);
::GetUpdateRgn(mWnd, rgn, TRUE);
HDC dc = ::GetDC(mWnd);
HBRUSH brsh = ::CreateSolidBrush(RGB(255, 0, 0));
::FillRgn(dc, rgn, brsh);
::ReleaseDC(mWnd, dc);
::DeleteObject(rgn);
int x;
for (x = 0; x < 10000000; x++);
#endif
1998-04-13 20:24:54 +00:00
HDC hDC = ::BeginPaint(mWnd, &ps);
1998-08-19 05:06:59 +00:00
// XXX What is this check doing? If it's trying to check for an empty
// paint rect then use the IsRectEmpty() function...
1998-04-13 20:24:54 +00:00
if (ps.rcPaint.left || ps.rcPaint.right || ps.rcPaint.top || ps.rcPaint.bottom) {
// call the event callback
if (mEventCallback) {
nsPaintEvent event;
InitEvent(event, NS_PAINT);
1998-04-13 20:24:54 +00:00
nsRect rect(ps.rcPaint.left,
ps.rcPaint.top,
ps.rcPaint.right - ps.rcPaint.left,
ps.rcPaint.bottom - ps.rcPaint.top);
event.rect = &rect;
event.eventStructType = NS_PAINT_EVENT;
1998-04-13 20:24:54 +00:00
static NS_DEFINE_IID(kRenderingContextCID, NS_RENDERING_CONTEXT_CID);
static NS_DEFINE_IID(kRenderingContextIID, NS_IRENDERING_CONTEXT_IID);
static NS_DEFINE_IID(kRenderingContextWinIID, NS_IRENDERING_CONTEXT_WIN_IID);
if (NS_OK == nsRepository::CreateInstance(kRenderingContextCID, nsnull, kRenderingContextIID, (void **)&event.renderingContext))
{
nsIRenderingContextWin *winrc;
if (NS_OK == event.renderingContext->QueryInterface(kRenderingContextWinIID, (void **)&winrc))
{
nsDrawingSurface surf;
//i know all of this seems a little backwards. i'll fix it, i swear. MMP
if (NS_OK == winrc->CreateDrawingSurface(hDC, surf))
{
event.renderingContext->Init(mContext, surf);
result = DispatchWindowEvent(&event);
event.renderingContext->DestroyDrawingSurface(surf);
}
NS_RELEASE(winrc);
}
1998-04-13 20:24:54 +00:00
NS_RELEASE(event.renderingContext);
}
else
result = PR_FALSE;
NS_RELEASE(event.widget);
1998-04-13 20:24:54 +00:00
}
}
::EndPaint(mWnd, &ps);
1998-04-13 20:24:54 +00:00
return result;
}
//-------------------------------------------------------------------------
//
// Send a resize message to the listener
//
//-------------------------------------------------------------------------
PRBool nsWindow::OnResize(nsRect &aWindowRect)
{
// call the event callback
if (mEventCallback) {
nsSizeEvent event;
InitEvent(event, NS_SIZE);
event.windowSize = &aWindowRect;
event.eventStructType = NS_SIZE_EVENT;
RECT r;
if (::GetWindowRect(mWnd, &r)) {
event.mWinWidth = PRInt32(r.right - r.left);
event.mWinHeight = PRInt32(r.bottom - r.top);
} else {
event.mWinWidth = 0;
event.mWinHeight = 0;
}
PRBool result = DispatchWindowEvent(&event);
NS_RELEASE(event.widget);
return result;
}
1998-04-13 20:24:54 +00:00
return PR_FALSE;
1998-04-13 20:24:54 +00:00
}
1998-04-17 00:16:11 +00:00
1998-04-13 20:24:54 +00:00
//-------------------------------------------------------------------------
//
// Deal with all sort of mouse event
//
//-------------------------------------------------------------------------
1998-05-29 22:44:13 +00:00
PRBool nsWindow::DispatchMouseEvent(PRUint32 aEventType, nsPoint* aPoint)
1998-04-13 20:24:54 +00:00
{
PRBool result = PR_FALSE;
if (nsnull == mEventCallback && nsnull == mMouseListener) {
return result;
}
1998-05-08 14:54:09 +00:00
nsMouseEvent event;
1998-05-29 22:44:13 +00:00
InitEvent(event, aEventType, aPoint);
1998-04-13 20:24:54 +00:00
1998-05-08 14:54:09 +00:00
event.isShift = GetKeyState(VK_LSHIFT) < 0 || GetKeyState(VK_RSHIFT) < 0;
event.isControl = GetKeyState(VK_LCONTROL) < 0 || GetKeyState(VK_RCONTROL) < 0;
event.isAlt = GetKeyState(VK_LMENU) < 0 || GetKeyState(VK_RMENU) < 0;
event.clickCount = (aEventType == NS_MOUSE_LEFT_DOUBLECLICK ||
aEventType == NS_MOUSE_LEFT_DOUBLECLICK)? 2:1;
event.eventStructType = NS_MOUSE_EVENT;
1998-05-08 14:54:09 +00:00
1998-04-13 20:24:54 +00:00
// call the event callback
if (nsnull != mEventCallback) {
result = DispatchWindowEvent(&event);
1998-04-13 20:24:54 +00:00
if (aEventType == NS_MOUSE_MOVE) {
MouseTrailer * mouseTrailer = MouseTrailer::GetMouseTrailer(0);
MouseTrailer::SetMouseTrailerWindow(this);
mouseTrailer->CreateTimer();
nsRect rect;
GetBounds(rect);
rect.x = 0;
rect.y = 0;
if (rect.Contains(event.point.x, event.point.y)) {
1998-05-29 22:44:13 +00:00
if (gCurrentWindow == NULL || gCurrentWindow != this) {
if ((nsnull != gCurrentWindow) && (!gCurrentWindow->mIsDestroying)) {
MouseTrailer::IgnoreNextCycle();
gCurrentWindow->DispatchMouseEvent(NS_MOUSE_EXIT, gCurrentWindow->GetLastPoint());
}
gCurrentWindow = this;
if (!mIsDestroying) {
gCurrentWindow->DispatchMouseEvent(NS_MOUSE_ENTER);
1998-04-13 20:24:54 +00:00
}
}
}
} else if (aEventType == NS_MOUSE_EXIT) {
1998-05-29 22:44:13 +00:00
if (gCurrentWindow == this) {
gCurrentWindow = nsnull;
1998-04-13 20:24:54 +00:00
}
}
NS_RELEASE(event.widget);
1998-04-13 20:24:54 +00:00
return result;
}
if (nsnull != mMouseListener) {
switch (aEventType) {
case NS_MOUSE_MOVE: {
result = ConvertStatus(mMouseListener->MouseMoved(event));
nsRect rect;
GetBounds(rect);
if (rect.Contains(event.point.x, event.point.y)) {
1998-05-29 22:44:13 +00:00
if (gCurrentWindow == NULL || gCurrentWindow != this) {
gCurrentWindow = this;
1998-04-13 20:24:54 +00:00
}
} else {
//printf("Mouse exit");
1998-04-13 20:24:54 +00:00
}
} break;
case NS_MOUSE_LEFT_BUTTON_DOWN:
case NS_MOUSE_MIDDLE_BUTTON_DOWN:
case NS_MOUSE_RIGHT_BUTTON_DOWN:
result = ConvertStatus(mMouseListener->MousePressed(event));
break;
case NS_MOUSE_LEFT_BUTTON_UP:
case NS_MOUSE_MIDDLE_BUTTON_UP:
case NS_MOUSE_RIGHT_BUTTON_UP:
result = ConvertStatus(mMouseListener->MouseReleased(event));
result = ConvertStatus(mMouseListener->MouseClicked(event));
break;
} // switch
}
NS_RELEASE(event.widget);
1998-04-13 20:24:54 +00:00
return result;
}
//-------------------------------------------------------------------------
//
// Deal with focus messages
//
//-------------------------------------------------------------------------
PRBool nsWindow::DispatchFocus(PRUint32 aEventType)
{
// call the event callback
if (mEventCallback) {
if ((nsnull != gCurrentWindow) && (!gCurrentWindow->mIsDestroying)) {
return(DispatchStandardEvent(aEventType));
}
1998-04-13 20:24:54 +00:00
}
return PR_FALSE;
}
//-------------------------------------------------------------------------
//
// Deal with scrollbar messages (actually implemented only in nsScrollbar)
//
//-------------------------------------------------------------------------
PRBool nsWindow::OnScroll(UINT scrollCode, int cPos)
{
return PR_FALSE;
}
//-------------------------------------------------------------------------
//
// Return the brush used to paint the background of this control
//
//-------------------------------------------------------------------------
HBRUSH nsWindow::OnControlColor()
{
return mBrush;
}
//-------------------------------------------------------------------------
//
// return the style for a child nsWindow
//
//-------------------------------------------------------------------------
DWORD ChildWindow::WindowStyle()
{
return WS_CHILD | WS_CLIPCHILDREN | GetBorderStyle(mBorderStyle);
1998-04-13 20:24:54 +00:00
}
//-------------------------------------------------------------------------
//
// Deal with all sort of mouse event
//
//-------------------------------------------------------------------------
PRBool ChildWindow::DispatchMouseEvent(PRUint32 aEventType, nsPoint* aPoint)
{
PRBool result = PR_FALSE;
if (nsnull == mEventCallback && nsnull == mMouseListener) {
return result;
}
switch (aEventType) {
case NS_MOUSE_LEFT_BUTTON_DOWN:
case NS_MOUSE_MIDDLE_BUTTON_DOWN:
case NS_MOUSE_RIGHT_BUTTON_DOWN:
SetCapture(mWnd);
break;
case NS_MOUSE_LEFT_BUTTON_UP:
case NS_MOUSE_MIDDLE_BUTTON_UP:
case NS_MOUSE_RIGHT_BUTTON_UP:
ReleaseCapture();
break;
default:
break;
} // switch
return nsWindow::DispatchMouseEvent(aEventType, aPoint);
}
1998-04-13 20:24:54 +00:00
DWORD nsWindow::GetBorderStyle(nsBorderStyle aBorderStyle)
{
switch(aBorderStyle)
{
case eBorderStyle_none:
return(0);
break;
case eBorderStyle_dialog:
return(WS_DLGFRAME | DS_3DLOOK);
break;
default:
NS_ASSERTION(0, "unknown border style");
return(WS_OVERLAPPEDWINDOW);
}
}
NS_METHOD nsWindow::SetTitle(const nsString& aTitle)
{
NS_ALLOC_STR_BUF(buf, aTitle, 256);
::SendMessage(mWnd, WM_SETTEXT, (WPARAM)0, (LPARAM)(LPCTSTR)buf);
NS_FREE_STR_BUF(buf);
return NS_OK;
}
PRBool nsWindow::AutoErase()
{
return(PR_FALSE);
}
NS_METHOD nsWindow::SetMenuBar(nsIMenuBar * aMenuBar)
{
HMENU nativeMenuHandle;
1998-09-29 18:32:37 +00:00
void * voidData;
aMenuBar->GetNativeData(voidData);
nativeMenuHandle = (HMENU)voidData;
if (nsnull != nativeMenuHandle) {
::SetMenu(mWnd, nativeMenuHandle);
return NS_OK;
} else {
return NS_ERROR_FAILURE;
}
}
NS_METHOD nsWindow::GetPreferredSize(PRInt32& aWidth, PRInt32& aHeight)
{
aWidth = mPreferredWidth;
aHeight = mPreferredHeight;
return NS_ERROR_FAILURE;
}
NS_METHOD nsWindow::SetPreferredSize(PRInt32 aWidth, PRInt32 aHeight)
{
mPreferredWidth = aWidth;
mPreferredHeight = aHeight;
return NS_OK;
}