846 lines
27 KiB
C++
846 lines
27 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2000, 2010 Oracle and/or its affiliates.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
#include "precompiled_vcl.hxx"
|
|
|
|
#include <string.h>
|
|
|
|
#include <svsys.h>
|
|
#include <tools/debug.hxx>
|
|
|
|
#include <vcl/svapp.hxx>
|
|
|
|
#include <win/wincomp.hxx>
|
|
#include <win/saldata.hxx>
|
|
#include <win/salinst.h>
|
|
#include <win/salframe.h>
|
|
#include <win/salobj.h>
|
|
|
|
// =======================================================================
|
|
|
|
static sal_Bool ImplIsSysWindowOrChild( HWND hWndParent, HWND hWndChild )
|
|
{
|
|
if ( hWndParent == hWndChild )
|
|
return TRUE;
|
|
|
|
HWND hTempWnd = ::GetParent( hWndChild );
|
|
while ( hTempWnd )
|
|
{
|
|
// Ab nicht Child-Fenstern hoeren wir auf zu suchen
|
|
if ( !(GetWindowStyle( hTempWnd ) & WS_CHILD) )
|
|
return FALSE;
|
|
if ( hTempWnd == hWndParent )
|
|
return TRUE;
|
|
hTempWnd = ::GetParent( hTempWnd );
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
WinSalObject* ImplFindSalObject( HWND hWndChild )
|
|
{
|
|
SalData* pSalData = GetSalData();
|
|
WinSalObject* pObject = pSalData->mpFirstObject;
|
|
while ( pObject )
|
|
{
|
|
if ( ImplIsSysWindowOrChild( pObject->mhWndChild, hWndChild ) )
|
|
return pObject;
|
|
|
|
pObject = pObject->mpNextObject;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
WinSalFrame* ImplFindSalObjectFrame( HWND hWnd )
|
|
{
|
|
WinSalFrame* pFrame = NULL;
|
|
WinSalObject* pObject = ImplFindSalObject( hWnd );
|
|
if ( pObject )
|
|
{
|
|
// Dazugehoerenden Frame suchen
|
|
HWND hWnd = ::GetParent( pObject->mhWnd );
|
|
pFrame = GetSalData()->mpFirstFrame;
|
|
while ( pFrame )
|
|
{
|
|
if ( pFrame->mhWnd == hWnd )
|
|
break;
|
|
|
|
pFrame = pFrame->mpNextFrame;
|
|
}
|
|
}
|
|
|
|
return pFrame;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
sal_Bool ImplInterceptChildWindowKeyDown( MSG& rMsg )
|
|
{
|
|
sal_Bool bResult = sal_False;
|
|
if ( rMsg.message == WM_KEYDOWN )
|
|
{
|
|
wchar_t pClassName[10];
|
|
sal_Int32 nLen = GetClassNameW( rMsg.hwnd, pClassName, 10 );
|
|
if ( !( nLen == 9 && wcsncmp( pClassName, SAL_OBJECT_CLASSNAMEW, nLen ) == 0 ) )
|
|
{
|
|
// look for the first SalObject in the parent hierarchy
|
|
HWND hWin = rMsg.hwnd;
|
|
WinSalObject* pSalObj = NULL;
|
|
do
|
|
{
|
|
hWin = ::GetParent( hWin );
|
|
if ( hWin )
|
|
{
|
|
nLen = GetClassNameW( hWin, pClassName, 10 );
|
|
if ( nLen == 9 && wcsncmp( pClassName, SAL_OBJECT_CLASSNAMEW, nLen ) == 0 )
|
|
pSalObj = GetSalObjWindowPtr( hWin );
|
|
}
|
|
} while( hWin && !pSalObj );
|
|
|
|
if ( pSalObj && pSalObj->mbInterceptChildWindowKeyDown && pSalObj->maSysData.hWnd )
|
|
{
|
|
bResult = ( 1 == ImplSendMessage( pSalObj->maSysData.hWnd, rMsg.message, rMsg.wParam, rMsg.lParam ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
LRESULT CALLBACK SalSysMsgProc( int nCode, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
// Used for Unicode and none Unicode
|
|
SalData* pSalData = GetSalData();
|
|
|
|
if ( (nCode >= 0) && lParam )
|
|
{
|
|
CWPSTRUCT* pData = (CWPSTRUCT*)lParam;
|
|
if ( (pData->message != WM_KEYDOWN) &&
|
|
(pData->message != WM_KEYUP) )
|
|
pSalData->mnSalObjWantKeyEvt = 0;
|
|
|
|
// Testen, ob wir Daten fuer ein SalObject-Fenster behandeln
|
|
// muessen
|
|
WinSalObject* pObject;
|
|
if ( pData->message == WM_SETFOCUS )
|
|
{
|
|
pObject = ImplFindSalObject( pData->hwnd );
|
|
if ( pObject )
|
|
{
|
|
pObject->mhLastFocusWnd = pData->hwnd;
|
|
if ( ImplSalYieldMutexTryToAcquire() )
|
|
{
|
|
pObject->CallCallback( SALOBJ_EVENT_GETFOCUS, 0 );
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
else
|
|
ImplPostMessage( pObject->mhWnd, SALOBJ_MSG_POSTFOCUS, 0, 0 );
|
|
}
|
|
}
|
|
else if ( pData->message == WM_KILLFOCUS )
|
|
{
|
|
pObject = ImplFindSalObject( pData->hwnd );
|
|
if ( pObject && !ImplFindSalObject( (HWND)pData->wParam ) )
|
|
{
|
|
// LoseFocus nur rufen, wenn wirklich kein ChildFenster
|
|
// den Focus bekommt
|
|
if ( !pData->wParam || !ImplFindSalObject( (HWND)pData->wParam ) )
|
|
{
|
|
if ( ImplSalYieldMutexTryToAcquire() )
|
|
{
|
|
pObject->CallCallback( SALOBJ_EVENT_LOSEFOCUS, 0 );
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
else
|
|
ImplPostMessage( pObject->mhWnd, SALOBJ_MSG_POSTFOCUS, 0, 0 );
|
|
}
|
|
else
|
|
pObject->mhLastFocusWnd = (HWND)pData->wParam;
|
|
}
|
|
}
|
|
}
|
|
|
|
return CallNextHookEx( pSalData->mhSalObjMsgHook, nCode, wParam, lParam );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
sal_Bool ImplSalPreDispatchMsg( MSG* pMsg )
|
|
{
|
|
// Used for Unicode and none Unicode
|
|
SalData* pSalData = GetSalData();
|
|
WinSalObject* pObject;
|
|
|
|
if ( (pMsg->message == WM_LBUTTONDOWN) ||
|
|
(pMsg->message == WM_RBUTTONDOWN) ||
|
|
(pMsg->message == WM_MBUTTONDOWN) )
|
|
{
|
|
ImplSalYieldMutexAcquireWithWait();
|
|
pObject = ImplFindSalObject( pMsg->hwnd );
|
|
if ( pObject && !pObject->IsMouseTransparent() )
|
|
ImplPostMessage( pObject->mhWnd, SALOBJ_MSG_TOTOP, 0, 0 );
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
|
|
if ( (pMsg->message == WM_KEYDOWN) ||
|
|
(pMsg->message == WM_KEYUP) )
|
|
{
|
|
// KeyEvents wollen wir nach Moeglichkeit auch abarbeiten,
|
|
// wenn das Control diese nicht selber auswertet
|
|
// SysKeys werden als WM_SYSCOMMAND verarbeitet
|
|
// Char-Events verarbeiten wir nicht, da wir nur
|
|
// Accelerator relevante Keys verarbeiten wollen
|
|
sal_Bool bWantedKeyCode = FALSE;
|
|
// A-Z, 0-9 nur in Verbindung mit Control-Taste
|
|
if ( ((pMsg->wParam >= 65) && (pMsg->wParam <= 90)) ||
|
|
((pMsg->wParam >= 48) && (pMsg->wParam <= 57)) )
|
|
{
|
|
if ( GetKeyState( VK_CONTROL ) & 0x8000 )
|
|
bWantedKeyCode = TRUE;
|
|
}
|
|
else if ( ((pMsg->wParam >= VK_F1) && (pMsg->wParam <= VK_F24)) ||
|
|
((pMsg->wParam >= VK_SPACE) && (pMsg->wParam <= VK_HELP)) ||
|
|
(pMsg->wParam == VK_BACK) || (pMsg->wParam == VK_TAB) ||
|
|
(pMsg->wParam == VK_CLEAR) || (pMsg->wParam == VK_RETURN) ||
|
|
(pMsg->wParam == VK_ESCAPE) )
|
|
bWantedKeyCode = TRUE;
|
|
if ( bWantedKeyCode )
|
|
{
|
|
ImplSalYieldMutexAcquireWithWait();
|
|
pObject = ImplFindSalObject( pMsg->hwnd );
|
|
if ( pObject )
|
|
pSalData->mnSalObjWantKeyEvt = pMsg->wParam;
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
}
|
|
// Hier WM_SYSCHAR abfangen, um mit Alt+Taste evtl. Menu zu aktivieren
|
|
else if ( pMsg->message == WM_SYSCHAR )
|
|
{
|
|
pSalData->mnSalObjWantKeyEvt = 0;
|
|
|
|
sal_uInt16 nKeyCode = LOWORD( pMsg->wParam );
|
|
// Nur 0-9 und A-Z
|
|
if ( ((nKeyCode >= 48) && (nKeyCode <= 57)) ||
|
|
((nKeyCode >= 65) && (nKeyCode <= 90)) ||
|
|
((nKeyCode >= 97) && (nKeyCode <= 122)) )
|
|
{
|
|
sal_Bool bRet = FALSE;
|
|
ImplSalYieldMutexAcquireWithWait();
|
|
pObject = ImplFindSalObject( pMsg->hwnd );
|
|
if ( pObject )
|
|
{
|
|
if ( pMsg->hwnd == ::GetFocus() )
|
|
{
|
|
WinSalFrame* pFrame = ImplFindSalObjectFrame( pMsg->hwnd );
|
|
if ( pFrame )
|
|
{
|
|
if ( ImplHandleSalObjSysCharMsg( pFrame->mhWnd, pMsg->wParam, pMsg->lParam ) )
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
}
|
|
ImplSalYieldMutexRelease();
|
|
if ( bRet )
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
pSalData->mnSalObjWantKeyEvt = 0;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void ImplSalPostDispatchMsg( MSG* pMsg, LRESULT /* nDispatchResult */ )
|
|
{
|
|
// Used for Unicode and none Unicode
|
|
SalData* pSalData = GetSalData();
|
|
WinSalFrame* pFrame;
|
|
|
|
if ( (pMsg->message == WM_KEYDOWN) || (pMsg->message == WM_KEYUP) )
|
|
{
|
|
if ( pSalData->mnSalObjWantKeyEvt == pMsg->wParam )
|
|
{
|
|
pSalData->mnSalObjWantKeyEvt = 0;
|
|
if ( pMsg->hwnd == ::GetFocus() )
|
|
{
|
|
ImplSalYieldMutexAcquireWithWait();
|
|
pFrame = ImplFindSalObjectFrame( pMsg->hwnd );
|
|
if ( pFrame )
|
|
ImplHandleSalObjKeyMsg( pFrame->mhWnd, pMsg->message, pMsg->wParam, pMsg->lParam );
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
}
|
|
}
|
|
|
|
pSalData->mnSalObjWantKeyEvt = 0;
|
|
}
|
|
|
|
// =======================================================================
|
|
|
|
LRESULT CALLBACK SalSysObjWndProc( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam, int& rDef )
|
|
{
|
|
WinSalObject* pSysObj;
|
|
LRESULT nRet = 0;
|
|
|
|
switch( nMsg )
|
|
{
|
|
case WM_ERASEBKGND:
|
|
nRet = 1;
|
|
rDef = FALSE;
|
|
break;
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT aPs;
|
|
BeginPaint( hWnd, &aPs );
|
|
EndPaint( hWnd, &aPs );
|
|
rDef = FALSE;
|
|
}
|
|
break;
|
|
|
|
case WM_PARENTNOTIFY:
|
|
{
|
|
UINT nNotifyMsg = LOWORD( wParam );
|
|
if ( (nNotifyMsg == WM_LBUTTONDOWN) ||
|
|
(nNotifyMsg == WM_RBUTTONDOWN) ||
|
|
(nNotifyMsg == WM_MBUTTONDOWN) )
|
|
{
|
|
ImplSalYieldMutexAcquireWithWait();
|
|
pSysObj = GetSalObjWindowPtr( hWnd );
|
|
if ( pSysObj && !pSysObj->IsMouseTransparent() )
|
|
pSysObj->CallCallback( SALOBJ_EVENT_TOTOP, 0 );
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_MOUSEACTIVATE:
|
|
{
|
|
ImplSalYieldMutexAcquireWithWait();
|
|
pSysObj = GetSalObjWindowPtr( hWnd );
|
|
if ( pSysObj && !pSysObj->IsMouseTransparent() )
|
|
ImplPostMessage( hWnd, SALOBJ_MSG_TOTOP, 0, 0 );
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
break;
|
|
|
|
case SALOBJ_MSG_TOTOP:
|
|
if ( ImplSalYieldMutexTryToAcquire() )
|
|
{
|
|
pSysObj = GetSalObjWindowPtr( hWnd );
|
|
pSysObj->CallCallback( SALOBJ_EVENT_TOTOP, 0 );
|
|
ImplSalYieldMutexRelease();
|
|
rDef = FALSE;
|
|
}
|
|
else
|
|
ImplPostMessage( hWnd, SALOBJ_MSG_TOTOP, 0, 0 );
|
|
break;
|
|
|
|
case SALOBJ_MSG_POSTFOCUS:
|
|
if ( ImplSalYieldMutexTryToAcquire() )
|
|
{
|
|
pSysObj = GetSalObjWindowPtr( hWnd );
|
|
HWND hFocusWnd = ::GetFocus();
|
|
sal_uInt16 nEvent;
|
|
if ( hFocusWnd && ImplIsSysWindowOrChild( hWnd, hFocusWnd ) )
|
|
nEvent = SALOBJ_EVENT_GETFOCUS;
|
|
else
|
|
nEvent = SALOBJ_EVENT_LOSEFOCUS;
|
|
pSysObj->CallCallback( nEvent, 0 );
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
else
|
|
ImplPostMessage( hWnd, SALOBJ_MSG_POSTFOCUS, 0, 0 );
|
|
rDef = FALSE;
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
{
|
|
HWND hWndChild = GetWindow( hWnd, GW_CHILD );
|
|
if ( hWndChild )
|
|
{
|
|
SetWindowPos( hWndChild,
|
|
0, 0, 0, (int)LOWORD( lParam ), (int)HIWORD( lParam ),
|
|
SWP_NOZORDER | SWP_NOACTIVATE );
|
|
}
|
|
}
|
|
rDef = FALSE;
|
|
break;
|
|
|
|
case WM_CREATE:
|
|
{
|
|
// Window-Instanz am Windowhandle speichern
|
|
// Can also be used for the W-Version, because the struct
|
|
// to access lpCreateParams is the same structure
|
|
CREATESTRUCTA* pStruct = (CREATESTRUCTA*)lParam;
|
|
pSysObj = (WinSalObject*)pStruct->lpCreateParams;
|
|
SetSalObjWindowPtr( hWnd, pSysObj );
|
|
// HWND schon hier setzen, da schon auf den Instanzdaten
|
|
// gearbeitet werden kann, wenn Messages waehrend
|
|
// CreateWindow() gesendet werden
|
|
pSysObj->mhWnd = hWnd;
|
|
rDef = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
LRESULT CALLBACK SalSysObjWndProcA( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
int bDef = TRUE;
|
|
LRESULT nRet = SalSysObjWndProc( hWnd, nMsg, wParam, lParam, bDef );
|
|
if ( bDef )
|
|
nRet = DefWindowProcA( hWnd, nMsg, wParam, lParam );
|
|
return nRet;
|
|
}
|
|
|
|
LRESULT CALLBACK SalSysObjWndProcW( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
int bDef = TRUE;
|
|
LRESULT nRet = SalSysObjWndProc( hWnd, nMsg, wParam, lParam, bDef );
|
|
if ( bDef )
|
|
nRet = DefWindowProcW( hWnd, nMsg, wParam, lParam );
|
|
return nRet;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
LRESULT CALLBACK SalSysObjChildWndProc( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam, int& rDef )
|
|
{
|
|
LRESULT nRet = 0;
|
|
|
|
switch( nMsg )
|
|
{
|
|
// Wegen PlugIn's loeschen wir erstmal den Hintergrund
|
|
case WM_ERASEBKGND:
|
|
{
|
|
WinSalObject* pSysObj = GetSalObjWindowPtr( ::GetParent( hWnd ) );
|
|
|
|
if( pSysObj && !pSysObj->IsEraseBackgroundEnabled() )
|
|
{
|
|
// do not erase background
|
|
nRet = 1;
|
|
rDef = FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT aPs;
|
|
BeginPaint( hWnd, &aPs );
|
|
EndPaint( hWnd, &aPs );
|
|
rDef = FALSE;
|
|
}
|
|
break;
|
|
|
|
case WM_MOUSEMOVE:
|
|
case WM_LBUTTONDOWN:
|
|
case WM_MBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_LBUTTONUP:
|
|
case WM_MBUTTONUP:
|
|
case WM_RBUTTONUP:
|
|
{
|
|
WinSalObject* pSysObj;
|
|
pSysObj = GetSalObjWindowPtr( ::GetParent( hWnd ) );
|
|
|
|
if( pSysObj && pSysObj->IsMouseTransparent() )
|
|
{
|
|
// forward mouse events to parent frame
|
|
HWND hWndParent = ::GetParent( pSysObj->mhWnd );
|
|
|
|
// transform coordinates
|
|
POINT pt;
|
|
pt.x = (long) LOWORD( lParam );
|
|
pt.y = (long) HIWORD( lParam );
|
|
MapWindowPoints( hWnd, hWndParent, &pt, 1 );
|
|
lParam = MAKELPARAM( (WORD) pt.x, (WORD) pt.y );
|
|
|
|
nRet = ImplSendMessage( hWndParent, nMsg, wParam, lParam );
|
|
rDef = FALSE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
LRESULT CALLBACK SalSysObjChildWndProcA( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
int bDef = TRUE;
|
|
LRESULT nRet = SalSysObjChildWndProc( hWnd, nMsg, wParam, lParam, bDef );
|
|
if ( bDef )
|
|
nRet = DefWindowProcA( hWnd, nMsg, wParam, lParam );
|
|
return nRet;
|
|
}
|
|
|
|
LRESULT CALLBACK SalSysObjChildWndProcW( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
int bDef = TRUE;
|
|
LRESULT nRet = SalSysObjChildWndProc( hWnd, nMsg, wParam, lParam, bDef );
|
|
if ( bDef )
|
|
nRet = DefWindowProcW( hWnd, nMsg, wParam, lParam );
|
|
return nRet;
|
|
}
|
|
|
|
// =======================================================================
|
|
|
|
SalObject* ImplSalCreateObject( WinSalInstance* pInst, WinSalFrame* pParent )
|
|
{
|
|
SalData* pSalData = GetSalData();
|
|
|
|
// Hook installieren, wenn es das erste SalObject ist
|
|
if ( !pSalData->mpFirstObject )
|
|
{
|
|
pSalData->mhSalObjMsgHook = SetWindowsHookExW( WH_CALLWNDPROC,
|
|
SalSysMsgProc,
|
|
pSalData->mhInst,
|
|
pSalData->mnAppThreadId );
|
|
}
|
|
|
|
if ( !pSalData->mbObjClassInit )
|
|
{
|
|
WNDCLASSEXA aWndClassEx;
|
|
aWndClassEx.cbSize = sizeof( aWndClassEx );
|
|
aWndClassEx.style = 0;
|
|
aWndClassEx.lpfnWndProc = SalSysObjWndProcA;
|
|
aWndClassEx.cbClsExtra = 0;
|
|
aWndClassEx.cbWndExtra = SAL_OBJECT_WNDEXTRA;
|
|
aWndClassEx.hInstance = pSalData->mhInst;
|
|
aWndClassEx.hIcon = 0;
|
|
aWndClassEx.hIconSm = 0;
|
|
aWndClassEx.hCursor = LoadCursor( 0, IDC_ARROW );
|
|
aWndClassEx.hbrBackground = 0;
|
|
aWndClassEx.lpszMenuName = 0;
|
|
aWndClassEx.lpszClassName = SAL_OBJECT_CLASSNAMEA;
|
|
if ( RegisterClassExA( &aWndClassEx ) )
|
|
{
|
|
// Clean background first because of plugins.
|
|
aWndClassEx.cbWndExtra = 0;
|
|
aWndClassEx.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
|
|
aWndClassEx.lpfnWndProc = SalSysObjChildWndProcA;
|
|
aWndClassEx.lpszClassName = SAL_OBJECT_CHILDCLASSNAMEA;
|
|
pSalData->mbObjClassInit = TRUE;
|
|
}
|
|
}
|
|
|
|
if ( pSalData->mbObjClassInit )
|
|
{
|
|
WinSalObject* pObject = new WinSalObject;
|
|
|
|
// #135235# Clip siblings of this
|
|
// SystemChildWindow. Otherwise, DXCanvas (using a hidden
|
|
// SystemChildWindow) clobbers applets/plugins during
|
|
// animations .
|
|
HWND hWnd = CreateWindowExA( 0, SAL_OBJECT_CLASSNAMEA, "",
|
|
WS_CHILD | WS_CLIPSIBLINGS, 0, 0, 0, 0,
|
|
pParent->mhWnd, 0,
|
|
pInst->mhInst, (void*)pObject );
|
|
|
|
HWND hWndChild = 0;
|
|
if ( hWnd )
|
|
{
|
|
// #135235# Explicitely stack SystemChildWindows in
|
|
// the order they're created - since there's no notion
|
|
// of zorder.
|
|
SetWindowPos(hWnd,HWND_TOP,0,0,0,0,
|
|
SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOSIZE);
|
|
hWndChild = CreateWindowExA( 0, SAL_OBJECT_CHILDCLASSNAMEA, "",
|
|
WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE,
|
|
0, 0, 0, 0,
|
|
hWnd, 0,
|
|
pInst->mhInst, NULL );
|
|
}
|
|
|
|
if ( !hWndChild )
|
|
{
|
|
delete pObject;
|
|
return NULL;
|
|
}
|
|
|
|
if ( hWnd )
|
|
{
|
|
pObject->mhWnd = hWnd;
|
|
pObject->mhWndChild = hWndChild;
|
|
pObject->maSysData.hWnd = hWndChild;
|
|
return pObject;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// =======================================================================
|
|
|
|
WinSalObject::WinSalObject()
|
|
{
|
|
SalData* pSalData = GetSalData();
|
|
|
|
mhWnd = 0;
|
|
mhWndChild = 0;
|
|
mhLastFocusWnd = 0;
|
|
maSysData.nSize = sizeof( SystemEnvData );
|
|
mpStdClipRgnData = NULL;
|
|
mbInterceptChildWindowKeyDown = sal_False;
|
|
|
|
// Insert object in objectlist
|
|
mpNextObject = pSalData->mpFirstObject;
|
|
pSalData->mpFirstObject = this;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
WinSalObject::~WinSalObject()
|
|
{
|
|
SalData* pSalData = GetSalData();
|
|
|
|
// remove frame from framelist
|
|
if ( this == pSalData->mpFirstObject )
|
|
{
|
|
pSalData->mpFirstObject = mpNextObject;
|
|
|
|
// Wenn letztes SalObject, dann Hook wieder entfernen
|
|
if ( !pSalData->mpFirstObject )
|
|
UnhookWindowsHookEx( pSalData->mhSalObjMsgHook );
|
|
}
|
|
else
|
|
{
|
|
WinSalObject* pTempObject = pSalData->mpFirstObject;
|
|
while ( pTempObject->mpNextObject != this )
|
|
pTempObject = pTempObject->mpNextObject;
|
|
|
|
pTempObject->mpNextObject = mpNextObject;
|
|
}
|
|
|
|
// Cache-Daten zerstoeren
|
|
delete mpStdClipRgnData;
|
|
|
|
HWND hWndParent = ::GetParent( mhWnd );
|
|
|
|
if ( mhWndChild )
|
|
DestroyWindow( mhWndChild );
|
|
if ( mhWnd )
|
|
DestroyWindow( mhWnd );
|
|
|
|
// Palette wieder zuruecksetzen, wenn kein externes Child-Fenster
|
|
// mehr vorhanden ist, da diese unsere Palette ueberschrieben haben
|
|
// koennen
|
|
if ( hWndParent &&
|
|
::GetActiveWindow() == hWndParent &&
|
|
!GetWindow( hWndParent, GW_CHILD ) )
|
|
ImplSendMessage( hWndParent, SAL_MSG_FORCEPALETTE, 0, 0 );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::ResetClipRegion()
|
|
{
|
|
SetWindowRgn( mhWnd, 0, TRUE );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
sal_uInt16 WinSalObject::GetClipRegionType()
|
|
{
|
|
return SAL_OBJECT_CLIP_INCLUDERECTS;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::BeginSetClipRegion( sal_uLong nRectCount )
|
|
{
|
|
sal_uLong nRectBufSize = sizeof(RECT)*nRectCount;
|
|
if ( nRectCount < SAL_CLIPRECT_COUNT )
|
|
{
|
|
if ( !mpStdClipRgnData )
|
|
mpStdClipRgnData = (RGNDATA*)new BYTE[sizeof(RGNDATA)-1+(SAL_CLIPRECT_COUNT*sizeof(RECT))];
|
|
mpClipRgnData = mpStdClipRgnData;
|
|
}
|
|
else
|
|
mpClipRgnData = (RGNDATA*)new BYTE[sizeof(RGNDATA)-1+nRectBufSize];
|
|
mpClipRgnData->rdh.dwSize = sizeof( RGNDATAHEADER );
|
|
mpClipRgnData->rdh.iType = RDH_RECTANGLES;
|
|
mpClipRgnData->rdh.nCount = nRectCount;
|
|
mpClipRgnData->rdh.nRgnSize = nRectBufSize;
|
|
SetRectEmpty( &(mpClipRgnData->rdh.rcBound) );
|
|
mpNextClipRect = (RECT*)(&(mpClipRgnData->Buffer));
|
|
mbFirstClipRect = TRUE;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::UnionClipRegion( long nX, long nY, long nWidth, long nHeight )
|
|
{
|
|
RECT* pRect = mpNextClipRect;
|
|
RECT* pBoundRect = &(mpClipRgnData->rdh.rcBound);
|
|
long nRight = nX + nWidth;
|
|
long nBottom = nY + nHeight;
|
|
|
|
if ( mbFirstClipRect )
|
|
{
|
|
pBoundRect->left = nX;
|
|
pBoundRect->top = nY;
|
|
pBoundRect->right = nRight;
|
|
pBoundRect->bottom = nBottom;
|
|
mbFirstClipRect = FALSE;
|
|
}
|
|
else
|
|
{
|
|
if ( nX < pBoundRect->left )
|
|
pBoundRect->left = (int)nX;
|
|
|
|
if ( nY < pBoundRect->top )
|
|
pBoundRect->top = (int)nY;
|
|
|
|
if ( nRight > pBoundRect->right )
|
|
pBoundRect->right = (int)nRight;
|
|
|
|
if ( nBottom > pBoundRect->bottom )
|
|
pBoundRect->bottom = (int)nBottom;
|
|
}
|
|
|
|
pRect->left = (int)nX;
|
|
pRect->top = (int)nY;
|
|
pRect->right = (int)nRight;
|
|
pRect->bottom = (int)nBottom;
|
|
mpNextClipRect++;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::EndSetClipRegion()
|
|
{
|
|
HRGN hRegion;
|
|
|
|
// Aus den Region-Daten muessen wir jetzt eine ClipRegion erzeugen
|
|
if ( mpClipRgnData->rdh.nCount == 1 )
|
|
{
|
|
RECT* pRect = &(mpClipRgnData->rdh.rcBound);
|
|
hRegion = CreateRectRgn( pRect->left, pRect->top,
|
|
pRect->right, pRect->bottom );
|
|
}
|
|
else
|
|
{
|
|
sal_uLong nSize = mpClipRgnData->rdh.nRgnSize+sizeof(RGNDATAHEADER);
|
|
hRegion = ExtCreateRegion( NULL, nSize, mpClipRgnData );
|
|
if ( mpClipRgnData != mpStdClipRgnData )
|
|
delete [] (BYTE*)mpClipRgnData;
|
|
}
|
|
|
|
DBG_ASSERT( hRegion, "SalObject::EndSetClipRegion() - Can't create ClipRegion" );
|
|
SetWindowRgn( mhWnd, hRegion, TRUE );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::SetPosSize( long nX, long nY, long nWidth, long nHeight )
|
|
{
|
|
sal_uLong nStyle = 0;
|
|
sal_Bool bVisible = (GetWindowStyle( mhWnd ) & WS_VISIBLE) != 0;
|
|
if ( bVisible )
|
|
{
|
|
ShowWindow( mhWnd, SW_HIDE );
|
|
nStyle |= SWP_SHOWWINDOW;
|
|
}
|
|
SetWindowPos( mhWnd, 0,
|
|
(int)nX, (int)nY, (int)nWidth, (int)nHeight,
|
|
SWP_NOZORDER | SWP_NOACTIVATE | nStyle );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::Show( sal_Bool bVisible )
|
|
{
|
|
if ( bVisible )
|
|
ShowWindow( mhWnd, SW_SHOWNORMAL );
|
|
else
|
|
ShowWindow( mhWnd, SW_HIDE );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::Enable( sal_Bool bEnable )
|
|
{
|
|
EnableWindow( mhWnd, bEnable );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::GrabFocus()
|
|
{
|
|
if ( mhLastFocusWnd &&
|
|
IsWindow( mhLastFocusWnd ) &&
|
|
ImplIsSysWindowOrChild( mhWndChild, mhLastFocusWnd ) )
|
|
::SetFocus( mhLastFocusWnd );
|
|
else
|
|
::SetFocus( mhWndChild );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::SetBackground()
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::SetBackground( SalColor )
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
const SystemEnvData* WinSalObject::GetSystemData() const
|
|
{
|
|
return &maSysData;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void WinSalObject::InterceptChildWindowKeyDown( sal_Bool bIntercept )
|
|
{
|
|
mbInterceptChildWindowKeyDown = bIntercept;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|