606 lines
19 KiB
C++
606 lines
19 KiB
C++
/*************************************************************************
|
|
*
|
|
* $RCSfile: salobj.cxx,v $
|
|
*
|
|
* $Revision: 1.1.1.1 $
|
|
*
|
|
* last change: $Author: hr $ $Date: 2000-09-18 17:05:35 $
|
|
*
|
|
* The Contents of this file are made available subject to the terms of
|
|
* either of the following licenses
|
|
*
|
|
* - GNU Lesser General Public License Version 2.1
|
|
* - Sun Industry Standards Source License Version 1.1
|
|
*
|
|
* Sun Microsystems Inc., October, 2000
|
|
*
|
|
* GNU Lesser General Public License Version 2.1
|
|
* =============================================
|
|
* Copyright 2000 by Sun Microsystems, Inc.
|
|
* 901 San Antonio Road, Palo Alto, CA 94303, USA
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License version 2.1, as published by the Free Software Foundation.
|
|
*
|
|
* This library 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 for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
*
|
|
* Sun Industry Standards Source License Version 1.1
|
|
* =================================================
|
|
* The contents of this file are subject to the Sun Industry Standards
|
|
* Source 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.openoffice.org/license.html.
|
|
*
|
|
* Software provided under this License is provided on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
|
|
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
|
|
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
|
|
* See the License for the specific provisions governing your rights and
|
|
* obligations concerning the Software.
|
|
*
|
|
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
|
|
*
|
|
* Copyright: 2000 by Sun Microsystems, Inc.
|
|
*
|
|
* All Rights Reserved.
|
|
*
|
|
* Contributor(s): _______________________________________
|
|
*
|
|
*
|
|
************************************************************************/
|
|
|
|
#include <tools/svpm.h>
|
|
|
|
#define _SV_SALOBJ_CXX
|
|
|
|
#ifndef _SV_SALDATA_HXX
|
|
#include <saldata.hxx>
|
|
#endif
|
|
#ifndef _SV_SALINST_HXX
|
|
#include <salinst.hxx>
|
|
#endif
|
|
#ifndef _SV_SALFRAME_HXX
|
|
#include <salframe.hxx>
|
|
#endif
|
|
#ifndef _SV_SALOBJ_HXX
|
|
#include <salobj.hxx>
|
|
#endif
|
|
|
|
// =======================================================================
|
|
|
|
static BOOL ImplIsSysWindowOrChild( HWND hWndParent, HWND hWndChild )
|
|
{
|
|
if ( hWndParent == hWndChild )
|
|
return TRUE;
|
|
|
|
HWND hTempWnd = WinQueryWindow( hWndChild, QW_PARENT );
|
|
while ( hTempWnd )
|
|
{
|
|
if ( hTempWnd == hWndParent )
|
|
return TRUE;
|
|
hTempWnd = WinQueryWindow( hTempWnd, QW_PARENT );
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
static SalObject* ImplFindSalObject( HWND hWndChild )
|
|
{
|
|
SalData* pSalData = GetSalData();
|
|
SalObject* pObject = pSalData->mpFirstObject;
|
|
while ( pObject )
|
|
{
|
|
if ( ImplIsSysWindowOrChild( pObject->maObjectData.mhWndChild, hWndChild ) )
|
|
return pObject;
|
|
|
|
pObject = pObject->maObjectData.mpNextObject;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// =======================================================================
|
|
|
|
PM_BOOL EXPENTRY SalSysMsgProc( HAB /* hAB */, QMSG* pMsg, PM_ULONG /* fs */ )
|
|
{
|
|
if ( (pMsg->msg == WM_BUTTON1DOWN) ||
|
|
(pMsg->msg == WM_BUTTON2DOWN) ||
|
|
(pMsg->msg == WM_BUTTON3DOWN) )
|
|
{
|
|
SalData* pSalData = GetSalData();
|
|
SalObject* pObject = ImplFindSalObject( pMsg->hwnd );
|
|
if ( pObject )
|
|
WinPostMsg( pObject->maObjectData.mhWnd, SALOBJ_MSG_TOTOP, 0, 0 );
|
|
}
|
|
|
|
// Focus fangen wir hier nicht ab, da wir erstmal davon ausgehen,
|
|
// das unser SalObject-Fenster immer eine WM_FOCUSCHANGE-Message
|
|
// bekommt.
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
MRESULT EXPENTRY SalSysObjWndProc( HWND hWnd, PM_ULONG nMsg,
|
|
MPARAM nMP1, MPARAM nMP2 )
|
|
{
|
|
SalObject* pSysObj;
|
|
MRESULT nRet = 0;
|
|
int bDef = TRUE;
|
|
|
|
switch( nMsg )
|
|
{
|
|
case WM_ERASEBACKGROUND:
|
|
nRet = (MRESULT)FALSE;
|
|
bDef = FALSE;
|
|
break;
|
|
case WM_PAINT:
|
|
{
|
|
HPS hPS;
|
|
RECTL aRect;
|
|
hPS = WinBeginPaint( hWnd, NULLHANDLE, &aRect );
|
|
WinEndPaint( hPS );
|
|
bDef = FALSE;
|
|
}
|
|
bDef = FALSE;
|
|
break;
|
|
|
|
case WM_BUTTON1DOWN:
|
|
case WM_BUTTON2DOWN:
|
|
case WM_BUTTON3DOWN:
|
|
case SALOBJ_MSG_TOTOP:
|
|
if ( ImplSalYieldMutexTryToAcquire() )
|
|
{
|
|
pSysObj = GetSalObjWindowPtr( hWnd );
|
|
pSysObj->maObjectData.mpProc( pSysObj->maObjectData.mpInst, pSysObj,
|
|
SALOBJ_EVENT_TOTOP, 0 );
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
else
|
|
WinPostMsg( hWnd, SALOBJ_MSG_TOTOP, 0, 0 );
|
|
break;
|
|
|
|
case WM_FOCUSCHANGE:
|
|
case SALOBJ_MSG_POSTFOCUS:
|
|
if ( ImplSalYieldMutexTryToAcquire() )
|
|
{
|
|
pSysObj = GetSalObjWindowPtr( hWnd );
|
|
if ( SHORT1FROMMP( nMP2 ) )
|
|
{
|
|
pSysObj->maObjectData.mhLastFocusWnd = WinQueryFocus( HWND_DESKTOP );
|
|
pSysObj->maObjectData.mpProc( pSysObj->maObjectData.mpInst, pSysObj,
|
|
SALOBJ_EVENT_GETFOCUS, 0 );
|
|
}
|
|
else
|
|
{
|
|
HWND hWndFocus = HWNDFROMMP( nMP1 );
|
|
if ( !hWndFocus || !ImplIsSysWindowOrChild( hWnd, hWndFocus ) )
|
|
{
|
|
pSysObj->maObjectData.mpProc( pSysObj->maObjectData.mpInst, pSysObj,
|
|
SALOBJ_EVENT_LOSEFOCUS, 0 );
|
|
}
|
|
}
|
|
ImplSalYieldMutexRelease();
|
|
}
|
|
else
|
|
WinPostMsg( hWnd, SALOBJ_MSG_POSTFOCUS, nMP1, nMP2 );
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
{
|
|
pSysObj = GetSalObjWindowPtr( hWnd );
|
|
pSysObj->maObjectData.mnHeight = (short)SHORT2FROMMP( nMP2 );
|
|
WinSetWindowPos( pSysObj->maObjectData.mhWndChild, 0,
|
|
0, 0,
|
|
(short)SHORT1FROMMP( nMP2 ), (short)SHORT2FROMMP( nMP2 ),
|
|
SWP_SIZE | SWP_MOVE );
|
|
bDef = FALSE;
|
|
}
|
|
break;
|
|
|
|
case WM_CREATE:
|
|
{
|
|
// Window-Instanz am Windowhandle speichern
|
|
CREATESTRUCT* pStruct = (CREATESTRUCT*)nMP2;
|
|
pSysObj = (SalObject*)pStruct->pPresParams;
|
|
SetSalObjWindowPtr( hWnd, pSysObj );
|
|
bDef = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( bDef )
|
|
nRet = WinDefWindowProc( hWnd, nMsg, nMP1, nMP2 );
|
|
return nRet;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
MRESULT EXPENTRY SalSysObjChildWndProc( HWND hWnd, PM_ULONG nMsg,
|
|
MPARAM nMP1, MPARAM nMP2 )
|
|
{
|
|
MRESULT nRet = 0;
|
|
int bDef = TRUE;
|
|
|
|
switch( nMsg )
|
|
{
|
|
case WM_ERASEBACKGROUND:
|
|
// Wegen PlugIn's loeschen wir erstmal den Hintergrund
|
|
/*
|
|
nRet = (MRESULT)FALSE;
|
|
bDef = FALSE;
|
|
*/
|
|
break;
|
|
case WM_PAINT:
|
|
{
|
|
HPS hPS;
|
|
RECTL aRect;
|
|
hPS = WinBeginPaint( hWnd, NULLHANDLE, &aRect );
|
|
WinEndPaint( hPS );
|
|
bDef = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( bDef )
|
|
nRet = WinDefWindowProc( hWnd, nMsg, nMP1, nMP2 );
|
|
return nRet;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
MRESULT EXPENTRY SalSysObjClipWndProc( HWND hWnd, PM_ULONG nMsg,
|
|
MPARAM nMP1, MPARAM nMP2 )
|
|
{
|
|
MRESULT nRet = 0;
|
|
int bDef = TRUE;
|
|
|
|
switch( nMsg )
|
|
{
|
|
case WM_MOUSEMOVE:
|
|
case WM_BUTTON1DOWN:
|
|
case WM_BUTTON2DOWN:
|
|
case WM_BUTTON3DOWN:
|
|
case WM_BUTTON1DBLCLK:
|
|
case WM_BUTTON2DBLCLK:
|
|
case WM_BUTTON3DBLCLK:
|
|
case WM_BUTTON1UP:
|
|
case WM_BUTTON2UP:
|
|
case WM_BUTTON3UP:
|
|
{
|
|
// Alle Events an den Frame weiterreichen, da diese Bereiche
|
|
// dem Frame gehoeren. Dazu muessen die Mouse-Koordinaaten
|
|
// entsprechend umgerechnet werden
|
|
HWND hWndParent = WinQueryWindow( hWnd, QW_PARENT ); // ergibt SysChild-Fenster
|
|
hWndParent = WinQueryWindow( hWndParent, QW_PARENT );
|
|
short nX = (short)SHORT1FROMMP( nMP1 );
|
|
short nY = (short)SHORT2FROMMP( nMP1 );
|
|
POINTL aPos;
|
|
aPos.x = nX;
|
|
aPos.y = nY;
|
|
WinMapWindowPoints( hWnd, hWndParent, &aPos, 1 );
|
|
nMP1 = MPFROM2SHORT( (short)aPos.x, (short)aPos.y );
|
|
bDef = FALSE;
|
|
nRet = WinSendMsg( hWndParent, nMsg, nMP1, nMP2 );
|
|
}
|
|
break;
|
|
|
|
case WM_HITTEST:
|
|
// Damit im disablten Zustand die MouseKlicks immer noch
|
|
// an den Frame geschickt werden
|
|
// Dieser Code reicht leider nicht aus, deshalb wir unter
|
|
// OS2 immer das Child-Fenster disablen, im Gegensatz
|
|
// zu Windows, wo immer der Parent disablte wird, da
|
|
// sich das Fenster evtl. anders Darstellen koennte,
|
|
// wenn es disablte wird. Da dieser Fall uns bisher
|
|
// nicht bekannt ist, ignorieren wir das.
|
|
nRet = HT_NORMAL;
|
|
bDef = FALSE;
|
|
break;
|
|
|
|
case WM_ERASEBACKGROUND:
|
|
nRet = (MRESULT)FALSE;
|
|
bDef = FALSE;
|
|
break;
|
|
case WM_PAINT:
|
|
{
|
|
HPS hPS;
|
|
RECTL aRect;
|
|
hPS = WinBeginPaint( hWnd, NULLHANDLE, &aRect );
|
|
WinEndPaint( hPS );
|
|
bDef = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( bDef )
|
|
nRet = WinDefWindowProc( hWnd, nMsg, nMP1, nMP2 );
|
|
return nRet;
|
|
}
|
|
|
|
// =======================================================================
|
|
|
|
void ImplDestroyAllClipWindows( HWND hWndLast )
|
|
{
|
|
if ( hWndLast == HWND_TOP )
|
|
return;
|
|
|
|
HWND hWndPrev;
|
|
while ( hWndLast )
|
|
{
|
|
hWndPrev = WinQueryWindow( hWndLast, QW_PREV );
|
|
WinDestroyWindow( hWndLast );
|
|
hWndLast = hWndPrev;
|
|
}
|
|
}
|
|
|
|
// =======================================================================
|
|
|
|
SalObject* ImplSalCreateObject( SalInstance* pInst, SalFrame* pParent )
|
|
{
|
|
SalData* pSalData = GetSalData();
|
|
|
|
if ( !pSalData->mbObjClassInit )
|
|
{
|
|
if ( WinRegisterClass( pSalData->mhAB, (PSZ)SAL_OBJECT_CLASSNAME,
|
|
(PFNWP)SalSysObjWndProc, CS_MOVENOTIFY,
|
|
SAL_OBJECT_WNDEXTRA ) )
|
|
{
|
|
if ( WinRegisterClass( pSalData->mhAB, (PSZ)SAL_OBJECT_CLIPCLASSNAME,
|
|
(PFNWP)SalSysObjClipWndProc, CS_HITTEST | CS_MOVENOTIFY, 0 ) )
|
|
{
|
|
if ( WinRegisterClass( pSalData->mhAB, (PSZ)SAL_OBJECT_CHILDCLASSNAME,
|
|
(PFNWP)SalSysObjChildWndProc, CS_HITTEST | CS_MOVENOTIFY, 32 ) )
|
|
pSalData->mbObjClassInit = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( pSalData->mbObjClassInit )
|
|
{
|
|
SalObject* pObject = new SalObject;
|
|
HWND hWnd = WinCreateWindow( pParent->maFrameData.mhWndClient, SAL_OBJECT_CLASSNAME, "",
|
|
0,
|
|
0, 0, 0, 0,
|
|
pParent->maFrameData.mhWndClient, HWND_TOP,
|
|
0, NULL, (void*)pObject );
|
|
HWND hWndChild = WinCreateWindow( hWnd, SAL_OBJECT_CHILDCLASSNAME, "",
|
|
WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE,
|
|
0, 0, 0, 0,
|
|
hWnd, HWND_TOP,
|
|
0, NULL, NULL );
|
|
|
|
if ( !hWndChild )
|
|
{
|
|
if ( hWnd )
|
|
WinDestroyWindow( hWnd );
|
|
delete pObject;
|
|
return NULL;
|
|
}
|
|
|
|
if ( hWnd )
|
|
{
|
|
pObject->maObjectData.mhWnd = hWnd;
|
|
pObject->maObjectData.mhWndChild = hWndChild;
|
|
pObject->maObjectData.maSysData.hWnd = hWndChild;
|
|
return pObject;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalInstance::DestroyObject( SalObject* pObject )
|
|
{
|
|
delete pObject;
|
|
}
|
|
|
|
// =======================================================================
|
|
|
|
long ImplSalObjCallbackDummy( void*, SalObject*, USHORT, const void* )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// =======================================================================
|
|
|
|
SalObject::SalObject()
|
|
{
|
|
SalData* pSalData = GetSalData();
|
|
|
|
maObjectData.mhLastClipWnd = HWND_TOP;
|
|
|
|
maObjectData.mhWnd = 0;
|
|
maObjectData.mhWndChild = 0;
|
|
maObjectData.mhLastFocusWnd = 0;
|
|
maObjectData.maSysData.nSize = sizeof( SystemEnvData );
|
|
maObjectData.mnHeight = 0;
|
|
maObjectData.mpInst = NULL;
|
|
maObjectData.mpProc = ImplSalObjCallbackDummy;
|
|
|
|
// Hook installieren, wenn es das erste SalObject ist
|
|
if ( !pSalData->mpFirstObject )
|
|
{
|
|
WinSetHook( pSalData->mhAB, pSalData->mhMQ,
|
|
HK_INPUT, (PFN)SalSysMsgProc, (HMODULE)0 );
|
|
}
|
|
|
|
// Insert object in objectlist
|
|
maObjectData.mpNextObject = pSalData->mpFirstObject;
|
|
pSalData->mpFirstObject = this;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
SalObject::~SalObject()
|
|
{
|
|
SalData* pSalData = GetSalData();
|
|
|
|
// remove frame from framelist
|
|
if ( this == pSalData->mpFirstObject )
|
|
{
|
|
pSalData->mpFirstObject = maObjectData.mpNextObject;
|
|
|
|
// Wenn letztes SalObject, dann Hook wieder entfernen
|
|
if ( !pSalData->mpFirstObject )
|
|
{
|
|
WinReleaseHook( pSalData->mhAB, pSalData->mhMQ,
|
|
HK_INPUT, (PFN)SalSysMsgProc, (HMODULE)0 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SalObject* pTempObject = pSalData->mpFirstObject;
|
|
while ( pTempObject->maObjectData.mpNextObject != this )
|
|
pTempObject = pTempObject->maObjectData.mpNextObject;
|
|
|
|
pTempObject->maObjectData.mpNextObject = maObjectData.mpNextObject;
|
|
}
|
|
|
|
// Cache-Daten zerstoeren
|
|
ImplDestroyAllClipWindows( maObjectData.mhLastClipWnd );
|
|
|
|
if ( maObjectData.mhWndChild )
|
|
WinDestroyWindow( maObjectData.mhWndChild );
|
|
if ( maObjectData.mhWnd )
|
|
WinDestroyWindow( maObjectData.mhWnd );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::ResetClipRegion()
|
|
{
|
|
ImplDestroyAllClipWindows( maObjectData.mhLastClipWnd );
|
|
maObjectData.mhLastClipWnd = HWND_TOP;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
USHORT SalObject::GetClipRegionType()
|
|
{
|
|
return SAL_OBJECT_CLIP_EXCLUDERECTS;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::BeginSetClipRegion( ULONG nRectCount )
|
|
{
|
|
maObjectData.mhOldLastClipWnd = maObjectData.mhLastClipWnd;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::UnionClipRegion( long nX, long nY, long nWidth, long nHeight )
|
|
{
|
|
HWND hClipWnd = WinCreateWindow( maObjectData.mhWnd, SAL_OBJECT_CLIPCLASSNAME, "",
|
|
WS_VISIBLE,
|
|
nX, maObjectData.mnHeight-(nY+nHeight), nWidth, nHeight,
|
|
maObjectData.mhWnd, maObjectData.mhLastClipWnd,
|
|
0, NULL, NULL );
|
|
maObjectData.mhLastClipWnd = hClipWnd;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::EndSetClipRegion()
|
|
{
|
|
ImplDestroyAllClipWindows( maObjectData.mhOldLastClipWnd );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::SetPosSize( long nX, long nY, long nWidth, long nHeight )
|
|
{
|
|
PM_ULONG nStyle = 0;
|
|
PM_BOOL bVisible = WinIsWindowVisible( maObjectData.mhWnd );
|
|
if ( bVisible )
|
|
{
|
|
WinShowWindow( maObjectData.mhWnd, FALSE );
|
|
nStyle |= SWP_SHOW;
|
|
}
|
|
SWP aParentSWP;
|
|
WinQueryWindowPos( WinQueryWindow( maObjectData.mhWnd, QW_PARENT ), &aParentSWP );
|
|
WinSetWindowPos( maObjectData.mhWnd, 0, nX, aParentSWP.cy-(nY+nHeight), nWidth, nHeight,
|
|
SWP_MOVE | SWP_SIZE | nStyle );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::Show( BOOL bVisible )
|
|
{
|
|
WinShowWindow( maObjectData.mhWnd, bVisible );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::Enable( BOOL bEnable )
|
|
{
|
|
// Im Gegensatz zu Windows disablen wir das Childfenster,
|
|
// da ansonsten unser Clippen nicht mehr funktioniert, da
|
|
// wir keine Events mehr bekommen. Dadurch kann sich evtl.
|
|
// das Fenster anders darstellen, was wir eigentlich nicht
|
|
// wollen. Aber da uns bisher kein Fall bekannt ist,
|
|
// ignorieren wir dies. Ansonsten muss ein Fenster dazwischen
|
|
// gezogen werden oder getestet werden, wie wir die
|
|
// Maustransparenz erreichen, wenn maObjectData.mhWnd
|
|
// disablte wird.
|
|
WinEnableWindow( maObjectData.mhWndChild, bEnable );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::GrabFocus()
|
|
{
|
|
if ( maObjectData.mhLastFocusWnd &&
|
|
WinIsWindow( GetSalData()->mhAB, maObjectData.mhLastFocusWnd ) &&
|
|
ImplIsSysWindowOrChild( maObjectData.mhWndChild, maObjectData.mhLastFocusWnd ) )
|
|
WinSetFocus( HWND_DESKTOP, maObjectData.mhLastFocusWnd );
|
|
else
|
|
WinSetFocus( HWND_DESKTOP, maObjectData.mhWndChild );
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::SetBackground()
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::SetBackground( SalColor nSalColor )
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
const SystemChildData* SalObject::GetSystemData() const
|
|
{
|
|
return &maObjectData.maSysData;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
void SalObject::SetCallback( void* pInst, SALOBJECTPROC pProc )
|
|
{
|
|
maObjectData.mpInst = pInst;
|
|
if ( pProc )
|
|
maObjectData.mpProc = pProc;
|
|
else
|
|
maObjectData.mpProc = ImplSalObjCallbackDummy;
|
|
}
|