Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / vcl / source / window / window.cxx
blob: a773d9a6c9c1bf732104e5c462117e42f673dab7 [file] [log] [blame]
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"
#include "tools/time.hxx"
#include "tools/debug.hxx"
#include "tools/rc.h"
#include "unotools/fontcfg.hxx"
#include "unotools/confignode.hxx"
#include "vcl/unohelp.hxx"
#include "vcl/salgtype.hxx"
#include "vcl/event.hxx"
#include "vcl/help.hxx"
#include "vcl/cursor.hxx"
#include "vcl/svapp.hxx"
#include "vcl/window.hxx"
#include "vcl/syswin.hxx"
#include "vcl/syschild.hxx"
#include "vcl/dockwin.hxx"
#include "vcl/menu.hxx"
#include "vcl/wrkwin.hxx"
#include "vcl/wall.hxx"
#include "vcl/gradient.hxx"
#include "vcl/salctype.hxx"
#include "vcl/button.hxx"
#include "vcl/taskpanelist.hxx"
#include "vcl/dialog.hxx"
#include "vcl/unowrap.hxx"
#include "vcl/gdimtf.hxx"
#include "vcl/pdfextoutdevdata.hxx"
#include "vcl/lazydelete.hxx"
// declare system types in sysdata.hxx
#include "svsys.h"
#include "vcl/sysdata.hxx"
#include "salframe.hxx"
#include "salobj.hxx"
#include "salinst.hxx"
#include "salgdi.hxx"
#include "svdata.hxx"
#include "dbggui.hxx"
#include "outfont.hxx"
#include "window.h"
#include "toolbox.h"
#include "outdev.h"
#include "brdwin.hxx"
#include "helpwin.hxx"
#include "sallayout.hxx"
#include "dndlcon.hxx"
#include "dndevdis.hxx"
#include "com/sun/star/awt/XWindowPeer.hpp"
#include "com/sun/star/rendering/XCanvas.hpp"
#include "com/sun/star/rendering/XSpriteCanvas.hpp"
#include "com/sun/star/awt/XWindow.hpp"
#include "comphelper/processfactory.hxx"
#include "com/sun/star/datatransfer/dnd/XDragSource.hpp"
#include "com/sun/star/datatransfer/dnd/XDropTarget.hpp"
#include "com/sun/star/datatransfer/clipboard/XClipboard.hpp"
#include "com/sun/star/awt/XTopWindow.hpp"
#include "com/sun/star/awt/XDisplayConnection.hpp"
#include "com/sun/star/lang/XInitialization.hpp"
#include "com/sun/star/lang/XComponent.hpp"
#include "com/sun/star/lang/XServiceName.hpp"
#include "com/sun/star/accessibility/XAccessible.hpp"
#include "com/sun/star/accessibility/AccessibleRole.hpp"
#include <set>
#include <typeinfo>
using namespace rtl;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::datatransfer::clipboard;
using namespace ::com::sun::star::datatransfer::dnd;
using namespace ::com::sun::star;
using namespace com::sun;
using ::com::sun::star::awt::XTopWindow;
// =======================================================================
DBG_NAME( Window )
// =======================================================================
#define IMPL_PAINT_PAINT ((sal_uInt16)0x0001)
#define IMPL_PAINT_PAINTALL ((sal_uInt16)0x0002)
#define IMPL_PAINT_PAINTALLCHILDS ((sal_uInt16)0x0004)
#define IMPL_PAINT_PAINTCHILDS ((sal_uInt16)0x0008)
#define IMPL_PAINT_ERASE ((sal_uInt16)0x0010)
#define IMPL_PAINT_CHECKRTL ((sal_uInt16)0x0020)
// -----------------------------------------------------------------------
typedef Window* PWINDOW;
// -----------------------------------------------------------------------
struct ImplCalcToTopData
{
ImplCalcToTopData* mpNext;
Window* mpWindow;
Region* mpInvalidateRegion;
};
ImplAccessibleInfos::ImplAccessibleInfos()
{
nAccessibleRole = 0xFFFF;
pAccessibleName = NULL;
pAccessibleDescription = NULL;
pLabeledByWindow = NULL;
pLabelForWindow = NULL;
pMemberOfWindow = NULL;
}
ImplAccessibleInfos::~ImplAccessibleInfos()
{
delete pAccessibleName;
delete pAccessibleDescription;
}
// -----------------------------------------------------------------------
WindowImpl::WindowImpl( WindowType nType )
{
maZoom = Fraction( 1, 1 );
maWinRegion = Region(true);
maWinClipRegion = Region(true);
mpWinData = NULL; // Extra Window Data, that we dont need for all windows
mpOverlapData = NULL; // Overlap Data
mpFrameData = NULL; // Frame Data
mpFrame = NULL; // Pointer to frame window
mpSysObj = NULL;
mpFrameWindow = NULL; // window to top level parent (same as frame window)
mpOverlapWindow = NULL; // first overlap parent
mpBorderWindow = NULL; // Border-Window
mpClientWindow = NULL; // Client-Window of a FrameWindow
mpParent = NULL; // parent (inkl. BorderWindow)
mpRealParent = NULL; // real parent (exkl. BorderWindow)
mpFirstChild = NULL; // first child window
mpLastChild = NULL; // last child window
mpFirstOverlap = NULL; // first overlap window (only set in overlap windows)
mpLastOverlap = NULL; // last overlap window (only set in overlap windows)
mpPrev = NULL; // prev window
mpNext = NULL; // next window
mpNextOverlap = NULL; // next overlap window of frame
mpLastFocusWindow = NULL; // window for focus restore
mpDlgCtrlDownWindow = NULL; // window for dialog control
mpFirstDel = NULL; // Dtor notification list
mpUserData = NULL; // user data
mpExtImpl = NULL; // extended implementation data
mpCursor = NULL; // cursor
mpControlFont = NULL; // font propertie
mpVCLXWindow = NULL;
mpAccessibleInfos = NULL;
maControlForeground = Color( COL_TRANSPARENT ); // foreground color not set
maControlBackground = Color( COL_TRANSPARENT ); // background color not set
mnLeftBorder = 0; // left border
mnTopBorder = 0; // top border
mnRightBorder = 0; // right border
mnBottomBorder = 0; // bottom border
mnX = 0; // X-Position to Parent
mnY = 0; // Y-Position to Parent
mnAbsScreenX = 0; // absolute X-position on screen, used for RTL window positioning
mpChildClipRegion = NULL; // Child-Clip-Region when ClipChildren
mpPaintRegion = NULL; // Paint-ClipRegion
mnStyle = 0; // style (init in ImplInitWindow)
mnPrevStyle = 0; // prevstyle (set in SetStyle)
mnExtendedStyle = 0; // extended style (init in ImplInitWindow)
mnPrevExtendedStyle = 0; // prevstyle (set in SetExtendedStyle)
mnType = nType; // window type
mnGetFocusFlags = 0; // Flags fuer GetFocus()-Aufruf
mnWaitCount = 0; // Wait-Count (>1 == Warte-MousePointer)
mnPaintFlags = 0; // Flags for ImplCallPaint
mnParentClipMode = 0; // Flags for Parent-ClipChildren-Mode
mnActivateMode = 0; // Wird bei System/Overlap-Windows umgesetzt
mnDlgCtrlFlags = 0; // DialogControl-Flags
mnLockCount = 0; // LockCount
meAlwaysInputMode = AlwaysInputNone; // neither AlwaysEnableInput nor AlwaysDisableInput called
mbFrame = sal_False; // sal_True: Window is a frame window
mbBorderWin = sal_False; // sal_True: Window is a border window
mbOverlapWin = sal_False; // sal_True: Window is a overlap window
mbSysWin = sal_False; // sal_True: SystemWindow is the base class
mbDialog = sal_False; // sal_True: Dialog is the base class
mbDockWin = sal_False; // sal_True: DockingWindow is the base class
mbFloatWin = sal_False; // sal_True: FloatingWindow is the base class
mbPushButton = sal_False; // sal_True: PushButton is the base class
mbToolBox = sal_False; // sal_True: ToolBox is the base class
mbMenuFloatingWindow= sal_False; // sal_True: MenuFloatingWindow is the base class
mbToolbarFloatingWindow= sal_False; // sal_True: ImplPopupFloatWin is the base class, used for subtoolbars
mbSplitter = sal_False; // sal_True: Splitter is the base class
mbVisible = sal_False; // sal_True: Show( sal_True ) called
mbOverlapVisible = sal_False; // sal_True: Hide called for visible window from ImplHideAllOverlapWindow()
mbDisabled = sal_False; // sal_True: Enable( sal_False ) called
mbInputDisabled = sal_False; // sal_True: EnableInput( sal_False ) called
mbDropDisabled = sal_False; // sal_True: Drop is enabled
mbNoUpdate = sal_False; // sal_True: SetUpdateMode( sal_False ) called
mbNoParentUpdate = sal_False; // sal_True: SetParentUpdateMode( sal_False ) called
mbActive = sal_False; // sal_True: Window Active
mbParentActive = sal_False; // sal_True: OverlapActive from Parent
mbReallyVisible = sal_False; // sal_True: this and all parents to an overlaped window are visible
mbReallyShown = sal_False; // sal_True: this and all parents to an overlaped window are shown
mbInInitShow = sal_False; // sal_True: we are in InitShow
mbChildNotify = sal_False; // sal_True: ChildNotify
mbChildPtrOverwrite = sal_False; // sal_True: PointerStyle overwrites Child-Pointer
mbNoPtrVisible = sal_False; // sal_True: ShowPointer( sal_False ) called
mbMouseMove = sal_False; // sal_True: BaseMouseMove called
mbPaintFrame = sal_False; // sal_True: Paint is visible, but not painted
mbInPaint = sal_False; // sal_True: Inside PaintHdl
mbMouseButtonDown = sal_False; // sal_True: BaseMouseButtonDown called
mbMouseButtonUp = sal_False; // sal_True: BaseMouseButtonUp called
mbKeyInput = sal_False; // sal_True: BaseKeyInput called
mbKeyUp = sal_False; // sal_True: BaseKeyUp called
mbCommand = sal_False; // sal_True: BaseCommand called
mbDefPos = sal_True; // sal_True: Position is not Set
mbDefSize = sal_True; // sal_True: Size is not Set
mbCallMove = sal_True; // sal_True: Move must be called by Show
mbCallResize = sal_True; // sal_True: Resize must be called by Show
mbWaitSystemResize = sal_True; // sal_True: Wait for System-Resize
mbInitWinClipRegion = sal_True; // sal_True: Calc Window Clip Region
mbInitChildRegion = sal_False; // sal_True: InitChildClipRegion
mbWinRegion = sal_False; // sal_True: Window Region
mbClipChildren = sal_False; // sal_True: request that child-windows get clipped
mbClipSiblings = sal_False; // sal_True: request that sibling child-windows get clipped
mbChildTransparent = sal_False; // sal_True: allow child-windows to enable transparency (incl. Parent-CLIPCHILDREN)
mbPaintTransparent = sal_False; // sal_True: Paints muessen auf Parent ausgeloest werden
mbMouseTransparent = sal_False; // sal_True: Window is transparent for Mouse
mbDlgCtrlStart = sal_False; // sal_True: Ab hier eigenes Dialog-Control
mbFocusVisible = sal_False; // sal_True: Focus Visible
mbUseNativeFocus = sal_False;
mbNativeFocusVisible= sal_False; // sal_True: native Focus Visible
mbInShowFocus = sal_False; // prevent recursion
mbInHideFocus = sal_False; // prevent recursion
mbTrackVisible = sal_False; // sal_True: Tracking Visible
mbControlForeground = sal_False; // sal_True: Foreground-Property set
mbControlBackground = sal_False; // sal_True: Background-Property set
mbAlwaysOnTop = sal_False; // sal_True: window is always on top
mbCompoundControl = sal_False; // sal_True: Zusammengesetztes Control => Listener...
mbCompoundControlHasFocus = sal_False; // sal_True: Zusammengesetztes Control hat irgendwo den Focus
mbPaintDisabled = sal_False; // sal_True: to disable paint events
mbAllResize = sal_False; // sal_True: to enable sending of ResizeEvents with both height=0 and width=0
mbInDtor = sal_False; // sal_True: is set when the window is being destructed
mbExtTextInput = sal_False; // sal_True: ExtTextInput-Mode is active
mbInFocusHdl = sal_False; // sal_True: is set when inside a GetFocus-Handler context
mbCreatedWithToolkit = sal_False;
mbSuppressAccessibilityEvents = sal_False; // sal_True: do not send any accessibility events
mbDrawSelectionBackground = sal_False; // sal_True: draws transparent window background to indicate (toolbox) selection
mbIsInTaskPaneList = sal_False; // sal_True: window was added to the taskpanelist in the topmost system window
mnNativeBackground = 0; // initialize later, depends on type
mbCallHandlersDuringInputDisabled = sal_False; // sal_True: call event handlers even if input is disabled
mbDisableAccessibleLabelForRelation = sal_False; // sal_True: do not set LabelFor relation on accessible objects
mbDisableAccessibleLabeledByRelation = sal_False; // sal_True: do not set LabeledBy relation on accessible objects
mbHelpTextDynamic = sal_False; // sal_True: append help id in HELP_DEBUG case
mbFakeFocusSet = sal_False; // sal_True: pretend as if the window
// has focus.
mbIsThemingEnabled = sal_True;
}
WindowImpl::~WindowImpl()
{
delete mpChildClipRegion;
delete mpAccessibleInfos;
delete mpControlFont;
}
// -----------------------------------------------------------------------
// helper method to allow inline constructor even for pWindow!=NULL case
void ImplDelData::AttachToWindow( const Window* pWindow )
{
if( pWindow )
const_cast<Window*>(pWindow)->ImplAddDel( this );
}
// -----------------------------------------------------------------------
// define dtor for ImplDelData
ImplDelData::~ImplDelData()
{
// #112873# auto remove of ImplDelData
// due to this code actively calling ImplRemoveDel() is not mandatory anymore
if( !mbDel && mpWindow )
{
// the window still exists but we were not removed
const_cast<Window*>(mpWindow)->ImplRemoveDel( this );
mpWindow = NULL;
}
}
// -----------------------------------------------------------------------
#ifdef DBG_UTIL
const char* ImplDbgCheckWindow( const void* pObj )
{
DBG_TESTSOLARMUTEX();
const Window* pWindow = (Window*)pObj;
if ( (pWindow->GetType() < WINDOW_FIRST) || (pWindow->GetType() > WINDOW_LAST) )
return "Window data overwrite";
// Fenster-Verkettung ueberpruefen
Window* pChild = pWindow->mpWindowImpl->mpFirstChild;
while ( pChild )
{
if ( pChild->mpWindowImpl->mpParent != pWindow )
return "Child-Window-Parent wrong";
pChild = pChild->mpWindowImpl->mpNext;
}
return NULL;
}
#endif
// =======================================================================
void Window::ImplInitAppFontData( Window* pWindow )
{
ImplSVData* pSVData = ImplGetSVData();
long nTextHeight = pWindow->GetTextHeight();
long nTextWidth = pWindow->GetTextWidth( XubString( RTL_CONSTASCII_USTRINGPARAM( "aemnnxEM" ) ) );
long nSymHeight = nTextHeight*4;
// Falls Font zu schmal ist, machen wir die Basis breiter,
// damit die Dialoge symetrisch aussehen und nicht zu schmal
// werden. Wenn der Dialog die gleiche breite hat, geben wir
// noch etwas Spielraum dazu, da etwas mehr Platz besser ist.
if ( nSymHeight > nTextWidth )
nTextWidth = nSymHeight;
else if ( nSymHeight+5 > nTextWidth )
nTextWidth = nSymHeight+5;
pSVData->maGDIData.mnAppFontX = nTextWidth * 10 / 8;
pSVData->maGDIData.mnAppFontY = nTextHeight * 10;
// FIXME: this is currently only on aqua, check with other
// platforms
if( pSVData->maNWFData.mbNoFocusRects )
{
// try to find out wether there is a large correction
// of control sizes, if yes, make app font scalings larger
// so dialog positioning is not completely off
ImplControlValue aControlValue;
Rectangle aCtrlRegion( Point(), Size( nTextWidth < 10 ? 10 : nTextWidth, nTextHeight < 10 ? 10 : nTextHeight ) );
Rectangle aBoundingRgn( aCtrlRegion );
Rectangle aContentRgn( aCtrlRegion );
if( pWindow->GetNativeControlRegion( CTRL_EDITBOX, PART_ENTIRE_CONTROL, aCtrlRegion,
CTRL_STATE_ENABLED, aControlValue, rtl::OUString(),
aBoundingRgn, aContentRgn ) )
{
// comment: the magical +6 is for the extra border in bordered
// (which is the standard) edit fields
if( aContentRgn.GetHeight() - nTextHeight > (nTextHeight+4)/4 )
pSVData->maGDIData.mnAppFontY = (aContentRgn.GetHeight()-4) * 10;
}
}
pSVData->maGDIData.mnRealAppFontX = pSVData->maGDIData.mnAppFontX;
if ( pSVData->maAppData.mnDialogScaleX )
pSVData->maGDIData.mnAppFontX += (pSVData->maGDIData.mnAppFontX*pSVData->maAppData.mnDialogScaleX)/100;
}
// -----------------------------------------------------------------------
bool Window::ImplCheckUIFont( const Font& rFont )
{
if( ImplGetSVData()->maGDIData.mbNativeFontConfig )
return true;
// create a text string using the localized text of important buttons
String aTestText;
static const StandardButtonType aTestButtons[] =
{
BUTTON_OK, BUTTON_CANCEL, BUTTON_CLOSE, BUTTON_ABORT,
BUTTON_YES, BUTTON_NO, BUTTON_MORE, BUTTON_IGNORE,
BUTTON_RETRY, BUTTON_HELP
};
const int nTestButtonCount = sizeof(aTestButtons)/sizeof(*aTestButtons);
for( int n = 0; n < nTestButtonCount; ++n )
{
String aButtonStr = Button::GetStandardText( aTestButtons[n] );
// #i115432# ignore mnemonic+accelerator part of each string
// TODO: use a string filtering method when it becomes available
const int nLen = aButtonStr.Len();
bool bInside = false;
for( int i = 0; i < nLen; ++i ) {
const sal_Unicode c = aButtonStr.GetChar( i );
if( (c == '('))
bInside = true;
if( (c == ')'))
bInside = false;
if( (c == '~')
|| (c == '(') || (c == ')')
|| ((c >= 'A') && (c <= 'Z') && bInside) )
aButtonStr.SetChar( i, ' ' );
}
// append sanitized button text to test string
aTestText.Append( aButtonStr );
}
const int nFirstChar = HasGlyphs( rFont, aTestText );
const bool bUIFontOk = (nFirstChar >= aTestText.Len());
return bUIFontOk;
}
// -----------------------------------------------------------------------
void Window::ImplUpdateGlobalSettings( AllSettings& rSettings, sal_Bool bCallHdl )
{
// reset high contrast to false, so the system can either update it
// or AutoDetectSystemHC can kick in (see below)
StyleSettings aTmpSt( rSettings.GetStyleSettings() );
aTmpSt.SetHighContrastMode( sal_False );
rSettings.SetStyleSettings( aTmpSt );
ImplGetFrame()->UpdateSettings( rSettings );
// reset default border width for layouters
ImplGetSVData()->maAppData.mnDefaultLayoutBorder = -1;
// Verify availability of the configured UI font, otherwise choose "Andale Sans UI"
String aUserInterfaceFont;
bool bUseSystemFont = rSettings.GetStyleSettings().GetUseSystemUIFonts();
// check whether system UI font can display a typical UI text
if( bUseSystemFont )
bUseSystemFont = ImplCheckUIFont( rSettings.GetStyleSettings().GetAppFont() );
if ( !bUseSystemFont )
{
ImplInitFontList();
String aConfigFont = utl::DefaultFontConfiguration::get()->getUserInterfaceFont( rSettings.GetUILocale() );
xub_StrLen nIndex = 0;
while( nIndex != STRING_NOTFOUND )
{
String aName( aConfigFont.GetToken( 0, ';', nIndex ) );
if ( aName.Len() && mpWindowImpl->mpFrameData->mpFontList->FindFontFamily( aName ) )
{
aUserInterfaceFont = aConfigFont;
break;
}
}
if ( ! aUserInterfaceFont.Len() )
{
String aFallbackFont (RTL_CONSTASCII_USTRINGPARAM( "Andale Sans UI" ));
if ( mpWindowImpl->mpFrameData->mpFontList->FindFontFamily( aFallbackFont ) )
aUserInterfaceFont = aFallbackFont;
}
}
if ( !bUseSystemFont && aUserInterfaceFont.Len() )
{
StyleSettings aStyleSettings = rSettings.GetStyleSettings();
Font aFont = aStyleSettings.GetAppFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetAppFont( aFont );
aFont = aStyleSettings.GetHelpFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetHelpFont( aFont );
aFont = aStyleSettings.GetTitleFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetTitleFont( aFont );
aFont = aStyleSettings.GetFloatTitleFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetFloatTitleFont( aFont );
aFont = aStyleSettings.GetMenuFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetMenuFont( aFont );
aFont = aStyleSettings.GetToolFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetToolFont( aFont );
aFont = aStyleSettings.GetLabelFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetLabelFont( aFont );
aFont = aStyleSettings.GetInfoFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetInfoFont( aFont );
aFont = aStyleSettings.GetRadioCheckFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetRadioCheckFont( aFont );
aFont = aStyleSettings.GetPushButtonFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetPushButtonFont( aFont );
aFont = aStyleSettings.GetFieldFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetFieldFont( aFont );
aFont = aStyleSettings.GetIconFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetIconFont( aFont );
aFont = aStyleSettings.GetGroupFont();
aFont.SetName( aUserInterfaceFont );
aStyleSettings.SetGroupFont( aFont );
rSettings.SetStyleSettings( aStyleSettings );
}
StyleSettings aStyleSettings = rSettings.GetStyleSettings();
// #97047: Force all fonts except Menu and Help to a fixed height
// to avoid UI scaling due to large fonts
// - but allow bigger fonts on bigger screens (i16682, i21238)
// dialogs were designed to fit 800x600 with an 8pt font, so scale accordingly
int maxFontheight = 9; // #107886#: 9 is default for some asian systems, so always allow if requested
if( GetDesktopRectPixel().getHeight() > 600 )
maxFontheight = (int) ((( 8.0 * (double) GetDesktopRectPixel().getHeight()) / 600.0) + 1.5);
Font aFont = aStyleSettings.GetMenuFont();
int defFontheight = aFont.GetHeight();
if( defFontheight > maxFontheight )
defFontheight = maxFontheight;
// if the UI is korean, chinese or another locale
// where the system font size is kown to be often too small to
// generate readable fonts enforce a minimum font size of 9 points
bool bBrokenLangFontHeight = false;
static const LanguageType eBrokenSystemFontSizeLanguages[] =
{ LANGUAGE_KOREAN, LANGUAGE_KOREAN_JOHAB,
LANGUAGE_CHINESE_HONGKONG, LANGUAGE_CHINESE_MACAU, LANGUAGE_CHINESE_SIMPLIFIED, LANGUAGE_CHINESE_SINGAPORE, LANGUAGE_CHINESE_TRADITIONAL
};
static std::set< LanguageType > aBrokenSystemFontSizeLanguagesSet(
eBrokenSystemFontSizeLanguages,
eBrokenSystemFontSizeLanguages +
(sizeof(eBrokenSystemFontSizeLanguages)/sizeof(eBrokenSystemFontSizeLanguages[0]))
);
LanguageType aLang = Application::GetSettings().GetUILanguage();
if( aBrokenSystemFontSizeLanguagesSet.find( aLang ) != aBrokenSystemFontSizeLanguagesSet.end() )
{
defFontheight = Max(9, defFontheight);
bBrokenLangFontHeight = true;
}
// i22098, toolfont will be scaled differently to avoid bloated rulers and status bars for big fonts
int toolfontheight = defFontheight;
if( toolfontheight > 9 )
toolfontheight = (defFontheight+8) / 2;
aFont = aStyleSettings.GetAppFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetAppFont( aFont );
aFont = aStyleSettings.GetTitleFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetTitleFont( aFont );
aFont = aStyleSettings.GetFloatTitleFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetFloatTitleFont( aFont );
// keep menu and help font size from system unless in broken locale size
if( bBrokenLangFontHeight )
{
aFont = aStyleSettings.GetMenuFont();
if( aFont.GetHeight() < defFontheight )
{
aFont.SetHeight( defFontheight );
aStyleSettings.SetMenuFont( aFont );
}
aFont = aStyleSettings.GetHelpFont();
if( aFont.GetHeight() < defFontheight )
{
aFont.SetHeight( defFontheight );
aStyleSettings.SetHelpFont( aFont );
}
}
// use different height for toolfont
aFont = aStyleSettings.GetToolFont();
aFont.SetHeight( toolfontheight );
aStyleSettings.SetToolFont( aFont );
aFont = aStyleSettings.GetLabelFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetLabelFont( aFont );
aFont = aStyleSettings.GetInfoFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetInfoFont( aFont );
aFont = aStyleSettings.GetRadioCheckFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetRadioCheckFont( aFont );
aFont = aStyleSettings.GetPushButtonFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetPushButtonFont( aFont );
aFont = aStyleSettings.GetFieldFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetFieldFont( aFont );
aFont = aStyleSettings.GetIconFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetIconFont( aFont );
aFont = aStyleSettings.GetGroupFont();
aFont.SetHeight( defFontheight );
aStyleSettings.SetGroupFont( aFont );
// set workspace gradient to black in dark themes
if( aStyleSettings.GetWindowColor().IsDark() )
aStyleSettings.SetWorkspaceGradient( Wallpaper( Color( COL_BLACK ) ) );
else
{
Gradient aGrad( GRADIENT_LINEAR, DEFAULT_WORKSPACE_GRADIENT_START_COLOR, DEFAULT_WORKSPACE_GRADIENT_END_COLOR );
aStyleSettings.SetWorkspaceGradient( Wallpaper( aGrad ) );
}
rSettings.SetStyleSettings( aStyleSettings );
// auto detect HC mode; if the system already set it to "yes"
// (see above) then accept that
if( !rSettings.GetStyleSettings().GetHighContrastMode() )
{
sal_Bool bTmp = sal_False, bAutoHCMode = sal_True;
utl::OConfigurationNode aNode = utl::OConfigurationTreeRoot::tryCreateWithServiceFactory(
vcl::unohelper::GetMultiServiceFactory(),
OUString::createFromAscii( "org.openoffice.Office.Common/Accessibility" ) ); // note: case sensisitive !
if ( aNode.isValid() )
{
::com::sun::star::uno::Any aValue = aNode.getNodeValue( OUString::createFromAscii( "AutoDetectSystemHC" ) );
if( aValue >>= bTmp )
bAutoHCMode = bTmp;
}
if( bAutoHCMode )
{
if( rSettings.GetStyleSettings().GetFaceColor().IsDark()
|| rSettings.GetStyleSettings().GetWindowColor().IsDark() )
{
aStyleSettings = rSettings.GetStyleSettings();
aStyleSettings.SetHighContrastMode( sal_True );
rSettings.SetStyleSettings( aStyleSettings );
}
}
}
static const char* pEnvHC = getenv( "SAL_FORCE_HC" );
if( pEnvHC && *pEnvHC )
{
aStyleSettings.SetHighContrastMode( sal_True );
rSettings.SetStyleSettings( aStyleSettings );
}
#ifdef DBG_UTIL
// Evt. AppFont auf Fett schalten, damit man feststellen kann,
// ob fuer die Texte auf anderen Systemen genuegend Platz
// vorhanden ist
if ( DbgIsBoldAppFont() )
{
aStyleSettings = rSettings.GetStyleSettings();
aFont = aStyleSettings.GetAppFont();
aFont.SetWeight( WEIGHT_BOLD );
aStyleSettings.SetAppFont( aFont );
aFont = aStyleSettings.GetGroupFont();
aFont.SetWeight( WEIGHT_BOLD );
aStyleSettings.SetGroupFont( aFont );
aFont = aStyleSettings.GetLabelFont();
aFont.SetWeight( WEIGHT_BOLD );
aStyleSettings.SetLabelFont( aFont );
aFont = aStyleSettings.GetRadioCheckFont();
aFont.SetWeight( WEIGHT_BOLD );
aStyleSettings.SetRadioCheckFont( aFont );
aFont = aStyleSettings.GetPushButtonFont();
aFont.SetWeight( WEIGHT_BOLD );
aStyleSettings.SetPushButtonFont( aFont );
aFont = aStyleSettings.GetFieldFont();
aFont.SetWeight( WEIGHT_BOLD );
aStyleSettings.SetFieldFont( aFont );
aFont = aStyleSettings.GetIconFont();
aFont.SetWeight( WEIGHT_BOLD );
aStyleSettings.SetIconFont( aFont );
rSettings.SetStyleSettings( aStyleSettings );
}
#endif
if ( bCallHdl )
GetpApp()->SystemSettingsChanging( rSettings, this );
}
// -----------------------------------------------------------------------
MouseEvent ImplTranslateMouseEvent( const MouseEvent& rE, Window* pSource, Window* pDest )
{
Point aPos = pSource->OutputToScreenPixel( rE.GetPosPixel() );
aPos = pDest->ScreenToOutputPixel( aPos );
return MouseEvent( aPos, rE.GetClicks(), rE.GetMode(), rE.GetButtons(), rE.GetModifier() );
}
// -----------------------------------------------------------------------
CommandEvent ImplTranslateCommandEvent( const CommandEvent& rCEvt, Window* pSource, Window* pDest )
{
if ( !rCEvt.IsMouseEvent() )
return rCEvt;
Point aPos = pSource->OutputToScreenPixel( rCEvt.GetMousePosPixel() );
aPos = pDest->ScreenToOutputPixel( aPos );
return CommandEvent( aPos, rCEvt.GetCommand(), rCEvt.IsMouseEvent(), rCEvt.GetData() );
}
// =======================================================================
void Window::ImplInitWindowData( WindowType nType )
{
mpWindowImpl = new WindowImpl( nType );
meOutDevType = OUTDEV_WINDOW;
mbEnableRTL = Application::GetSettings().GetLayoutRTL(); // sal_True: this outdev will be mirrored if RTL window layout (UI mirroring) is globally active
}
// -----------------------------------------------------------------------
void Window::ImplInit( Window* pParent, WinBits nStyle, const ::com::sun::star::uno::Any& /*aSystemWorkWindowToken*/ )
{
ImplInit( pParent, nStyle, NULL );
}
// -----------------------------------------------------------------------
void Window::ImplInit( Window* pParent, WinBits nStyle, SystemParentData* pSystemParentData )
{
DBG_ASSERT( mpWindowImpl->mbFrame || pParent, "Window::Window(): pParent == NULL" );
ImplSVData* pSVData = ImplGetSVData();
Window* pRealParent = pParent;
// 3D-Look vererben
if ( !mpWindowImpl->mbOverlapWin && pParent && (pParent->GetStyle() & WB_3DLOOK) )
nStyle |= WB_3DLOOK;
// create border window if necessary
if ( !mpWindowImpl->mbFrame && !mpWindowImpl->mbBorderWin && !mpWindowImpl->mpBorderWindow
&& (nStyle & (WB_BORDER | WB_SYSTEMCHILDWINDOW) ) )
{
sal_uInt16 nBorderTypeStyle = 0;
if( (nStyle & WB_SYSTEMCHILDWINDOW) )
{
// handle WB_SYSTEMCHILDWINDOW
// these should be analogous to a top level frame; meaning they
// should have a border window with style BORDERWINDOW_STYLE_FRAME
// which controls their size
nBorderTypeStyle |= BORDERWINDOW_STYLE_FRAME;
nStyle |= WB_BORDER;
}
ImplBorderWindow* pBorderWin =
mpWindowImpl->mbIsThemingEnabled
? CreateBorderWindow( pParent, nStyle & (WB_BORDER | WB_DIALOGCONTROL | WB_NODIALOGCONTROL | WB_NEEDSFOCUS), nBorderTypeStyle )
: new ImplBorderWindow( pParent, nStyle & (WB_BORDER | WB_DIALOGCONTROL | WB_NODIALOGCONTROL | WB_NEEDSFOCUS), nBorderTypeStyle );
((Window*)pBorderWin)->mpWindowImpl->mpClientWindow = this;
pBorderWin->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder );
mpWindowImpl->mpBorderWindow = pBorderWin;
pParent = mpWindowImpl->mpBorderWindow;
}
else if( !mpWindowImpl->mbFrame && ! pParent )
{
mpWindowImpl->mbOverlapWin = sal_True;
mpWindowImpl->mbFrame = sal_True;
}
// insert window in list
ImplInsertWindow( pParent );
mpWindowImpl->mnStyle = nStyle;
// Overlap-Window-Daten
if ( mpWindowImpl->mbOverlapWin )
{
mpWindowImpl->mpOverlapData = new ImplOverlapData;
mpWindowImpl->mpOverlapData->mpSaveBackDev = NULL;
mpWindowImpl->mpOverlapData->mpSaveBackRgn = NULL;
mpWindowImpl->mpOverlapData->mpNextBackWin = NULL;
mpWindowImpl->mpOverlapData->mnSaveBackSize = 0;
mpWindowImpl->mpOverlapData->mbSaveBack = sal_False;
mpWindowImpl->mpOverlapData->mnTopLevel = 1;
}
if( pParent && ! mpWindowImpl->mbFrame )
mbEnableRTL = pParent->mbEnableRTL;
// test for frame creation
if ( mpWindowImpl->mbFrame )
{
// create frame
sal_uLong nFrameStyle = 0;
if ( nStyle & WB_MOVEABLE )
nFrameStyle |= SAL_FRAME_STYLE_MOVEABLE;
if ( nStyle & WB_SIZEABLE )
nFrameStyle |= SAL_FRAME_STYLE_SIZEABLE;
if ( nStyle & WB_CLOSEABLE )
nFrameStyle |= SAL_FRAME_STYLE_CLOSEABLE;
if ( nStyle & WB_APP )
nFrameStyle |= SAL_FRAME_STYLE_DEFAULT;
// check for undecorated floating window
if( // 1. floating windows that are not moveable/sizeable (only closeable allowed)
( !(nFrameStyle & ~SAL_FRAME_STYLE_CLOSEABLE) &&
( mpWindowImpl->mbFloatWin || ((GetType() == WINDOW_BORDERWINDOW) && ((ImplBorderWindow*)this)->mbFloatWindow) || (nStyle & WB_SYSTEMFLOATWIN) ) ) ||
// 2. borderwindows of floaters with ownerdraw decoration
( ((GetType() == WINDOW_BORDERWINDOW) && ((ImplBorderWindow*)this)->mbFloatWindow && (nStyle & WB_OWNERDRAWDECORATION) ) ) )
{
nFrameStyle = SAL_FRAME_STYLE_FLOAT;
if( nStyle & WB_OWNERDRAWDECORATION )
nFrameStyle |= (SAL_FRAME_STYLE_OWNERDRAWDECORATION | SAL_FRAME_STYLE_NOSHADOW);
if( nStyle & WB_NEEDSFOCUS )
nFrameStyle |= SAL_FRAME_STYLE_FLOAT_FOCUSABLE;
}
else if( mpWindowImpl->mbFloatWin )
nFrameStyle |= SAL_FRAME_STYLE_TOOLWINDOW;
if( nStyle & WB_INTROWIN )
nFrameStyle |= SAL_FRAME_STYLE_INTRO;
if( nStyle & WB_TOOLTIPWIN )
nFrameStyle |= SAL_FRAME_STYLE_TOOLTIP;
if( nStyle & WB_NOSHADOW )
nFrameStyle |= SAL_FRAME_STYLE_NOSHADOW;
if( nStyle & WB_SYSTEMCHILDWINDOW )
nFrameStyle |= SAL_FRAME_STYLE_SYSTEMCHILD;
switch (mpWindowImpl->mnType)
{
case WINDOW_DIALOG:
case WINDOW_TABDIALOG:
case WINDOW_MODALDIALOG:
case WINDOW_MODELESSDIALOG:
case WINDOW_MESSBOX:
case WINDOW_INFOBOX:
case WINDOW_WARNINGBOX:
case WINDOW_ERRORBOX:
case WINDOW_QUERYBOX:
nFrameStyle |= SAL_FRAME_STYLE_DIALOG;
default:
break;
}
SalFrame* pParentFrame = NULL;
if ( pParent )
pParentFrame = pParent->mpWindowImpl->mpFrame;
SalFrame* pFrame;
if ( pSystemParentData )
pFrame = pSVData->mpDefInst->CreateChildFrame( pSystemParentData, nFrameStyle | SAL_FRAME_STYLE_PLUG );
else
pFrame = pSVData->mpDefInst->CreateFrame( pParentFrame, nFrameStyle );
if ( !pFrame )
{
// do not abort but throw an exception, may be the current thread terminates anyway (plugin-scenario)
throw ::com::sun::star::uno::RuntimeException(
OUString( RTL_CONSTASCII_USTRINGPARAM( "Could not create system window!" ) ),
::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );
//GetpApp()->Exception( EXC_SYSOBJNOTCREATED );
}
pFrame->SetCallback( this, ImplWindowFrameProc );
// set window frame data
mpWindowImpl->mpFrameData = new ImplFrameData;
mpWindowImpl->mpFrame = pFrame;
mpWindowImpl->mpFrameWindow = this;
mpWindowImpl->mpOverlapWindow = this;
// set frame data
mpWindowImpl->mpFrameData->mpNextFrame = pSVData->maWinData.mpFirstFrame;
pSVData->maWinData.mpFirstFrame = this;
mpWindowImpl->mpFrameData->mpFirstOverlap = NULL;
mpWindowImpl->mpFrameData->mpFocusWin = NULL;
mpWindowImpl->mpFrameData->mpMouseMoveWin = NULL;
mpWindowImpl->mpFrameData->mpMouseDownWin = NULL;
mpWindowImpl->mpFrameData->mpFirstBackWin = NULL;
mpWindowImpl->mpFrameData->mpFontList = pSVData->maGDIData.mpScreenFontList;
mpWindowImpl->mpFrameData->mpFontCache = pSVData->maGDIData.mpScreenFontCache;
mpWindowImpl->mpFrameData->mnAllSaveBackSize = 0;
mpWindowImpl->mpFrameData->mnFocusId = 0;
mpWindowImpl->mpFrameData->mnMouseMoveId = 0;
mpWindowImpl->mpFrameData->mnLastMouseX = -1;
mpWindowImpl->mpFrameData->mnLastMouseY = -1;
mpWindowImpl->mpFrameData->mnBeforeLastMouseX = -1;
mpWindowImpl->mpFrameData->mnBeforeLastMouseY = -1;
mpWindowImpl->mpFrameData->mnFirstMouseX = -1;
mpWindowImpl->mpFrameData->mnFirstMouseY = -1;
mpWindowImpl->mpFrameData->mnLastMouseWinX = -1;
mpWindowImpl->mpFrameData->mnLastMouseWinY = -1;
mpWindowImpl->mpFrameData->mnModalMode = 0;
mpWindowImpl->mpFrameData->mnMouseDownTime = 0;
mpWindowImpl->mpFrameData->mnClickCount = 0;
mpWindowImpl->mpFrameData->mnFirstMouseCode = 0;
mpWindowImpl->mpFrameData->mnMouseCode = 0;
mpWindowImpl->mpFrameData->mnMouseMode = 0;
mpWindowImpl->mpFrameData->meMapUnit = MAP_PIXEL;
mpWindowImpl->mpFrameData->mbHasFocus = sal_False;
mpWindowImpl->mpFrameData->mbInMouseMove = sal_False;
mpWindowImpl->mpFrameData->mbMouseIn = sal_False;
mpWindowImpl->mpFrameData->mbStartDragCalled = sal_False;
mpWindowImpl->mpFrameData->mbNeedSysWindow = sal_False;
mpWindowImpl->mpFrameData->mbMinimized = sal_False;
mpWindowImpl->mpFrameData->mbStartFocusState = sal_False;
mpWindowImpl->mpFrameData->mbInSysObjFocusHdl = sal_False;
mpWindowImpl->mpFrameData->mbInSysObjToTopHdl = sal_False;
mpWindowImpl->mpFrameData->mbSysObjFocus = sal_False;
mpWindowImpl->mpFrameData->maPaintTimer.SetTimeout( 30 );
mpWindowImpl->mpFrameData->maPaintTimer.SetTimeoutHdl( LINK( this, Window, ImplHandlePaintHdl ) );
mpWindowImpl->mpFrameData->maResizeTimer.SetTimeout( 50 );
mpWindowImpl->mpFrameData->maResizeTimer.SetTimeoutHdl( LINK( this, Window, ImplHandleResizeTimerHdl ) );
mpWindowImpl->mpFrameData->mbInternalDragGestureRecognizer = sal_False;
if ( pRealParent && IsTopWindow() )
{
ImplWinData* pParentWinData = pRealParent->ImplGetWinData();
pParentWinData->maTopWindowChildren.push_back( this );
}
}
// init data
mpWindowImpl->mpRealParent = pRealParent;
// #99318: make sure fontcache and list is available before call to SetSettings
mpFontList = mpWindowImpl->mpFrameData->mpFontList;
mpFontCache = mpWindowImpl->mpFrameData->mpFontCache;
if ( mpWindowImpl->mbFrame )
{
if ( pParent )
{
mpWindowImpl->mpFrameData->mnDPIX = pParent->mpWindowImpl->mpFrameData->mnDPIX;
mpWindowImpl->mpFrameData->mnDPIY = pParent->mpWindowImpl->mpFrameData->mnDPIY;
}
else
{
if ( ImplGetGraphics() )
{
mpGraphics->GetResolution( mpWindowImpl->mpFrameData->mnDPIX, mpWindowImpl->mpFrameData->mnDPIY );
}
}
// add ownerdraw decorated frame windows to list in the top-most frame window
// so they can be hidden on lose focus
if( nStyle & WB_OWNERDRAWDECORATION )
ImplGetOwnerDrawList().push_back( this );
// delay settings initialization until first "real" frame
// this relies on the IntroWindow not needing any system settings
if ( !pSVData->maAppData.mbSettingsInit &&
! (nStyle & (WB_INTROWIN|WB_DEFAULTWIN))
)
{
// side effect: ImplUpdateGlobalSettings does an ImplGetFrame()->UpdateSettings
ImplUpdateGlobalSettings( *pSVData->maAppData.mpSettings );
OutputDevice::SetSettings( *pSVData->maAppData.mpSettings );
pSVData->maAppData.mbSettingsInit = sal_True;
}
// If we create a Window with default size, query this
// size directly, because we want resize all Controls to
// the correct size before we display the window
if ( nStyle & (WB_MOVEABLE | WB_SIZEABLE | WB_APP) )
mpWindowImpl->mpFrame->GetClientSize( mnOutWidth, mnOutHeight );
}
else
{
if ( pParent )
{
if ( !ImplIsOverlapWindow() )
{
mpWindowImpl->mbDisabled = pParent->mpWindowImpl->mbDisabled;
mpWindowImpl->mbInputDisabled = pParent->mpWindowImpl->mbInputDisabled;
mpWindowImpl->meAlwaysInputMode = pParent->mpWindowImpl->meAlwaysInputMode;
}
OutputDevice::SetSettings( pParent->GetSettings() );
}
}
const StyleSettings& rStyleSettings = maSettings.GetStyleSettings();
sal_uInt16 nScreenZoom = rStyleSettings.GetScreenZoom();
mnDPIX = (mpWindowImpl->mpFrameData->mnDPIX*nScreenZoom)/100;
mnDPIY = (mpWindowImpl->mpFrameData->mnDPIY*nScreenZoom)/100;
maFont = rStyleSettings.GetAppFont();
ImplPointToLogic( maFont );
if ( nStyle & WB_3DLOOK )
{
SetTextColor( rStyleSettings.GetButtonTextColor() );
SetBackground( Wallpaper( rStyleSettings.GetFaceColor() ) );
}
else
{
SetTextColor( rStyleSettings.GetWindowTextColor() );
SetBackground( Wallpaper( rStyleSettings.GetWindowColor() ) );
}
ImplUpdatePos();
// calculate app font res (except for the Intro Window or the default window)
if ( mpWindowImpl->mbFrame && !pSVData->maGDIData.mnAppFontX && ! (nStyle & (WB_INTROWIN|WB_DEFAULTWIN)) )
ImplInitAppFontData( this );
if ( GetAccessibleParentWindow() && GetParent() != Application::GetDefDialogParent() )
GetAccessibleParentWindow()->ImplCallEventListeners( VCLEVENT_WINDOW_CHILDCREATED, this );
}
// -----------------------------------------------------------------------
void Window::ImplSetFrameParent( const Window* pParent )
{
Window* pFrameWindow = ImplGetSVData()->maWinData.mpFirstFrame;
while( pFrameWindow )
{
// search all frames that are children of this window
// and reparent them
if( ImplIsRealParentPath( pFrameWindow ) )
{
DBG_ASSERT( mpWindowImpl->mpFrame != pFrameWindow->mpWindowImpl->mpFrame, "SetFrameParent to own" );
DBG_ASSERT( mpWindowImpl->mpFrame, "no frame" );
SalFrame* pParentFrame = pParent ? pParent->mpWindowImpl->mpFrame : NULL;
pFrameWindow->mpWindowImpl->mpFrame->SetParent( pParentFrame );
}
pFrameWindow = pFrameWindow->mpWindowImpl->mpFrameData->mpNextFrame;
}
}
// -----------------------------------------------------------------------
void Window::ImplInsertWindow( Window* pParent )
{
mpWindowImpl->mpParent = pParent;
mpWindowImpl->mpRealParent = pParent;
if ( pParent && !mpWindowImpl->mbFrame )
{
// search frame window and set window frame data
Window* pFrameParent = pParent->mpWindowImpl->mpFrameWindow;
mpWindowImpl->mpFrameData = pFrameParent->mpWindowImpl->mpFrameData;
mpWindowImpl->mpFrame = pFrameParent->mpWindowImpl->mpFrame;
mpWindowImpl->mpFrameWindow = pFrameParent;
mpWindowImpl->mbFrame = sal_False;
// search overlap window and insert window in list
if ( ImplIsOverlapWindow() )
{
Window* pFirstOverlapParent = pParent;
while ( !pFirstOverlapParent->ImplIsOverlapWindow() )
pFirstOverlapParent = pFirstOverlapParent->ImplGetParent();
mpWindowImpl->mpOverlapWindow = pFirstOverlapParent;
mpWindowImpl->mpNextOverlap = mpWindowImpl->mpFrameData->mpFirstOverlap;
mpWindowImpl->mpFrameData->mpFirstOverlap = this;
// Overlap-Windows sind per default die obersten
mpWindowImpl->mpNext = pFirstOverlapParent->mpWindowImpl->mpFirstOverlap;
pFirstOverlapParent->mpWindowImpl->mpFirstOverlap = this;
if ( !pFirstOverlapParent->mpWindowImpl->mpLastOverlap )
pFirstOverlapParent->mpWindowImpl->mpLastOverlap = this;
else
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = this;
}
else
{
if ( pParent->ImplIsOverlapWindow() )
mpWindowImpl->mpOverlapWindow = pParent;
else
mpWindowImpl->mpOverlapWindow = pParent->mpWindowImpl->mpOverlapWindow;
mpWindowImpl->mpPrev = pParent->mpWindowImpl->mpLastChild;
pParent->mpWindowImpl->mpLastChild = this;
if ( !pParent->mpWindowImpl->mpFirstChild )
pParent->mpWindowImpl->mpFirstChild = this;
else
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
}
}
}
// -----------------------------------------------------------------------
void Window::ImplRemoveWindow( sal_Bool bRemoveFrameData )
{
// Fenster aus den Listen austragen
if ( !mpWindowImpl->mbFrame )
{
if ( ImplIsOverlapWindow() )
{
if ( mpWindowImpl->mpFrameData->mpFirstOverlap == this )
mpWindowImpl->mpFrameData->mpFirstOverlap = mpWindowImpl->mpNextOverlap;
else
{
Window* pTempWin = mpWindowImpl->mpFrameData->mpFirstOverlap;
while ( pTempWin->mpWindowImpl->mpNextOverlap != this )
pTempWin = pTempWin->mpWindowImpl->mpNextOverlap;
pTempWin->mpWindowImpl->mpNextOverlap = mpWindowImpl->mpNextOverlap;
}
if ( mpWindowImpl->mpPrev )
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
else
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = mpWindowImpl->mpNext;
if ( mpWindowImpl->mpNext )
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
else
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = mpWindowImpl->mpPrev;
}
else
{
if ( mpWindowImpl->mpPrev )
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
else
mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = mpWindowImpl->mpNext;
if ( mpWindowImpl->mpNext )
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
else
mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = mpWindowImpl->mpPrev;
}
mpWindowImpl->mpPrev = NULL;
mpWindowImpl->mpNext = NULL;
}
if ( bRemoveFrameData )
{
// Graphic freigeben
ImplReleaseGraphics();
}
}
// -----------------------------------------------------------------------
void Window::ImplCallResize()
{
mpWindowImpl->mbCallResize = sal_False;
if( GetBackground().IsGradient() )
Invalidate();
Resize();
// #88419# Most classes don't call the base class in Resize() and Move(),
// => Call ImpleResize/Move instead of Resize/Move directly...
ImplCallEventListeners( VCLEVENT_WINDOW_RESIZE );
ImplExtResize();
}
// -----------------------------------------------------------------------
void Window::ImplCallMove()
{
mpWindowImpl->mbCallMove = sal_False;
if( mpWindowImpl->mbFrame )
{
// update frame position
SalFrame *pParentFrame = NULL;
Window *pParent = ImplGetParent();
while( pParent )
{
if( pParent->mpWindowImpl->mpFrame != mpWindowImpl->mpFrame )
{
pParentFrame = pParent->mpWindowImpl->mpFrame;
break;
}
pParent = pParent->GetParent();
}
SalFrameGeometry g = mpWindowImpl->mpFrame->GetGeometry();
mpWindowImpl->maPos = Point( g.nX, g.nY );
if( pParentFrame )
{
g = pParentFrame->GetGeometry();
mpWindowImpl->maPos -= Point( g.nX, g.nY );
}
// the client window and and all its subclients have the same position as the borderframe
// this is important for floating toolbars where the borderwindow is a floating window
// which has another borderwindow (ie the system floating window)
Window *pClientWin = mpWindowImpl->mpClientWindow;
while( pClientWin )
{
pClientWin->mpWindowImpl->maPos = mpWindowImpl->maPos;
pClientWin = pClientWin->mpWindowImpl->mpClientWindow;
}
}
Move();
ImplCallEventListeners( VCLEVENT_WINDOW_MOVE );
}
// -----------------------------------------------------------------------
static rtl::OString ImplAutoHelpID( ResMgr* pResMgr )
{
rtl::OString aRet;
if( pResMgr && Application::IsAutoHelpIdEnabled() )
aRet = pResMgr->GetAutoHelpId();
return aRet;
}
// -----------------------------------------------------------------------
WinBits Window::ImplInitRes( const ResId& rResId )
{
GetRes( rResId );
char* pRes = (char*)GetClassRes();
pRes += 8;
sal_uInt32 nStyle = (sal_uInt32)GetLongRes( (void*)pRes );
rResId.SetWinBits( nStyle );
return nStyle;
}
// -----------------------------------------------------------------------
void Window::ImplLoadRes( const ResId& rResId )
{
sal_uLong nObjMask = ReadLongRes();
// we need to calculate auto helpids before the resource gets closed
// if the resource only contains flags, it will be closed before we try to read a help id
// so we always create an auto help id that might be overwritten later
// HelpId
rtl::OString aHelpId = ImplAutoHelpID( rResId.GetResMgr() );
// ResourceStyle
sal_uLong nRSStyle = ReadLongRes();
// WinBits
ReadLongRes();
if( nObjMask & WINDOW_HELPID )
aHelpId = ReadByteStringRes();
SetHelpId( aHelpId );
sal_Bool bPos = sal_False;
sal_Bool bSize = sal_False;
Point aPos;
Size aSize;
if ( nObjMask & (WINDOW_XYMAPMODE | WINDOW_X | WINDOW_Y) )
{
// Groessenangabe aus der Resource verwenden
MapUnit ePosMap = MAP_PIXEL;
bPos = sal_True;
if ( nObjMask & WINDOW_XYMAPMODE )
ePosMap = (MapUnit)ReadLongRes();
if ( nObjMask & WINDOW_X )
aPos.X() = ImplLogicUnitToPixelX( ReadLongRes(), ePosMap );
if ( nObjMask & WINDOW_Y )
aPos.Y() = ImplLogicUnitToPixelY( ReadLongRes(), ePosMap );
}
if ( nObjMask & (WINDOW_WHMAPMODE | WINDOW_WIDTH | WINDOW_HEIGHT) )
{
// Groessenangabe aus der Resource verwenden
MapUnit eSizeMap = MAP_PIXEL;
bSize = sal_True;
if ( nObjMask & WINDOW_WHMAPMODE )
eSizeMap = (MapUnit)ReadLongRes();
if ( nObjMask & WINDOW_WIDTH )
aSize.Width() = ImplLogicUnitToPixelX( ReadLongRes(), eSizeMap );
if ( nObjMask & WINDOW_HEIGHT )
aSize.Height() = ImplLogicUnitToPixelY( ReadLongRes(), eSizeMap );
}
// Wegen Optimierung so schlimm aussehend
if ( nRSStyle & RSWND_CLIENTSIZE )
{
if ( bPos )
SetPosPixel( aPos );
if ( bSize )
SetOutputSizePixel( aSize );
}
else if ( bPos && bSize )
SetPosSizePixel( aPos, aSize );
else if ( bPos )
SetPosPixel( aPos );
else if ( bSize )
SetSizePixel( aSize );
if ( nRSStyle & RSWND_DISABLED )
Enable( sal_False );
if ( nObjMask & WINDOW_TEXT )
SetText( ReadStringRes() );
if ( nObjMask & WINDOW_HELPTEXT )
{
SetHelpText( ReadStringRes() );
mpWindowImpl->mbHelpTextDynamic = sal_True;
}
if ( nObjMask & WINDOW_QUICKTEXT )
SetQuickHelpText( ReadStringRes() );
if ( nObjMask & WINDOW_EXTRALONG )
SetData( (void*)ReadLongRes() );
if ( nObjMask & WINDOW_UNIQUEID )
SetUniqueId( ReadByteStringRes() );
if ( nObjMask & WINDOW_BORDER_STYLE )
{
sal_uInt16 nBorderStyle = (sal_uInt16)ReadLongRes();
SetBorderStyle( nBorderStyle );
}
}
// -----------------------------------------------------------------------
ImplWinData* Window::ImplGetWinData() const
{
if ( !mpWindowImpl->mpWinData )
{
static const char* pNoNWF = getenv( "SAL_NO_NWF" );
((Window*)this)->mpWindowImpl->mpWinData = new ImplWinData;
mpWindowImpl->mpWinData->mpExtOldText = NULL;
mpWindowImpl->mpWinData->mpExtOldAttrAry = NULL;
mpWindowImpl->mpWinData->mpCursorRect = 0;
mpWindowImpl->mpWinData->mnCursorExtWidth = 0;
mpWindowImpl->mpWinData->mpFocusRect = NULL;
mpWindowImpl->mpWinData->mpTrackRect = NULL;
mpWindowImpl->mpWinData->mnTrackFlags = 0;
mpWindowImpl->mpWinData->mnIsTopWindow = (sal_uInt16) ~0; // not initialized yet, 0/1 will indicate TopWindow (see IsTopWindow())
mpWindowImpl->mpWinData->mbMouseOver = sal_False;
mpWindowImpl->mpWinData->mbEnableNativeWidget = (pNoNWF && *pNoNWF) ? sal_False : sal_True; // sal_True: try to draw this control with native theme API
}
return mpWindowImpl->mpWinData;
}
// -----------------------------------------------------------------------
SalGraphics* Window::ImplGetFrameGraphics() const
{
if ( mpWindowImpl->mpFrameWindow->mpGraphics )
mpWindowImpl->mpFrameWindow->mbInitClipRegion = sal_True;
else
mpWindowImpl->mpFrameWindow->ImplGetGraphics();
mpWindowImpl->mpFrameWindow->mpGraphics->ResetClipRegion();
return mpWindowImpl->mpFrameWindow->mpGraphics;
}
// -----------------------------------------------------------------------
Window* Window::ImplFindWindow( const Point& rFramePos )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
Window* pTempWindow;
Window* pFindWindow;
// Zuerst alle ueberlappenden Fenster ueberpruefen
pTempWindow = mpWindowImpl->mpFirstOverlap;
while ( pTempWindow )
{
pFindWindow = pTempWindow->ImplFindWindow( rFramePos );
if ( pFindWindow )
return pFindWindow;
pTempWindow = pTempWindow->mpWindowImpl->mpNext;
}
// dann testen wir unser Fenster
if ( !mpWindowImpl->mbVisible )
return NULL;
sal_uInt16 nHitTest = ImplHitTest( rFramePos );
if ( nHitTest & WINDOW_HITTEST_INSIDE )
{
// und danach gehen wir noch alle Child-Fenster durch
pTempWindow = mpWindowImpl->mpFirstChild;
while ( pTempWindow )
{
pFindWindow = pTempWindow->ImplFindWindow( rFramePos );
if ( pFindWindow )
return pFindWindow;
pTempWindow = pTempWindow->mpWindowImpl->mpNext;
}
if ( nHitTest & WINDOW_HITTEST_TRANSPARENT )
return NULL;
else
return this;
}
return NULL;
}
// -----------------------------------------------------------------------
sal_uInt16 Window::ImplHitTest( const Point& rFramePos )
{
Point aFramePos( rFramePos );
if( ImplIsAntiparallel() )
{
// - RTL - re-mirror frame pos at this window
ImplReMirror( aFramePos );
}
Rectangle aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
if ( !aRect.IsInside( aFramePos ) )
return 0;
if ( mpWindowImpl->mbWinRegion )
{
Point aTempPos = aFramePos;
aTempPos.X() -= mnOutOffX;
aTempPos.Y() -= mnOutOffY;
if ( !mpWindowImpl->maWinRegion.IsInside( aTempPos ) )
return 0;
}
sal_uInt16 nHitTest = WINDOW_HITTEST_INSIDE;
if ( mpWindowImpl->mbMouseTransparent )
nHitTest |= WINDOW_HITTEST_TRANSPARENT;
return nHitTest;
}
// -----------------------------------------------------------------------
sal_Bool Window::ImplIsRealParentPath( const Window* pWindow ) const
{
pWindow = pWindow->GetParent();
while ( pWindow )
{
if ( pWindow == this )
return sal_True;
pWindow = pWindow->GetParent();
}
return sal_False;
}
// -----------------------------------------------------------------------
sal_Bool Window::ImplIsChild( const Window* pWindow, sal_Bool bSystemWindow ) const
{
do
{
if ( !bSystemWindow && pWindow->ImplIsOverlapWindow() )
break;
pWindow = pWindow->ImplGetParent();
if ( pWindow == this )
return sal_True;
}
while ( pWindow );
return sal_False;
}
// -----------------------------------------------------------------------
sal_Bool Window::ImplIsWindowOrChild( const Window* pWindow, sal_Bool bSystemWindow ) const
{
if ( this == pWindow )
return sal_True;
return ImplIsChild( pWindow, bSystemWindow );
}
// -----------------------------------------------------------------------
Window* Window::ImplGetSameParent( const Window* pWindow ) const
{
if ( mpWindowImpl->mpFrameWindow != pWindow->mpWindowImpl->mpFrameWindow )
return NULL;
else
{
if ( pWindow->ImplIsChild( this ) )
return (Window*)pWindow;
else
{
Window* pTestWindow = (Window*)this;
while ( (pTestWindow == pWindow) || pTestWindow->ImplIsChild( pWindow ) )
pTestWindow = pTestWindow->ImplGetParent();
return pTestWindow;
}
}
}
// -----------------------------------------------------------------------
int Window::ImplTestMousePointerSet()
{
// Wenn Mouse gecaptured ist, dann soll MousePointer umgeschaltet werden
if ( IsMouseCaptured() )
return sal_True;
// Wenn sich Mouse ueber dem Fenster befindet, dann soll MousePointer
// umgeschaltet werden
Rectangle aClientRect( Point( 0, 0 ), GetOutputSizePixel() );
if ( aClientRect.IsInside( GetPointerPosPixel() ) )
return sal_True;
return sal_False;
}
// -----------------------------------------------------------------------
PointerStyle Window::ImplGetMousePointer() const
{
PointerStyle ePointerStyle;
sal_Bool bWait = sal_False;
if ( IsEnabled() && IsInputEnabled() && ! IsInModalMode() )
ePointerStyle = GetPointer().GetStyle();
else
ePointerStyle = POINTER_ARROW;
const Window* pWindow = this;
do
{
// Wenn Pointer nicht sichtbar, dann wird suche abgebrochen, da
// dieser Status nicht ueberschrieben werden darf
if ( pWindow->mpWindowImpl->mbNoPtrVisible )
return POINTER_NULL;
if ( !bWait )
{
if ( pWindow->mpWindowImpl->mnWaitCount )
{
ePointerStyle = POINTER_WAIT;
bWait = sal_True;
}
else
{
if ( pWindow->mpWindowImpl->mbChildPtrOverwrite )
ePointerStyle = pWindow->GetPointer().GetStyle();
}
}
if ( pWindow->ImplIsOverlapWindow() )
break;
pWindow = pWindow->ImplGetParent();
}
while ( pWindow );
return ePointerStyle;
}
// -----------------------------------------------------------------------
void Window::ImplResetReallyVisible()
{
sal_Bool bBecameReallyInvisible = mpWindowImpl->mbReallyVisible;
mbDevOutput = sal_False;
mpWindowImpl->mbReallyVisible = sal_False;
mpWindowImpl->mbReallyShown = sal_False;
// the SHOW/HIDE events serve as indicators to send child creation/destroy events to the access bridge.
// For this, the data member of the event must not be NULL.
// Previously, we did this in Window::Show, but there some events got lost in certain situations.
// #104887# - 2004-08-10 - fs@openoffice.org
if( bBecameReallyInvisible && ImplIsAccessibleCandidate() )
ImplCallEventListeners( VCLEVENT_WINDOW_HIDE, this );
// TODO. It's kind of a hack that we're re-using the VCLEVENT_WINDOW_HIDE. Normally, we should
// introduce another event which explicitly triggers the Accessibility implementations.
Window* pWindow = mpWindowImpl->mpFirstOverlap;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbReallyVisible )
pWindow->ImplResetReallyVisible();
pWindow = pWindow->mpWindowImpl->mpNext;
}
pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbReallyVisible )
pWindow->ImplResetReallyVisible();
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplSetReallyVisible()
{
// #i43594# it is possible that INITSHOW was never send, because the visibility state changed between
// ImplCallInitShow() and ImplSetReallyVisible() when called from Show()
// mbReallyShown is a useful indicator
if( !mpWindowImpl->mbReallyShown )
ImplCallInitShow();
sal_Bool bBecameReallyVisible = !mpWindowImpl->mbReallyVisible;
mbDevOutput = sal_True;
mpWindowImpl->mbReallyVisible = sal_True;
mpWindowImpl->mbReallyShown = sal_True;
// the SHOW/HIDE events serve as indicators to send child creation/destroy events to the access bridge.
// For this, the data member of the event must not be NULL.
// Previously, we did this in Window::Show, but there some events got lost in certain situations. Now
// we're doing it when the visibility really changes
// #104887# - 2004-08-10 - fs@openoffice.org
if( bBecameReallyVisible && ImplIsAccessibleCandidate() )
ImplCallEventListeners( VCLEVENT_WINDOW_SHOW, this );
// TODO. It's kind of a hack that we're re-using the VCLEVENT_WINDOW_SHOW. Normally, we should
// introduce another event which explicitly triggers the Accessibility implementations.
Window* pWindow = mpWindowImpl->mpFirstOverlap;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbVisible )
pWindow->ImplSetReallyVisible();
pWindow = pWindow->mpWindowImpl->mpNext;
}
pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbVisible )
pWindow->ImplSetReallyVisible();
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplCallInitShow()
{
mpWindowImpl->mbReallyShown = sal_True;
mpWindowImpl->mbInInitShow = sal_True;
StateChanged( STATE_CHANGE_INITSHOW );
mpWindowImpl->mbInInitShow = sal_False;
Window* pWindow = mpWindowImpl->mpFirstOverlap;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbVisible )
pWindow->ImplCallInitShow();
pWindow = pWindow->mpWindowImpl->mpNext;
}
pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbVisible )
pWindow->ImplCallInitShow();
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplAddDel( ImplDelData* pDel ) // TODO: make "const" when incompatiblity ok
{
DBG_ASSERT( !pDel->mpWindow, "Window::ImplAddDel(): cannot add ImplDelData twice !" );
if( !pDel->mpWindow )
{
pDel->mpWindow = this; // #112873# store ref to this window, so pDel can remove itself
pDel->mpNext = mpWindowImpl->mpFirstDel;
mpWindowImpl->mpFirstDel = pDel;
}
}
// -----------------------------------------------------------------------
void Window::ImplRemoveDel( ImplDelData* pDel ) // TODO: make "const" when incompatiblity ok
{
pDel->mpWindow = NULL; // #112873# pDel is not associated with a Window anymore
if ( mpWindowImpl->mpFirstDel == pDel )
mpWindowImpl->mpFirstDel = pDel->mpNext;
else
{
ImplDelData* pData = mpWindowImpl->mpFirstDel;
while ( pData->mpNext != pDel )
pData = pData->mpNext;
pData->mpNext = pDel->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplInitResolutionSettings()
{
// AppFont-Aufloesung und DPI-Aufloesung neu berechnen
if ( mpWindowImpl->mbFrame )
{
const StyleSettings& rStyleSettings = maSettings.GetStyleSettings();
sal_uInt16 nScreenZoom = rStyleSettings.GetScreenZoom();
mnDPIX = (mpWindowImpl->mpFrameData->mnDPIX*nScreenZoom)/100;
mnDPIY = (mpWindowImpl->mpFrameData->mnDPIY*nScreenZoom)/100;
SetPointFont( rStyleSettings.GetAppFont() );
}
else if ( mpWindowImpl->mpParent )
{
mnDPIX = mpWindowImpl->mpParent->mnDPIX;
mnDPIY = mpWindowImpl->mpParent->mnDPIY;
}
// Vorberechnete Werte fuer logische Einheiten updaten und auch
// die entsprechenden Tools dazu
if ( IsMapMode() )
{
MapMode aMapMode = GetMapMode();
SetMapMode();
SetMapMode( aMapMode );
}
}
// -----------------------------------------------------------------------
void Window::ImplPointToLogic( Font& rFont ) const
{
Size aSize = rFont.GetSize();
sal_uInt16 nScreenFontZoom = maSettings.GetStyleSettings().GetScreenFontZoom();
if ( aSize.Width() )
{
aSize.Width() *= mpWindowImpl->mpFrameData->mnDPIX;
aSize.Width() += 72/2;
aSize.Width() /= 72;
aSize.Width() *= nScreenFontZoom;
aSize.Width() /= 100;
}
aSize.Height() *= mpWindowImpl->mpFrameData->mnDPIY;
aSize.Height() += 72/2;
aSize.Height() /= 72;
aSize.Height() *= nScreenFontZoom;
aSize.Height() /= 100;
if ( IsMapModeEnabled() )
aSize = PixelToLogic( aSize );
rFont.SetSize( aSize );
}
// -----------------------------------------------------------------------
void Window::ImplLogicToPoint( Font& rFont ) const
{
Size aSize = rFont.GetSize();
sal_uInt16 nScreenFontZoom = maSettings.GetStyleSettings().GetScreenFontZoom();
if ( IsMapModeEnabled() )
aSize = LogicToPixel( aSize );
if ( aSize.Width() )
{
aSize.Width() *= 100;
aSize.Width() /= nScreenFontZoom;
aSize.Width() *= 72;
aSize.Width() += mpWindowImpl->mpFrameData->mnDPIX/2;
aSize.Width() /= mpWindowImpl->mpFrameData->mnDPIX;
}
aSize.Height() *= 100;
aSize.Height() /= nScreenFontZoom;
aSize.Height() *= 72;
aSize.Height() += mpWindowImpl->mpFrameData->mnDPIY/2;
aSize.Height() /= mpWindowImpl->mpFrameData->mnDPIY;
rFont.SetSize( aSize );
}
// -----------------------------------------------------------------------
sal_Bool Window::ImplSysObjClip( const Region* pOldRegion )
{
sal_Bool bUpdate = sal_True;
if ( mpWindowImpl->mpSysObj )
{
sal_Bool bVisibleState = mpWindowImpl->mbReallyVisible;
if ( bVisibleState )
{
Region* pWinChildClipRegion = ImplGetWinChildClipRegion();
if ( !pWinChildClipRegion->IsEmpty() )
{
if ( pOldRegion )
{
Region aNewRegion = *pWinChildClipRegion;
pWinChildClipRegion->Intersect( *pOldRegion );
bUpdate = aNewRegion == *pWinChildClipRegion;
}
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
Region aRegion = *pWinChildClipRegion;
Rectangle aWinRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
Region aWinRectRegion( aWinRect );
sal_uInt16 nClipFlags = mpWindowImpl->mpSysObj->GetClipRegionType();
if ( aRegion == aWinRectRegion )
mpWindowImpl->mpSysObj->ResetClipRegion();
else
{
if ( nClipFlags & SAL_OBJECT_CLIP_EXCLUDERECTS )
{
aWinRectRegion.Exclude( aRegion );
aRegion = aWinRectRegion;
}
if ( !(nClipFlags & SAL_OBJECT_CLIP_ABSOLUTE) )
aRegion.Move( -mnOutOffX, -mnOutOffY );
// ClipRegion setzen/updaten
RectangleVector aRectangles;
aRegion.GetRegionRectangles(aRectangles);
mpWindowImpl->mpSysObj->BeginSetClipRegion(aRectangles.size());
for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++)
{
mpWindowImpl->mpSysObj->UnionClipRegion(
aRectIter->Left(),
aRectIter->Top(),
aRectIter->GetWidth(), // orig nWidth was ((R - L) + 1), same as GetWidth does
aRectIter->GetHeight()); // same for height
}
mpWindowImpl->mpSysObj->EndSetClipRegion();
//long nX;
//long nY;
//long nWidth;
//long nHeight;
//sal_uLong nRectCount;
//ImplRegionInfo aInfo;
//sal_Bool bRegionRect;
//
//nRectCount = aRegion.GetRectCount();
//mpWindowImpl->mpSysObj->BeginSetClipRegion( nRectCount );
//bRegionRect = aRegion.ImplGetFirstRect( aInfo, nX, nY, nWidth, nHeight );
//while ( bRegionRect )
//{
// mpWindowImpl->mpSysObj->UnionClipRegion( nX, nY, nWidth, nHeight );
// bRegionRect = aRegion.ImplGetNextRect( aInfo, nX, nY, nWidth, nHeight );
//}
//mpWindowImpl->mpSysObj->EndSetClipRegion();
}
}
else
bVisibleState = sal_False;
}
// Visible-Status updaten
mpWindowImpl->mpSysObj->Show( bVisibleState );
}
return bUpdate;
}
// -----------------------------------------------------------------------
void Window::ImplUpdateSysObjChildsClip()
{
if ( mpWindowImpl->mpSysObj && mpWindowImpl->mbInitWinClipRegion )
ImplSysObjClip( NULL );
Window* pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
pWindow->ImplUpdateSysObjChildsClip();
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplUpdateSysObjOverlapsClip()
{
ImplUpdateSysObjChildsClip();
Window* pWindow = mpWindowImpl->mpFirstOverlap;
while ( pWindow )
{
pWindow->ImplUpdateSysObjOverlapsClip();
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplUpdateSysObjClip()
{
if ( !ImplIsOverlapWindow() )
{
ImplUpdateSysObjChildsClip();
// Schwestern muessen ihre ClipRegion auch neu berechnen
if ( mpWindowImpl->mbClipSiblings )
{
Window* pWindow = mpWindowImpl->mpNext;
while ( pWindow )
{
pWindow->ImplUpdateSysObjChildsClip();
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
}
else
mpWindowImpl->mpFrameWindow->ImplUpdateSysObjOverlapsClip();
}
// -----------------------------------------------------------------------
sal_Bool Window::ImplSetClipFlagChilds( sal_Bool bSysObjOnlySmaller )
{
sal_Bool bUpdate = sal_True;
if ( mpWindowImpl->mpSysObj )
{
Region* pOldRegion = NULL;
if ( bSysObjOnlySmaller && !mpWindowImpl->mbInitWinClipRegion )
pOldRegion = new Region( mpWindowImpl->maWinClipRegion );
mbInitClipRegion = sal_True;
mpWindowImpl->mbInitWinClipRegion = sal_True;
Window* pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
if ( !pWindow->ImplSetClipFlagChilds( bSysObjOnlySmaller ) )
bUpdate = sal_False;
pWindow = pWindow->mpWindowImpl->mpNext;
}
if ( !ImplSysObjClip( pOldRegion ) )
{
mbInitClipRegion = sal_True;
mpWindowImpl->mbInitWinClipRegion = sal_True;
bUpdate = sal_False;
}
if ( pOldRegion )
delete pOldRegion;
}
else
{
mbInitClipRegion = sal_True;
mpWindowImpl->mbInitWinClipRegion = sal_True;
Window* pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
if ( !pWindow->ImplSetClipFlagChilds( bSysObjOnlySmaller ) )
bUpdate = sal_False;
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
return bUpdate;
}
// -----------------------------------------------------------------------
sal_Bool Window::ImplSetClipFlagOverlapWindows( sal_Bool bSysObjOnlySmaller )
{
sal_Bool bUpdate = ImplSetClipFlagChilds( bSysObjOnlySmaller );
Window* pWindow = mpWindowImpl->mpFirstOverlap;
while ( pWindow )
{
if ( !pWindow->ImplSetClipFlagOverlapWindows( bSysObjOnlySmaller ) )
bUpdate = sal_False;
pWindow = pWindow->mpWindowImpl->mpNext;
}
return bUpdate;
}
// -----------------------------------------------------------------------
sal_Bool Window::ImplSetClipFlag( sal_Bool bSysObjOnlySmaller )
{
if ( !ImplIsOverlapWindow() )
{
sal_Bool bUpdate = ImplSetClipFlagChilds( bSysObjOnlySmaller );
Window* pParent = ImplGetParent();
if ( pParent &&
((pParent->GetStyle() & WB_CLIPCHILDREN) || (mpWindowImpl->mnParentClipMode & PARENTCLIPMODE_CLIP)) )
{
pParent->mbInitClipRegion = sal_True;
pParent->mpWindowImpl->mbInitChildRegion = sal_True;
}
// Schwestern muessen ihre ClipRegion auch neu berechnen
if ( mpWindowImpl->mbClipSiblings )
{
Window* pWindow = mpWindowImpl->mpNext;
while ( pWindow )
{
if ( !pWindow->ImplSetClipFlagChilds( bSysObjOnlySmaller ) )
bUpdate = sal_False;
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
return bUpdate;
}
else
return mpWindowImpl->mpFrameWindow->ImplSetClipFlagOverlapWindows( bSysObjOnlySmaller );
}
// -----------------------------------------------------------------------
void Window::ImplIntersectWindowClipRegion( Region& rRegion )
{
if ( mpWindowImpl->mbInitWinClipRegion )
ImplInitWinClipRegion();
rRegion.Intersect( mpWindowImpl->maWinClipRegion );
}
// -----------------------------------------------------------------------
void Window::ImplIntersectWindowRegion( Region& rRegion )
{
rRegion.Intersect( Rectangle( Point( mnOutOffX, mnOutOffY ),
Size( mnOutWidth, mnOutHeight ) ) );
if ( mpWindowImpl->mbWinRegion )
rRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
}
// -----------------------------------------------------------------------
void Window::ImplExcludeWindowRegion( Region& rRegion )
{
if ( mpWindowImpl->mbWinRegion )
{
Point aPoint( mnOutOffX, mnOutOffY );
Region aRegion( Rectangle( aPoint,
Size( mnOutWidth, mnOutHeight ) ) );
aRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
rRegion.Exclude( aRegion );
}
else
{
Point aPoint( mnOutOffX, mnOutOffY );
rRegion.Exclude( Rectangle( aPoint,
Size( mnOutWidth, mnOutHeight ) ) );
}
}
// -----------------------------------------------------------------------
void Window::ImplExcludeOverlapWindows( Region& rRegion )
{
Window* pWindow = mpWindowImpl->mpFirstOverlap;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbReallyVisible )
{
pWindow->ImplExcludeWindowRegion( rRegion );
pWindow->ImplExcludeOverlapWindows( rRegion );
}
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplExcludeOverlapWindows2( Region& rRegion )
{
if ( mpWindowImpl->mbReallyVisible )
ImplExcludeWindowRegion( rRegion );
ImplExcludeOverlapWindows( rRegion );
}
// -----------------------------------------------------------------------
void Window::ImplClipBoundaries( Region& rRegion, sal_Bool bThis, sal_Bool bOverlaps )
{
if ( bThis )
ImplIntersectWindowClipRegion( rRegion );
else if ( ImplIsOverlapWindow() )
{
// Evt. noch am Frame clippen
if ( !mpWindowImpl->mbFrame )
rRegion.Intersect( Rectangle( Point( 0, 0 ), Size( mpWindowImpl->mpFrameWindow->mnOutWidth, mpWindowImpl->mpFrameWindow->mnOutHeight ) ) );
if ( bOverlaps && !rRegion.IsEmpty() )
{
// Clip Overlap Siblings
Window* pStartOverlapWindow = this;
while ( !pStartOverlapWindow->mpWindowImpl->mbFrame )
{
Window* pOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
while ( pOverlapWindow && (pOverlapWindow != pStartOverlapWindow) )
{
pOverlapWindow->ImplExcludeOverlapWindows2( rRegion );
pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
}
pStartOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow;
}
// Clip Child Overlap Windows
ImplExcludeOverlapWindows( rRegion );
}
}
else
ImplGetParent()->ImplIntersectWindowClipRegion( rRegion );
}
// -----------------------------------------------------------------------
sal_Bool Window::ImplClipChilds( Region& rRegion )
{
sal_Bool bOtherClip = sal_False;
Window* pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbReallyVisible )
{
// ParentClipMode-Flags auswerten
sal_uInt16 nClipMode = pWindow->GetParentClipMode();
if ( !(nClipMode & PARENTCLIPMODE_NOCLIP) &&
((nClipMode & PARENTCLIPMODE_CLIP) || (GetStyle() & WB_CLIPCHILDREN)) )
pWindow->ImplExcludeWindowRegion( rRegion );
else
bOtherClip = sal_True;
}
pWindow = pWindow->mpWindowImpl->mpNext;
}
return bOtherClip;
}
// -----------------------------------------------------------------------
void Window::ImplClipAllChilds( Region& rRegion )
{
Window* pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbReallyVisible )
pWindow->ImplExcludeWindowRegion( rRegion );
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplClipSiblings( Region& rRegion )
{
Window* pWindow = ImplGetParent()->mpWindowImpl->mpFirstChild;
while ( pWindow )
{
if ( pWindow == this )
break;
if ( pWindow->mpWindowImpl->mbReallyVisible )
pWindow->ImplExcludeWindowRegion( rRegion );
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplInitWinClipRegion()
{
// Build Window Region
mpWindowImpl->maWinClipRegion = Rectangle( Point( mnOutOffX, mnOutOffY ),
Size( mnOutWidth, mnOutHeight ) );
if ( mpWindowImpl->mbWinRegion )
mpWindowImpl->maWinClipRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
// ClipSiblings
if ( mpWindowImpl->mbClipSiblings && !ImplIsOverlapWindow() )
ImplClipSiblings( mpWindowImpl->maWinClipRegion );
// Clip Parent Boundaries
ImplClipBoundaries( mpWindowImpl->maWinClipRegion, sal_False, sal_True );
// Clip Children
if ( (GetStyle() & WB_CLIPCHILDREN) || mpWindowImpl->mbClipChildren )
mpWindowImpl->mbInitChildRegion = sal_True;
mpWindowImpl->mbInitWinClipRegion = sal_False;
}
// -----------------------------------------------------------------------
void Window::ImplInitWinChildClipRegion()
{
if ( !mpWindowImpl->mpFirstChild )
{
if ( mpWindowImpl->mpChildClipRegion )
{
delete mpWindowImpl->mpChildClipRegion;
mpWindowImpl->mpChildClipRegion = NULL;
}
}
else
{
if ( !mpWindowImpl->mpChildClipRegion )
mpWindowImpl->mpChildClipRegion = new Region( mpWindowImpl->maWinClipRegion );
else
*mpWindowImpl->mpChildClipRegion = mpWindowImpl->maWinClipRegion;
ImplClipChilds( *mpWindowImpl->mpChildClipRegion );
}
mpWindowImpl->mbInitChildRegion = sal_False;
}
// -----------------------------------------------------------------------
Region* Window::ImplGetWinChildClipRegion()
{
if ( mpWindowImpl->mbInitWinClipRegion )
ImplInitWinClipRegion();
if ( mpWindowImpl->mbInitChildRegion )
ImplInitWinChildClipRegion();
if ( mpWindowImpl->mpChildClipRegion )
return mpWindowImpl->mpChildClipRegion;
else
return &mpWindowImpl->maWinClipRegion;
}
// -----------------------------------------------------------------------
void Window::ImplIntersectAndUnionOverlapWindows( const Region& rInterRegion, Region& rRegion )
{
Window* pWindow = mpWindowImpl->mpFirstOverlap;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbReallyVisible )
{
Region aTempRegion( rInterRegion );
pWindow->ImplIntersectWindowRegion( aTempRegion );
rRegion.Union( aTempRegion );
pWindow->ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
}
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplIntersectAndUnionOverlapWindows2( const Region& rInterRegion, Region& rRegion )
{
if ( mpWindowImpl->mbReallyVisible )
{
Region aTempRegion( rInterRegion );
ImplIntersectWindowRegion( aTempRegion );
rRegion.Union( aTempRegion );
}
ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
}
// -----------------------------------------------------------------------
void Window::ImplCalcOverlapRegionOverlaps( const Region& rInterRegion, Region& rRegion )
{
// Clip Overlap Siblings
Window* pStartOverlapWindow;
if ( !ImplIsOverlapWindow() )
pStartOverlapWindow = mpWindowImpl->mpOverlapWindow;
else
pStartOverlapWindow = this;
while ( !pStartOverlapWindow->mpWindowImpl->mbFrame )
{
Window* pOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
while ( pOverlapWindow && (pOverlapWindow != pStartOverlapWindow) )
{
pOverlapWindow->ImplIntersectAndUnionOverlapWindows2( rInterRegion, rRegion );
pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
}
pStartOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow;
}
// Clip Child Overlap Windows
if ( !ImplIsOverlapWindow() )
mpWindowImpl->mpOverlapWindow->ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
else
ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
}
// -----------------------------------------------------------------------
void Window::ImplCalcOverlapRegion( const Rectangle& rSourceRect, Region& rRegion,
sal_Bool bChilds, sal_Bool bParent, sal_Bool bSiblings )
{
Region aRegion( rSourceRect );
if ( mpWindowImpl->mbWinRegion )
rRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
Region aTempRegion;
Window* pWindow;
ImplCalcOverlapRegionOverlaps( aRegion, rRegion );
// Parent-Boundaries
if ( bParent )
{
pWindow = this;
if ( !ImplIsOverlapWindow() )
{
pWindow = ImplGetParent();
do
{
aTempRegion = aRegion;
pWindow->ImplExcludeWindowRegion( aTempRegion );
rRegion.Union( aTempRegion );
if ( pWindow->ImplIsOverlapWindow() )
break;
pWindow = pWindow->ImplGetParent();
}
while ( pWindow );
}
if ( !pWindow->mpWindowImpl->mbFrame )
{
aTempRegion = aRegion;
aTempRegion.Exclude( Rectangle( Point( 0, 0 ), Size( mpWindowImpl->mpFrameWindow->mnOutWidth, mpWindowImpl->mpFrameWindow->mnOutHeight ) ) );
rRegion.Union( aTempRegion );
}
}
// Siblings
if ( bSiblings && !ImplIsOverlapWindow() )
{
pWindow = mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild;
do
{
if ( pWindow->mpWindowImpl->mbReallyVisible && (pWindow != this) )
{
aTempRegion = aRegion;
pWindow->ImplIntersectWindowRegion( aTempRegion );
rRegion.Union( aTempRegion );
}
pWindow = pWindow->mpWindowImpl->mpNext;
}
while ( pWindow );
}
// Childs
if ( bChilds )
{
pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
if ( pWindow->mpWindowImpl->mbReallyVisible )
{
aTempRegion = aRegion;
pWindow->ImplIntersectWindowRegion( aTempRegion );
rRegion.Union( aTempRegion );
}
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
}
// -----------------------------------------------------------------------
void Window::ImplCallPaint( const Region* pRegion, sal_uInt16 nPaintFlags )
{
Exception aException;
bool bExceptionCaught(false);
// call PrePaint. PrePaint may add to the invalidate region as well as
// other parameters used below.
PrePaint();
mpWindowImpl->mbPaintFrame = sal_False;
if ( nPaintFlags & IMPL_PAINT_PAINTALLCHILDS )
mpWindowImpl->mnPaintFlags |= IMPL_PAINT_PAINT | IMPL_PAINT_PAINTALLCHILDS | (nPaintFlags & IMPL_PAINT_PAINTALL);
if ( nPaintFlags & IMPL_PAINT_PAINTCHILDS )
mpWindowImpl->mnPaintFlags |= IMPL_PAINT_PAINTCHILDS;
if ( nPaintFlags & IMPL_PAINT_ERASE )
mpWindowImpl->mnPaintFlags |= IMPL_PAINT_ERASE;
if ( nPaintFlags & IMPL_PAINT_CHECKRTL )
mpWindowImpl->mnPaintFlags |= IMPL_PAINT_CHECKRTL;
if ( !mpWindowImpl->mpFirstChild )
mpWindowImpl->mnPaintFlags &= ~IMPL_PAINT_PAINTALLCHILDS;
if ( mpWindowImpl->mbPaintDisabled )
{
if ( mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALL )
Invalidate( INVALIDATE_NOCHILDREN | INVALIDATE_NOERASE | INVALIDATE_NOTRANSPARENT | INVALIDATE_NOCLIPCHILDREN );
else if ( pRegion )
Invalidate( *pRegion, INVALIDATE_NOCHILDREN | INVALIDATE_NOERASE | INVALIDATE_NOTRANSPARENT | INVALIDATE_NOCLIPCHILDREN );
return;
}
nPaintFlags = mpWindowImpl->mnPaintFlags & ~(IMPL_PAINT_PAINT);
Region* pChildRegion = NULL;
Rectangle aSelectionRect;
if ( mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINT )
{
Region* pWinChildClipRegion = ImplGetWinChildClipRegion();
if ( mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALL )
mpWindowImpl->maInvalidateRegion = *pWinChildClipRegion;
else
{
if ( pRegion )
mpWindowImpl->maInvalidateRegion.Union( *pRegion );
if( mpWindowImpl->mpWinData && mpWindowImpl->mbTrackVisible )
/* #98602# need to repaint all children within the
* tracking rectangle, so the following invert
* operation takes places without traces of the previous
* one.
*/
mpWindowImpl->maInvalidateRegion.Union( *mpWindowImpl->mpWinData->mpTrackRect );
if ( mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALLCHILDS )
pChildRegion = new Region( mpWindowImpl->maInvalidateRegion );
mpWindowImpl->maInvalidateRegion.Intersect( *pWinChildClipRegion );
}
mpWindowImpl->mnPaintFlags = 0;
if ( !mpWindowImpl->maInvalidateRegion.IsEmpty() )
{
bool bRestoreCursor = false;
if ( mpWindowImpl->mpCursor )
bRestoreCursor = mpWindowImpl->mpCursor->ImplHide( false );
mbInitClipRegion = sal_True;
mpWindowImpl->mbInPaint = sal_True;
// Paint-Region zuruecksetzen
Region aPaintRegion( mpWindowImpl->maInvalidateRegion );
Rectangle aPaintRect = aPaintRegion.GetBoundRect();
// - RTL - re-mirror paint rect and region at this window
if( ImplIsAntiparallel() )
{
ImplReMirror( aPaintRect );
ImplReMirror( aPaintRegion );
}
aPaintRect = ImplDevicePixelToLogic( aPaintRect);
mpWindowImpl->mpPaintRegion = &aPaintRegion;
mpWindowImpl->maInvalidateRegion.SetEmpty();
if ( (nPaintFlags & IMPL_PAINT_ERASE) && IsBackground() )
{
if ( IsClipRegion() )
{
Region aOldRegion = GetClipRegion();
SetClipRegion();
Erase();
SetClipRegion( aOldRegion );
}
else
Erase();
}
// #98943# trigger drawing of toolbox selection after all childern are painted
if( mpWindowImpl->mbDrawSelectionBackground )
aSelectionRect = aPaintRect;
// Paint can throw exceptions; to not have a situation where
// mpWindowImpl->mbInPaint keeps to be on true (and other
// settings, too) better catch here to avoid to go completely out of
// this method without executing the after-paint stuff
try
{
Paint( aPaintRect );
}
catch(Exception& rException)
{
aException = rException;
bExceptionCaught = true;
}
if ( mpWindowImpl->mpWinData )
{
if ( mpWindowImpl->mbFocusVisible )
ImplInvertFocus( *(mpWindowImpl->mpWinData->mpFocusRect) );
}
mpWindowImpl->mbInPaint = sal_False;
mbInitClipRegion = sal_True;
mpWindowImpl->mpPaintRegion = NULL;
if ( mpWindowImpl->mpCursor )
mpWindowImpl->mpCursor->ImplShow( false, bRestoreCursor );
}
}
else
mpWindowImpl->mnPaintFlags = 0;
if ( nPaintFlags & (IMPL_PAINT_PAINTALLCHILDS | IMPL_PAINT_PAINTCHILDS) )
{
// die Childfenster ausgeben
Window* pTempWindow = mpWindowImpl->mpFirstChild;
while ( pTempWindow )
{
if ( pTempWindow->mpWindowImpl->mbVisible )
pTempWindow->ImplCallPaint( pChildRegion, nPaintFlags );
pTempWindow = pTempWindow->mpWindowImpl->mpNext;
}
}
if ( mpWindowImpl->mpWinData && mpWindowImpl->mbTrackVisible && (mpWindowImpl->mpWinData->mnTrackFlags & SHOWTRACK_WINDOW) )
/* #98602# need to invert the tracking rect AFTER
* the children have painted
*/
InvertTracking( *(mpWindowImpl->mpWinData->mpTrackRect), mpWindowImpl->mpWinData->mnTrackFlags );
// #98943# draw toolbox selection
if( !aSelectionRect.IsEmpty() )
DrawSelectionBackground( aSelectionRect, 3, sal_False, sal_True, sal_False );
if ( pChildRegion )
delete pChildRegion;
if(bExceptionCaught)
{
throw(aException);
}
}
// -----------------------------------------------------------------------
void Window::ImplCallOverlapPaint()
{
// Zuerst geben wir die ueberlappenden Fenster aus
Window* pTempWindow = mpWindowImpl->mpFirstOverlap;
while ( pTempWindow )
{
if ( pTempWindow->mpWindowImpl->mbReallyVisible )
pTempWindow->ImplCallOverlapPaint();
pTempWindow = pTempWindow->mpWindowImpl->mpNext;
}
// und dann erst uns selber
if ( mpWindowImpl->mnPaintFlags & (IMPL_PAINT_PAINT | IMPL_PAINT_PAINTCHILDS) )
{
// - RTL - notify ImplCallPaint to check for re-mirroring (CHECKRTL)
// because we were called from the Sal layer
ImplCallPaint( NULL, mpWindowImpl->mnPaintFlags /*| IMPL_PAINT_CHECKRTL */);
}
}
// -----------------------------------------------------------------------
void Window::ImplPostPaint()
{
if ( !mpWindowImpl->mpFrameData->maPaintTimer.IsActive() )
mpWindowImpl->mpFrameData->maPaintTimer.Start();
}
// -----------------------------------------------------------------------
IMPL_LINK( Window, ImplHandlePaintHdl, void*, EMPTYARG )
{
// save paint events until resizing is done
if( mpWindowImpl->mbFrame && mpWindowImpl->mpFrameData->maResizeTimer.IsActive() )
mpWindowImpl->mpFrameData->maPaintTimer.Start();
else if ( mpWindowImpl->mbReallyVisible )
ImplCallOverlapPaint();
return 0;
}
// -----------------------------------------------------------------------
IMPL_LINK( Window, ImplHandleResizeTimerHdl, void*, EMPTYARG )
{
if( mpWindowImpl->mbReallyVisible )
{
ImplCallResize();
if( mpWindowImpl->mpFrameData->maPaintTimer.IsActive() )
{
mpWindowImpl->mpFrameData->maPaintTimer.Stop();
mpWindowImpl->mpFrameData->maPaintTimer.GetTimeoutHdl().Call( NULL );
}
}
return 0;
}
// -----------------------------------------------------------------------
void Window::ImplInvalidateFrameRegion( const Region* pRegion, sal_uInt16 nFlags )
{
// PAINTCHILDS bei allen Parent-Fenster bis zum ersten OverlapWindow
// setzen
if ( !ImplIsOverlapWindow() )
{
Window* pTempWindow = this;
sal_uInt16 nTranspPaint = IsPaintTransparent() ? IMPL_PAINT_PAINT : 0;
do
{
pTempWindow = pTempWindow->ImplGetParent();
if ( pTempWindow->mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTCHILDS )
break;
pTempWindow->mpWindowImpl->mnPaintFlags |= IMPL_PAINT_PAINTCHILDS | nTranspPaint;
if( ! pTempWindow->IsPaintTransparent() )
nTranspPaint = 0;
}
while ( !pTempWindow->ImplIsOverlapWindow() );
}
// Paint-Flags setzen
mpWindowImpl->mnPaintFlags |= IMPL_PAINT_PAINT;
if ( nFlags & INVALIDATE_CHILDREN )
mpWindowImpl->mnPaintFlags |= IMPL_PAINT_PAINTALLCHILDS;
if ( !(nFlags & INVALIDATE_NOERASE) )
mpWindowImpl->mnPaintFlags |= IMPL_PAINT_ERASE;
if ( !pRegion )
mpWindowImpl->mnPaintFlags |= IMPL_PAINT_PAINTALL;
// Wenn nicht alles neu ausgegeben werden muss, dann die Region
// dazupacken
if ( !(mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALL) )
mpWindowImpl->maInvalidateRegion.Union( *pRegion );
// Handle transparent windows correctly: invalidate must be done on the first opaque parent
if( ((IsPaintTransparent() && !(nFlags & INVALIDATE_NOTRANSPARENT)) || (nFlags & INVALIDATE_TRANSPARENT) )
&& ImplGetParent() )
{
Window *pParent = ImplGetParent();
while( pParent && pParent->IsPaintTransparent() )
pParent = pParent->ImplGetParent();
if( pParent )
{
Region *pChildRegion;
if ( mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALL )
// invalidate the whole child window region in the parent
pChildRegion = ImplGetWinChildClipRegion();
else
// invalidate the same region in the parent that has to be repainted in the child
pChildRegion = &mpWindowImpl->maInvalidateRegion;
nFlags |= INVALIDATE_CHILDREN; // paint should also be done on all children
nFlags &= ~INVALIDATE_NOERASE; // parent should paint and erase to create proper background
pParent->ImplInvalidateFrameRegion( pChildRegion, nFlags );
}
}
ImplPostPaint();
}
// -----------------------------------------------------------------------
void Window::ImplInvalidateOverlapFrameRegion( const Region& rRegion )
{
Region aRegion = rRegion;
ImplClipBoundaries( aRegion, sal_True, sal_True );
if ( !aRegion.IsEmpty() )
ImplInvalidateFrameRegion( &aRegion, INVALIDATE_CHILDREN );
// Dann invalidieren wir die ueberlappenden Fenster
Window* pTempWindow = mpWindowImpl->mpFirstOverlap;
while ( pTempWindow )
{
if ( pTempWindow->IsVisible() )
pTempWindow->ImplInvalidateOverlapFrameRegion( rRegion );
pTempWindow = pTempWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplInvalidateParentFrameRegion( Region& rRegion )
{
if ( mpWindowImpl->mbOverlapWin )
mpWindowImpl->mpFrameWindow->ImplInvalidateOverlapFrameRegion( rRegion );
else
{
if( ImplGetParent() )
ImplGetParent()->ImplInvalidateFrameRegion( &rRegion, INVALIDATE_CHILDREN );
}
}
// -----------------------------------------------------------------------
void Window::ImplInvalidate( const Region* pRegion, sal_uInt16 nFlags )
{
// Hintergrund-Sicherung zuruecksetzen
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
// Feststellen, was neu ausgegeben werden muss
sal_Bool bInvalidateAll = !pRegion;
// Transparent-Invalidate beruecksichtigen
Window* pOpaqueWindow = this;
if ( (mpWindowImpl->mbPaintTransparent && !(nFlags & INVALIDATE_NOTRANSPARENT)) || (nFlags & INVALIDATE_TRANSPARENT) )
{
Window* pTempWindow = pOpaqueWindow->ImplGetParent();
while ( pTempWindow )
{
if ( !pTempWindow->IsPaintTransparent() )
{
pOpaqueWindow = pTempWindow;
nFlags |= INVALIDATE_CHILDREN;
bInvalidateAll = sal_False;
break;
}
if ( pTempWindow->ImplIsOverlapWindow() )
break;
pTempWindow = pTempWindow->ImplGetParent();
}
}
// Region zusammenbauen
sal_uInt16 nOrgFlags = nFlags;
if ( !(nFlags & (INVALIDATE_CHILDREN | INVALIDATE_NOCHILDREN)) )
{
if ( GetStyle() & WB_CLIPCHILDREN )
nFlags |= INVALIDATE_NOCHILDREN;
else
nFlags |= INVALIDATE_CHILDREN;
}
if ( (nFlags & INVALIDATE_NOCHILDREN) && mpWindowImpl->mpFirstChild )
bInvalidateAll = sal_False;
if ( bInvalidateAll )
ImplInvalidateFrameRegion( NULL, nFlags );
else
{
Rectangle aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
Region aRegion( aRect );
if ( pRegion )
{
// --- RTL --- remirror region before intersecting it
if ( ImplIsAntiparallel() )
{
Region aRgn( *pRegion );
ImplReMirror( aRgn );
aRegion.Intersect( aRgn );
}
else
aRegion.Intersect( *pRegion );
}
ImplClipBoundaries( aRegion, sal_True, sal_True );
if ( nFlags & INVALIDATE_NOCHILDREN )
{
nFlags &= ~INVALIDATE_CHILDREN;
if ( !(nFlags & INVALIDATE_NOCLIPCHILDREN) )
{
if ( nOrgFlags & INVALIDATE_NOCHILDREN )
ImplClipAllChilds( aRegion );
else
{
if ( ImplClipChilds( aRegion ) )
nFlags |= INVALIDATE_CHILDREN;
}
}
}
if ( !aRegion.IsEmpty() )
ImplInvalidateFrameRegion( &aRegion, nFlags ); // transparency is handled here, pOpaqueWindow not required
}
if ( nFlags & INVALIDATE_UPDATE )
pOpaqueWindow->Update(); // start painting at the opaque parent
}
// -----------------------------------------------------------------------
void Window::ImplMoveInvalidateRegion( const Rectangle& rRect,
long nHorzScroll, long nVertScroll,
sal_Bool bChilds )
{
if ( (mpWindowImpl->mnPaintFlags & (IMPL_PAINT_PAINT | IMPL_PAINT_PAINTALL)) == IMPL_PAINT_PAINT )
{
Region aTempRegion = mpWindowImpl->maInvalidateRegion;
aTempRegion.Intersect( rRect );
aTempRegion.Move( nHorzScroll, nVertScroll );
mpWindowImpl->maInvalidateRegion.Union( aTempRegion );
}
if ( bChilds && (mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTCHILDS) )
{
Window* pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
pWindow->ImplMoveInvalidateRegion( rRect, nHorzScroll, nVertScroll, sal_True );
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
}
// -----------------------------------------------------------------------
void Window::ImplMoveAllInvalidateRegions( const Rectangle& rRect,
long nHorzScroll, long nVertScroll,
sal_Bool bChilds )
{
// Paint-Region auch verschieben, wenn noch Paints anstehen
ImplMoveInvalidateRegion( rRect, nHorzScroll, nVertScroll, bChilds );
// Paint-Region muss bei uns verschoben gesetzt werden, die durch
// die Parents gezeichnet werden
if ( !ImplIsOverlapWindow() )
{
Region aPaintAllRegion;
Window* pPaintAllWindow = this;
do
{
pPaintAllWindow = pPaintAllWindow->ImplGetParent();
if ( pPaintAllWindow->mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALLCHILDS )
{
if ( pPaintAllWindow->mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALL )
{
aPaintAllRegion.SetEmpty();
break;
}
else
aPaintAllRegion.Union( pPaintAllWindow->mpWindowImpl->maInvalidateRegion );
}
}
while ( !pPaintAllWindow->ImplIsOverlapWindow() );
if ( !aPaintAllRegion.IsEmpty() )
{
aPaintAllRegion.Move( nHorzScroll, nVertScroll );
sal_uInt16 nPaintFlags = 0;
if ( bChilds )
mpWindowImpl->mnPaintFlags |= INVALIDATE_CHILDREN;
ImplInvalidateFrameRegion( &aPaintAllRegion, nPaintFlags );
}
}
}
// -----------------------------------------------------------------------
void Window::ImplValidateFrameRegion( const Region* pRegion, sal_uInt16 nFlags )
{
if ( !pRegion )
mpWindowImpl->maInvalidateRegion.SetEmpty();
else
{
// Wenn alle Childfenster neu ausgegeben werden muessen,
// dann invalidieren wir diese vorher
if ( (mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALLCHILDS) && mpWindowImpl->mpFirstChild )
{
Region aChildRegion = mpWindowImpl->maInvalidateRegion;
if ( mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALL )
{
Rectangle aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
aChildRegion = aRect;
}
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->Invalidate( aChildRegion, INVALIDATE_CHILDREN | INVALIDATE_NOTRANSPARENT );
pChild = pChild->mpWindowImpl->mpNext;
}
}
if ( mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALL )
{
Rectangle aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
mpWindowImpl->maInvalidateRegion = aRect;
}
mpWindowImpl->maInvalidateRegion.Exclude( *pRegion );
}
mpWindowImpl->mnPaintFlags &= ~IMPL_PAINT_PAINTALL;
if ( nFlags & VALIDATE_CHILDREN )
{
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->ImplValidateFrameRegion( pRegion, nFlags );
pChild = pChild->mpWindowImpl->mpNext;
}
}
}
// -----------------------------------------------------------------------
void Window::ImplValidate( const Region* pRegion, sal_uInt16 nFlags )
{
// Region zusammenbauen
sal_Bool bValidateAll = !pRegion;
sal_uInt16 nOrgFlags = nFlags;
if ( !(nFlags & (VALIDATE_CHILDREN | VALIDATE_NOCHILDREN)) )
{
if ( GetStyle() & WB_CLIPCHILDREN )
nFlags |= VALIDATE_NOCHILDREN;
else
nFlags |= VALIDATE_CHILDREN;
}
if ( (nFlags & VALIDATE_NOCHILDREN) && mpWindowImpl->mpFirstChild )
bValidateAll = sal_False;
if ( bValidateAll )
ImplValidateFrameRegion( NULL, nFlags );
else
{
Rectangle aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
Region aRegion( aRect );
if ( pRegion )
aRegion.Intersect( *pRegion );
ImplClipBoundaries( aRegion, sal_True, sal_True );
if ( nFlags & VALIDATE_NOCHILDREN )
{
nFlags &= ~VALIDATE_CHILDREN;
if ( nOrgFlags & VALIDATE_NOCHILDREN )
ImplClipAllChilds( aRegion );
else
{
if ( ImplClipChilds( aRegion ) )
nFlags |= VALIDATE_CHILDREN;
}
}
if ( !aRegion.IsEmpty() )
ImplValidateFrameRegion( &aRegion, nFlags );
}
}
// -----------------------------------------------------------------------
void Window::ImplScroll( const Rectangle& rRect,
long nHorzScroll, long nVertScroll, sal_uInt16 nFlags )
{
if ( !IsDeviceOutputNecessary() )
return;
nHorzScroll = ImplLogicWidthToDevicePixel( nHorzScroll );
nVertScroll = ImplLogicHeightToDevicePixel( nVertScroll );
if ( !nHorzScroll && !nVertScroll )
return;
// Hintergrund-Sicherung zuruecksetzen
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
if ( mpWindowImpl->mpCursor )
mpWindowImpl->mpCursor->ImplHide( false );
sal_uInt16 nOrgFlags = nFlags;
if ( !(nFlags & (SCROLL_CHILDREN | SCROLL_NOCHILDREN)) )
{
if ( GetStyle() & WB_CLIPCHILDREN )
nFlags |= SCROLL_NOCHILDREN;
else
nFlags |= SCROLL_CHILDREN;
}
Region aInvalidateRegion;
sal_Bool bScrollChilds = (nFlags & SCROLL_CHILDREN) != 0;
sal_Bool bErase = (nFlags & SCROLL_NOERASE) == 0;
if ( !mpWindowImpl->mpFirstChild )
bScrollChilds = sal_False;
// --- RTL --- check if this window requires special action
sal_Bool bReMirror = ( ImplIsAntiparallel() );
Rectangle aRectMirror( rRect );
if( bReMirror )
{
// --- RTL --- make sure the invalidate region of this window is
// computed in the same coordinate space as the one from the overlap windows
ImplReMirror( aRectMirror );
}
// Paint-Bereiche anpassen
ImplMoveAllInvalidateRegions( aRectMirror, nHorzScroll, nVertScroll, bScrollChilds );
if ( !(nFlags & SCROLL_NOINVALIDATE) )
{
ImplCalcOverlapRegion( aRectMirror, aInvalidateRegion, !bScrollChilds, sal_True, sal_False );
// --- RTL ---
// if the scrolling on the device is performed in the opposite direction
// then move the overlaps in that direction to compute the invalidate region
// on the correct side, i.e., revert nHorzScroll
if ( !aInvalidateRegion.IsEmpty() )
{
aInvalidateRegion.Move( bReMirror ? -nHorzScroll : nHorzScroll, nVertScroll );
bErase = sal_True;
}
if ( !(nFlags & SCROLL_NOWINDOWINVALIDATE) )
{
Rectangle aDestRect( aRectMirror );
aDestRect.Move( bReMirror ? -nHorzScroll : nHorzScroll, nVertScroll );
Region aWinInvalidateRegion( aRectMirror );
aWinInvalidateRegion.Exclude( aDestRect );
aInvalidateRegion.Union( aWinInvalidateRegion );
}
}
Point aPoint( mnOutOffX, mnOutOffY );
Region aRegion( Rectangle( aPoint, Size( mnOutWidth, mnOutHeight ) ) );
if ( nFlags & SCROLL_CLIP )
aRegion.Intersect( rRect );
if ( mpWindowImpl->mbWinRegion )
aRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
aRegion.Exclude( aInvalidateRegion );
ImplClipBoundaries( aRegion, sal_False, sal_True );
if ( !bScrollChilds )
{
if ( nOrgFlags & SCROLL_NOCHILDREN )
ImplClipAllChilds( aRegion );
else
ImplClipChilds( aRegion );
}
if ( mbClipRegion && (nFlags & SCROLL_USECLIPREGION) )
aRegion.Intersect( maRegion );
if ( !aRegion.IsEmpty() )
{
if ( mpWindowImpl->mpWinData )
{
if ( mpWindowImpl->mbFocusVisible )
ImplInvertFocus( *(mpWindowImpl->mpWinData->mpFocusRect) );
if ( mpWindowImpl->mbTrackVisible && (mpWindowImpl->mpWinData->mnTrackFlags & SHOWTRACK_WINDOW) )
InvertTracking( *(mpWindowImpl->mpWinData->mpTrackRect), mpWindowImpl->mpWinData->mnTrackFlags );
}
SalGraphics* pGraphics = ImplGetFrameGraphics();
if ( pGraphics )
{
if( bReMirror )
{
// --- RTL --- frame coordinates require re-mirroring
ImplReMirror( aRegion );
}
ImplSelectClipRegion( aRegion, pGraphics );
pGraphics->CopyArea( rRect.Left()+nHorzScroll, rRect.Top()+nVertScroll,
rRect.Left(), rRect.Top(),
rRect.GetWidth(), rRect.GetHeight(),
SAL_COPYAREA_WINDOWINVALIDATE, this );
}
if ( mpWindowImpl->mpWinData )
{
if ( mpWindowImpl->mbFocusVisible )
ImplInvertFocus( *(mpWindowImpl->mpWinData->mpFocusRect) );
if ( mpWindowImpl->mbTrackVisible && (mpWindowImpl->mpWinData->mnTrackFlags & SHOWTRACK_WINDOW) )
InvertTracking( *(mpWindowImpl->mpWinData->mpTrackRect), mpWindowImpl->mpWinData->mnTrackFlags );
}
}
if ( !aInvalidateRegion.IsEmpty() )
{
// --- RTL --- the invalidate region for this windows is already computed in frame coordinates
// so it has to be re-mirrored before calling the Paint-handler
mpWindowImpl->mnPaintFlags |= IMPL_PAINT_CHECKRTL;
sal_uInt16 nPaintFlags = INVALIDATE_CHILDREN;
if ( !bErase )
nPaintFlags |= INVALIDATE_NOERASE;
if ( !bScrollChilds )
{
if ( nOrgFlags & SCROLL_NOCHILDREN )
ImplClipAllChilds( aInvalidateRegion );
else
ImplClipChilds( aInvalidateRegion );
}
ImplInvalidateFrameRegion( &aInvalidateRegion, nPaintFlags );
}
if ( bScrollChilds )
{
Window* pWindow = mpWindowImpl->mpFirstChild;
while ( pWindow )
{
Point aPos = pWindow->GetPosPixel();
aPos += Point( nHorzScroll, nVertScroll );
pWindow->SetPosPixel( aPos );
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
if ( nFlags & SCROLL_UPDATE )
Update();
if ( mpWindowImpl->mpCursor )
mpWindowImpl->mpCursor->ImplShow( false );
}
// -----------------------------------------------------------------------
void Window::ImplUpdateAll( sal_Bool bOverlapWindows )
{
if ( !mpWindowImpl->mbReallyVisible )
return;
sal_Bool bFlush = sal_False;
if ( mpWindowImpl->mpFrameWindow->mpWindowImpl->mbPaintFrame )
{
Point aPoint( 0, 0 );
Region aRegion( Rectangle( aPoint, Size( mnOutWidth, mnOutHeight ) ) );
ImplInvalidateOverlapFrameRegion( aRegion );
if ( mpWindowImpl->mbFrame || (mpWindowImpl->mpBorderWindow && mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame) )
bFlush = sal_True;
}
// Ein Update wirkt immer auf das OverlapWindow, damit bei spaeteren
// Paints nicht zuviel gemalt wird, wenn dort ALLCHILDREN usw. gesetzt
// ist
Window* pWindow = ImplGetFirstOverlapWindow();
if ( bOverlapWindows )
pWindow->ImplCallOverlapPaint();
else
{
if ( pWindow->mpWindowImpl->mnPaintFlags & (IMPL_PAINT_PAINT | IMPL_PAINT_PAINTCHILDS) )
pWindow->ImplCallPaint( NULL, pWindow->mpWindowImpl->mnPaintFlags );
}
if ( bFlush )
Flush();
}
// -----------------------------------------------------------------------
void Window::ImplUpdateWindowPtr( Window* pWindow )
{
if ( mpWindowImpl->mpFrameWindow != pWindow->mpWindowImpl->mpFrameWindow )
{
// Graphic freigeben
ImplReleaseGraphics();
}
mpWindowImpl->mpFrameData = pWindow->mpWindowImpl->mpFrameData;
mpWindowImpl->mpFrame = pWindow->mpWindowImpl->mpFrame;
mpWindowImpl->mpFrameWindow = pWindow->mpWindowImpl->mpFrameWindow;
if ( pWindow->ImplIsOverlapWindow() )
mpWindowImpl->mpOverlapWindow = pWindow;
else
mpWindowImpl->mpOverlapWindow = pWindow->mpWindowImpl->mpOverlapWindow;
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->ImplUpdateWindowPtr( pWindow );
pChild = pChild->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplUpdateWindowPtr()
{
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->ImplUpdateWindowPtr( this );
pChild = pChild->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplUpdateOverlapWindowPtr( sal_Bool bNewFrame )
{
sal_Bool bVisible = IsVisible();
Show( sal_False );
ImplRemoveWindow( bNewFrame );
Window* pRealParent = mpWindowImpl->mpRealParent;
ImplInsertWindow( ImplGetParent() );
mpWindowImpl->mpRealParent = pRealParent;
ImplUpdateWindowPtr();
if ( ImplUpdatePos() )
ImplUpdateSysObjPos();
if ( bNewFrame )
{
Window* pOverlapWindow = mpWindowImpl->mpFirstOverlap;
while ( pOverlapWindow )
{
Window* pNextOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
pOverlapWindow->ImplUpdateOverlapWindowPtr( bNewFrame );
pOverlapWindow = pNextOverlapWindow;
}
}
if ( bVisible )
Show( sal_True );
}
// -----------------------------------------------------------------------
sal_Bool Window::ImplUpdatePos()
{
sal_Bool bSysChild = sal_False;
if ( ImplIsOverlapWindow() )
{
mnOutOffX = mpWindowImpl->mnX;
mnOutOffY = mpWindowImpl->mnY;
}
else
{
Window* pParent = ImplGetParent();
mnOutOffX = mpWindowImpl->mnX + pParent->mnOutOffX;
mnOutOffY = mpWindowImpl->mnY + pParent->mnOutOffY;
}
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
if ( pChild->ImplUpdatePos() )
bSysChild = sal_True;
pChild = pChild->mpWindowImpl->mpNext;
}
if ( mpWindowImpl->mpSysObj )
bSysChild = sal_True;
return bSysChild;
}
// -----------------------------------------------------------------------
void Window::ImplUpdateSysObjPos()
{
if ( mpWindowImpl->mpSysObj )
mpWindowImpl->mpSysObj->SetPosSize( mnOutOffX, mnOutOffY, mnOutWidth, mnOutHeight );
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->ImplUpdateSysObjPos();
pChild = pChild->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplPosSizeWindow( long nX, long nY,
long nWidth, long nHeight, sal_uInt16 nFlags )
{
sal_Bool bNewPos = sal_False;
sal_Bool bNewSize = sal_False;
sal_Bool bNewWidth = sal_False;
sal_Bool bCopyBits = sal_False;
long nOldOutOffX = mnOutOffX;
long nOldOutOffY = mnOutOffY;
long nOldOutWidth = mnOutWidth;
long nOldOutHeight = mnOutHeight;
Region* pOverlapRegion = NULL;
Region* pOldRegion = NULL;
if ( IsReallyVisible() )
{
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
Rectangle aOldWinRect( Point( nOldOutOffX, nOldOutOffY ),
Size( nOldOutWidth, nOldOutHeight ) );
pOldRegion = new Region( aOldWinRect );
if ( mpWindowImpl->mbWinRegion )
pOldRegion->Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
if ( mnOutWidth && mnOutHeight && !mpWindowImpl->mbPaintTransparent &&
!mpWindowImpl->mbInitWinClipRegion && !mpWindowImpl->maWinClipRegion.IsEmpty() &&
!HasPaintEvent() )
bCopyBits = sal_True;
}
sal_Bool bnXRecycled = sal_False; // avoid duplicate mirroring in RTL case
if ( nFlags & WINDOW_POSSIZE_WIDTH )
{
if(!( nFlags & WINDOW_POSSIZE_X ))
{
nX = mpWindowImpl->mnX;
nFlags |= WINDOW_POSSIZE_X;
bnXRecycled = sal_True; // we're using a mnX which was already mirrored in RTL case
}
if ( nWidth < 0 )
nWidth = 0;
if ( nWidth != mnOutWidth )
{
mnOutWidth = nWidth;
bNewSize = sal_True;
bCopyBits = sal_False;
bNewWidth = sal_True;
}
}
if ( nFlags & WINDOW_POSSIZE_HEIGHT )
{
if ( nHeight < 0 )
nHeight = 0;
if ( nHeight != mnOutHeight )
{
mnOutHeight = nHeight;
bNewSize = sal_True;
bCopyBits = sal_False;
}
}
if ( nFlags & WINDOW_POSSIZE_X )
{
long nOrgX = nX;
// --- RTL --- (compare the screen coordinates)
Point aPtDev( Point( nX+mnOutOffX, 0 ) );
if( ImplHasMirroredGraphics() )
{
mpGraphics->mirror( aPtDev.X(), this );
// #106948# always mirror our pos if our parent is not mirroring, even
// if we are also not mirroring
// --- RTL --- check if parent is in different coordinates
if( !bnXRecycled && mpWindowImpl->mpParent && !mpWindowImpl->mpParent->mpWindowImpl->mbFrame && mpWindowImpl->mpParent->ImplIsAntiparallel() )
{
// --- RTL --- (re-mirror at parent window)
nX = mpWindowImpl->mpParent->mnOutWidth - mnOutWidth - nX;
}
/* #i99166# An LTR window in RTL UI that gets sized only would be
expected to not moved its upper left point
*/
if( bnXRecycled )
{
if( ImplIsAntiparallel() )
{
aPtDev.X() = mpWindowImpl->mnAbsScreenX;
nOrgX = mpWindowImpl->maPos.X();
}
}
}
else if( !bnXRecycled && mpWindowImpl->mpParent && !mpWindowImpl->mpParent->mpWindowImpl->mbFrame && mpWindowImpl->mpParent->ImplIsAntiparallel() )
{
// mirrored window in LTR UI
{
// --- RTL --- (re-mirror at parent window)
nX = mpWindowImpl->mpParent->mnOutWidth - mnOutWidth - nX;
}
}
// check maPos as well, as it could have been changed for client windows (ImplCallMove())
if ( mpWindowImpl->mnAbsScreenX != aPtDev.X() || nX != mpWindowImpl->mnX || nOrgX != mpWindowImpl->maPos.X() )
{
if ( bCopyBits && !pOverlapRegion )
{
pOverlapRegion = new Region();
ImplCalcOverlapRegion( Rectangle( Point( mnOutOffX, mnOutOffY ),
Size( mnOutWidth, mnOutHeight ) ),
*pOverlapRegion, sal_False, sal_True, sal_True );
}
mpWindowImpl->mnX = nX;
mpWindowImpl->maPos.X() = nOrgX;
mpWindowImpl->mnAbsScreenX = aPtDev.X(); // --- RTL --- (store real screen pos)
bNewPos = sal_True;
}
}
if ( nFlags & WINDOW_POSSIZE_Y )
{
// check maPos as well, as it could have been changed for client windows (ImplCallMove())
if ( nY != mpWindowImpl->mnY || nY != mpWindowImpl->maPos.Y() )
{
if ( bCopyBits && !pOverlapRegion )
{
pOverlapRegion = new Region();
ImplCalcOverlapRegion( Rectangle( Point( mnOutOffX, mnOutOffY ),
Size( mnOutWidth, mnOutHeight ) ),
*pOverlapRegion, sal_False, sal_True, sal_True );
}
mpWindowImpl->mnY = nY;
mpWindowImpl->maPos.Y() = nY;
bNewPos = sal_True;
}
}
/* if ( nFlags & (WINDOW_POSSIZE_X|WINDOW_POSSIZE_Y) )
{
POINT aPt;
aPt.x = mpWindowImpl->maPos.X();
aPt.y = mpWindowImpl->maPos.Y();
ClientToScreen( mpWindowImpl->mpFrame->maFrameData.mhWnd , &aPt );
mpWindowImpl->maPos.X() = aPt.x;
mpWindowImpl->maPos.Y() = aPt.y;
}
*/
if ( bNewPos || bNewSize )
{
sal_Bool bUpdateSysObjPos = sal_False;
if ( bNewPos )
bUpdateSysObjPos = ImplUpdatePos();
// the borderwindow always specifies the position for its client window
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->maPos = mpWindowImpl->mpBorderWindow->mpWindowImpl->maPos;
if ( mpWindowImpl->mpClientWindow )
{
mpWindowImpl->mpClientWindow->ImplPosSizeWindow( mpWindowImpl->mpClientWindow->mpWindowImpl->mnLeftBorder,
mpWindowImpl->mpClientWindow->mpWindowImpl->mnTopBorder,
mnOutWidth-mpWindowImpl->mpClientWindow->mpWindowImpl->mnLeftBorder-mpWindowImpl->mpClientWindow->mpWindowImpl->mnRightBorder,
mnOutHeight-mpWindowImpl->mpClientWindow->mpWindowImpl->mnTopBorder-mpWindowImpl->mpClientWindow->mpWindowImpl->mnBottomBorder,
WINDOW_POSSIZE_X | WINDOW_POSSIZE_Y |
WINDOW_POSSIZE_WIDTH | WINDOW_POSSIZE_HEIGHT );
// Wenn wir ein ClientWindow haben, dann hat dieses fuer die
// Applikation auch die Position des FloatingWindows
mpWindowImpl->mpClientWindow->mpWindowImpl->maPos = mpWindowImpl->maPos;
if ( bNewPos )
{
if ( mpWindowImpl->mpClientWindow->IsVisible() )
{
mpWindowImpl->mpClientWindow->ImplCallMove();
}
else
{
mpWindowImpl->mpClientWindow->mpWindowImpl->mbCallMove = sal_True;
}
}
}
// else
// {
// if ( mpWindowImpl->mpBorderWindow )
// mpWindowImpl->maPos = mpWindowImpl->mpBorderWindow->mpWindowImpl->maPos;
// }
// Move()/Resize() werden erst bei Show() gerufen, damit min. eins vor
// einem Show() kommt
if ( IsVisible() )
{
if ( bNewPos )
{
ImplCallMove();
}
if ( bNewSize )
{
ImplCallResize();
}
}
else
{
if ( bNewPos )
mpWindowImpl->mbCallMove = sal_True;
if ( bNewSize )
mpWindowImpl->mbCallResize = sal_True;
}
sal_Bool bUpdateSysObjClip = sal_False;
if ( IsReallyVisible() )
{
if ( bNewPos || bNewSize )
{
// Hintergrund-Sicherung zuruecksetzen
if ( mpWindowImpl->mpOverlapData && mpWindowImpl->mpOverlapData->mpSaveBackDev )
ImplDeleteOverlapBackground();
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
// Clip-Flag neu setzen
bUpdateSysObjClip = !ImplSetClipFlag( sal_True );
}
// Fensterinhalt invalidieren ?
if ( bNewPos || (mnOutWidth > nOldOutWidth) || (mnOutHeight > nOldOutHeight) )
{
if ( bNewPos )
{
sal_Bool bInvalidate = sal_False;
sal_Bool bParentPaint = sal_True;
if ( !ImplIsOverlapWindow() )
bParentPaint = mpWindowImpl->mpParent->IsPaintEnabled();
if ( bCopyBits && bParentPaint && !HasPaintEvent() )
{
Point aPoint( mnOutOffX, mnOutOffY );
Region aRegion( Rectangle( aPoint,
Size( mnOutWidth, mnOutHeight ) ) );
if ( mpWindowImpl->mbWinRegion )
aRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
ImplClipBoundaries( aRegion, sal_False, sal_True );
if ( !pOverlapRegion->IsEmpty() )
{
pOverlapRegion->Move( mnOutOffX-nOldOutOffX, mnOutOffY-nOldOutOffY );
aRegion.Exclude( *pOverlapRegion );
}
if ( !aRegion.IsEmpty() )
{
// Paint-Bereiche anpassen
ImplMoveAllInvalidateRegions( Rectangle( Point( nOldOutOffX, nOldOutOffY ),
Size( nOldOutWidth, nOldOutHeight ) ),
mnOutOffX-nOldOutOffX, mnOutOffY-nOldOutOffY,
sal_True );
SalGraphics* pGraphics = ImplGetFrameGraphics();
if ( pGraphics )
{
const bool bSelectClipRegion = ImplSelectClipRegion( aRegion, pGraphics );
if ( bSelectClipRegion )
{
pGraphics->CopyArea( mnOutOffX, mnOutOffY,
nOldOutOffX, nOldOutOffY,
nOldOutWidth, nOldOutHeight,
SAL_COPYAREA_WINDOWINVALIDATE, this );
}
else
bInvalidate = sal_True;
}
else
bInvalidate = sal_True;
if ( !bInvalidate )
{
if ( !pOverlapRegion->IsEmpty() )
ImplInvalidateFrameRegion( pOverlapRegion, INVALIDATE_CHILDREN );
}
}
else
bInvalidate = sal_True;
}
else
bInvalidate = sal_True;
if ( bInvalidate )
ImplInvalidateFrameRegion( NULL, INVALIDATE_CHILDREN );
}
else
{
Point aPoint( mnOutOffX, mnOutOffY );
Region aRegion( Rectangle( aPoint,
Size( mnOutWidth, mnOutHeight ) ) );
aRegion.Exclude( *pOldRegion );
if ( mpWindowImpl->mbWinRegion )
aRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
ImplClipBoundaries( aRegion, sal_False, sal_True );
if ( !aRegion.IsEmpty() )
ImplInvalidateFrameRegion( &aRegion, INVALIDATE_CHILDREN );
}
}
// Parent oder Overlaps invalidieren
if ( bNewPos ||
(mnOutWidth < nOldOutWidth) || (mnOutHeight < nOldOutHeight) )
{
Region aRegion( *pOldRegion );
if ( !mpWindowImpl->mbPaintTransparent )
ImplExcludeWindowRegion( aRegion );
ImplClipBoundaries( aRegion, sal_False, sal_True );
if ( !aRegion.IsEmpty() && !mpWindowImpl->mpBorderWindow )
ImplInvalidateParentFrameRegion( aRegion );
}
}
// System-Objekte anpassen
if ( bUpdateSysObjClip )
ImplUpdateSysObjClip();
if ( bUpdateSysObjPos )
ImplUpdateSysObjPos();
if ( bNewSize && mpWindowImpl->mpSysObj )
mpWindowImpl->mpSysObj->SetPosSize( mnOutOffX, mnOutOffY, mnOutWidth, mnOutHeight );
}
if ( pOverlapRegion )
delete pOverlapRegion;
if ( pOldRegion )
delete pOldRegion;
}
// -----------------------------------------------------------------------
void Window::ImplToBottomChild()
{
if ( !ImplIsOverlapWindow() && !mpWindowImpl->mbReallyVisible && (mpWindowImpl->mpParent->mpWindowImpl->mpLastChild != this) )
{
// Fenster an das Ende der Liste setzen
if ( mpWindowImpl->mpPrev )
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
else
mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = mpWindowImpl->mpNext;
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
mpWindowImpl->mpPrev = mpWindowImpl->mpParent->mpWindowImpl->mpLastChild;
mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = this;
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
mpWindowImpl->mpNext = NULL;
}
}
// -----------------------------------------------------------------------
void Window::ImplCalcToTop( ImplCalcToTopData* pPrevData )
{
DBG_ASSERT( ImplIsOverlapWindow(), "Window::ImplCalcToTop(): Is not a OverlapWindow" );
if ( !mpWindowImpl->mbFrame )
{
if ( IsReallyVisible() )
{
// Region berechnen, wo das Fenster mit anderen Fenstern ueberlappt
Point aPoint( mnOutOffX, mnOutOffY );
Region aRegion( Rectangle( aPoint,
Size( mnOutWidth, mnOutHeight ) ) );
Region aInvalidateRegion;
ImplCalcOverlapRegionOverlaps( aRegion, aInvalidateRegion );
if ( !aInvalidateRegion.IsEmpty() )
{
ImplCalcToTopData* pData = new ImplCalcToTopData;
pPrevData->mpNext = pData;
pData->mpNext = NULL;
pData->mpWindow = this;
pData->mpInvalidateRegion = new Region( aInvalidateRegion );
}
}
}
}
// -----------------------------------------------------------------------
void Window::ImplCalcChildOverlapToTop( ImplCalcToTopData* pPrevData )
{
DBG_ASSERT( ImplIsOverlapWindow(), "Window::ImplCalcChildOverlapToTop(): Is not a OverlapWindow" );
ImplCalcToTop( pPrevData );
if ( pPrevData->mpNext )
pPrevData = pPrevData->mpNext;
Window* pOverlap = mpWindowImpl->mpFirstOverlap;
while ( pOverlap )
{
pOverlap->ImplCalcToTop( pPrevData );
if ( pPrevData->mpNext )
pPrevData = pPrevData->mpNext;
pOverlap = pOverlap->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplToTop( sal_uInt16 nFlags )
{
DBG_ASSERT( ImplIsOverlapWindow(), "Window::ImplToTop(): Is not a OverlapWindow" );
if ( mpWindowImpl->mbFrame )
{
// Wenn in das externe Fenster geklickt wird, ist dieses
// dafuer zustaendig dafuer zu sorgen, das unser Frame
// nach vorne kommt
if ( !mpWindowImpl->mpFrameData->mbHasFocus &&
!mpWindowImpl->mpFrameData->mbSysObjFocus &&
!mpWindowImpl->mpFrameData->mbInSysObjFocusHdl &&
!mpWindowImpl->mpFrameData->mbInSysObjToTopHdl )
{
// do not bring floating windows on the client to top
if( !ImplGetClientWindow() || !(ImplGetClientWindow()->GetStyle() & WB_SYSTEMFLOATWIN) )
{
sal_uInt16 nSysFlags = 0;
if ( nFlags & TOTOP_RESTOREWHENMIN )
nSysFlags |= SAL_FRAME_TOTOP_RESTOREWHENMIN;
if ( nFlags & TOTOP_FOREGROUNDTASK )
nSysFlags |= SAL_FRAME_TOTOP_FOREGROUNDTASK;
if ( nFlags & TOTOP_GRABFOCUSONLY )
nSysFlags |= SAL_FRAME_TOTOP_GRABFOCUS_ONLY;
mpWindowImpl->mpFrame->ToTop( nSysFlags );
}
}
}
else
{
if ( mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap != this )
{
// Fenster aus der Liste entfernen
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
if ( mpWindowImpl->mpNext )
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
else
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = mpWindowImpl->mpPrev;
// AlwaysOnTop beruecksichtigen
sal_Bool bOnTop = IsAlwaysOnTopEnabled();
Window* pNextWin = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
if ( !bOnTop )
{
while ( pNextWin )
{
if ( !pNextWin->IsAlwaysOnTopEnabled() )
break;
pNextWin = pNextWin->mpWindowImpl->mpNext;
}
}
// TopLevel abpruefen
sal_uInt8 nTopLevel = mpWindowImpl->mpOverlapData->mnTopLevel;
while ( pNextWin )
{
if ( (bOnTop != pNextWin->IsAlwaysOnTopEnabled()) ||
(nTopLevel <= pNextWin->mpWindowImpl->mpOverlapData->mnTopLevel) )
break;
pNextWin = pNextWin->mpWindowImpl->mpNext;
}
// Fenster in die Liste wieder eintragen
mpWindowImpl->mpNext = pNextWin;
if ( pNextWin )
{
mpWindowImpl->mpPrev = pNextWin->mpWindowImpl->mpPrev;
pNextWin->mpWindowImpl->mpPrev = this;
}
else
{
mpWindowImpl->mpPrev = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap;
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = this;
}
if ( mpWindowImpl->mpPrev )
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
else
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = this;
// ClipRegion muss von diesem Fenster und allen weiteren
// ueberlappenden Fenstern neu berechnet werden.
if ( IsReallyVisible() )
{
// Hintergrund-Sicherung zuruecksetzen
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
mpWindowImpl->mpOverlapWindow->ImplSetClipFlagOverlapWindows();
}
}
}
}
// -----------------------------------------------------------------------
void Window::ImplStartToTop( sal_uInt16 nFlags )
{
ImplCalcToTopData aStartData;
ImplCalcToTopData* pCurData;
ImplCalcToTopData* pNextData;
Window* pOverlapWindow;
if ( ImplIsOverlapWindow() )
pOverlapWindow = this;
else
pOverlapWindow = mpWindowImpl->mpOverlapWindow;
// Zuerst die Paint-Bereiche berechnen
Window* pTempOverlapWindow = pOverlapWindow;
aStartData.mpNext = NULL;
pCurData = &aStartData;
do
{
pTempOverlapWindow->ImplCalcToTop( pCurData );
if ( pCurData->mpNext )
pCurData = pCurData->mpNext;
pTempOverlapWindow = pTempOverlapWindow->mpWindowImpl->mpOverlapWindow;
}
while ( !pTempOverlapWindow->mpWindowImpl->mbFrame );
// Dann die Paint-Bereiche der ChildOverlap-Windows berechnen
pTempOverlapWindow = mpWindowImpl->mpFirstOverlap;
while ( pTempOverlapWindow )
{
pTempOverlapWindow->ImplCalcToTop( pCurData );
if ( pCurData->mpNext )
pCurData = pCurData->mpNext;
pTempOverlapWindow = pTempOverlapWindow->mpWindowImpl->mpNext;
}
// Dann die Fenster-Verkettung aendern
pTempOverlapWindow = pOverlapWindow;
do
{
pTempOverlapWindow->ImplToTop( nFlags );
pTempOverlapWindow = pTempOverlapWindow->mpWindowImpl->mpOverlapWindow;
}
while ( !pTempOverlapWindow->mpWindowImpl->mbFrame );
// Und zum Schluss invalidieren wir die ungueltigen Bereiche
pCurData = aStartData.mpNext;
while ( pCurData )
{
pCurData->mpWindow->ImplInvalidateFrameRegion( pCurData->mpInvalidateRegion, INVALIDATE_CHILDREN );
pNextData = pCurData->mpNext;
delete pCurData->mpInvalidateRegion;
delete pCurData;
pCurData = pNextData;
}
}
// -----------------------------------------------------------------------
void Window::ImplFocusToTop( sal_uInt16 nFlags, sal_Bool bReallyVisible )
{
// Soll Focus auch geholt werden?
if ( !(nFlags & TOTOP_NOGRABFOCUS) )
{
// Erstes Fenster mit GrabFocus-Activate bekommt den Focus
Window* pFocusWindow = this;
while ( !pFocusWindow->ImplIsOverlapWindow() )
{
// Nur wenn Fenster kein Border-Fenster hat, da wir
// immer das dazugehoerende BorderFenster finden wollen
if ( !pFocusWindow->mpWindowImpl->mpBorderWindow )
{
if ( pFocusWindow->mpWindowImpl->mnActivateMode & ACTIVATE_MODE_GRABFOCUS )
break;
}
pFocusWindow = pFocusWindow->ImplGetParent();
}
if ( (pFocusWindow->mpWindowImpl->mnActivateMode & ACTIVATE_MODE_GRABFOCUS) &&
!pFocusWindow->HasChildPathFocus( sal_True ) )
pFocusWindow->GrabFocus();
}
if ( bReallyVisible )
ImplGenerateMouseMove();
}
// -----------------------------------------------------------------------
void Window::ImplShowAllOverlaps()
{
Window* pOverlapWindow = mpWindowImpl->mpFirstOverlap;
while ( pOverlapWindow )
{
if ( pOverlapWindow->mpWindowImpl->mbOverlapVisible )
{
pOverlapWindow->Show( sal_True, SHOW_NOACTIVATE );
pOverlapWindow->mpWindowImpl->mbOverlapVisible = sal_False;
}
pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplHideAllOverlaps()
{
Window* pOverlapWindow = mpWindowImpl->mpFirstOverlap;
while ( pOverlapWindow )
{
if ( pOverlapWindow->IsVisible() )
{
pOverlapWindow->mpWindowImpl->mbOverlapVisible = sal_True;
pOverlapWindow->Show( sal_False );
}
pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::ImplCallMouseMove( sal_uInt16 nMouseCode, sal_Bool bModChanged )
{
if ( mpWindowImpl->mpFrameData->mbMouseIn && mpWindowImpl->mpFrameWindow->mpWindowImpl->mbReallyVisible )
{
sal_uLong nTime = Time::GetSystemTicks();
long nX = mpWindowImpl->mpFrameData->mnLastMouseX;
long nY = mpWindowImpl->mpFrameData->mnLastMouseY;
sal_uInt16 nCode = nMouseCode;
sal_uInt16 nMode = mpWindowImpl->mpFrameData->mnMouseMode;
sal_Bool bLeave;
// Auf MouseLeave testen
if ( ((nX < 0) || (nY < 0) ||
(nX >= mpWindowImpl->mpFrameWindow->mnOutWidth) ||
(nY >= mpWindowImpl->mpFrameWindow->mnOutHeight)) &&
!ImplGetSVData()->maWinData.mpCaptureWin )
bLeave = sal_True;
else
bLeave = sal_False;
nMode |= MOUSE_SYNTHETIC;
if ( bModChanged )
nMode |= MOUSE_MODIFIERCHANGED;
ImplHandleMouseEvent( mpWindowImpl->mpFrameWindow, EVENT_MOUSEMOVE, bLeave, nX, nY, nTime, nCode, nMode );
}
}
// -----------------------------------------------------------------------
void Window::ImplGenerateMouseMove()
{
if ( !mpWindowImpl->mpFrameData->mnMouseMoveId )
Application::PostUserEvent( mpWindowImpl->mpFrameData->mnMouseMoveId, LINK( mpWindowImpl->mpFrameWindow, Window, ImplGenerateMouseMoveHdl ) );
}
// -----------------------------------------------------------------------
IMPL_LINK( Window, ImplGenerateMouseMoveHdl, void*, EMPTYARG )
{
mpWindowImpl->mpFrameData->mnMouseMoveId = 0;
Window* pCaptureWin = ImplGetSVData()->maWinData.mpCaptureWin;
if( ! pCaptureWin ||
(pCaptureWin->mpWindowImpl && pCaptureWin->mpWindowImpl->mpFrame == mpWindowImpl->mpFrame)
)
{
ImplCallMouseMove( mpWindowImpl->mpFrameData->mnMouseCode );
}
return 0;
}
// -----------------------------------------------------------------------
void Window::ImplInvertFocus( const Rectangle& rRect )
{
InvertTracking( rRect, SHOWTRACK_SMALL | SHOWTRACK_WINDOW );
}
// -----------------------------------------------------------------------
void Window::ImplCallFocusChangeActivate( Window* pNewOverlapWindow,
Window* pOldOverlapWindow )
{
ImplSVData* pSVData = ImplGetSVData();
Window* pNewRealWindow;
Window* pOldRealWindow;
Window* pLastRealWindow;
sal_Bool bCallActivate = sal_True;
sal_Bool bCallDeactivate = sal_True;
pOldRealWindow = pOldOverlapWindow->ImplGetWindow();
pNewRealWindow = pNewOverlapWindow->ImplGetWindow();
if ( (pOldRealWindow->GetType() != WINDOW_FLOATINGWINDOW) ||
pOldRealWindow->GetActivateMode() )
{
if ( (pNewRealWindow->GetType() == WINDOW_FLOATINGWINDOW) &&
!pNewRealWindow->GetActivateMode() )
{
pSVData->maWinData.mpLastDeacWin = pOldOverlapWindow;
bCallDeactivate = sal_False;
}
}
else if ( (pNewRealWindow->GetType() != WINDOW_FLOATINGWINDOW) ||
pNewRealWindow->GetActivateMode() )
{
if ( pSVData->maWinData.mpLastDeacWin )
{
if ( pSVData->maWinData.mpLastDeacWin == pNewOverlapWindow )
bCallActivate = sal_False;
else
{
pLastRealWindow = pSVData->maWinData.mpLastDeacWin->ImplGetWindow();
pSVData->maWinData.mpLastDeacWin->mpWindowImpl->mbActive = sal_False;
pSVData->maWinData.mpLastDeacWin->Deactivate();
if ( pLastRealWindow != pSVData->maWinData.mpLastDeacWin )
{
pLastRealWindow->mpWindowImpl->mbActive = sal_True;
pLastRealWindow->Activate();
}
}
pSVData->maWinData.mpLastDeacWin = NULL;
}
}
if ( bCallDeactivate )
{
if( pOldOverlapWindow->mpWindowImpl->mbActive )
{
pOldOverlapWindow->mpWindowImpl->mbActive = sal_False;
pOldOverlapWindow->Deactivate();
}
if ( pOldRealWindow != pOldOverlapWindow )
{
if( pOldRealWindow->mpWindowImpl->mbActive )
{
pOldRealWindow->mpWindowImpl->mbActive = sal_False;
pOldRealWindow->Deactivate();
}
}
}
if ( bCallActivate && ! pNewOverlapWindow->mpWindowImpl->mbActive )
{
if( ! pNewOverlapWindow->mpWindowImpl->mbActive )
{
pNewOverlapWindow->mpWindowImpl->mbActive = sal_True;
pNewOverlapWindow->Activate();
}
if ( pNewRealWindow != pNewOverlapWindow )
{
if( ! pNewRealWindow->mpWindowImpl->mbActive )
{
pNewRealWindow->mpWindowImpl->mbActive = sal_True;
pNewRealWindow->Activate();
}
}
}
}
static bool IsWindowFocused(const WindowImpl& rWinImpl)
{
if (rWinImpl.mpSysObj)
return true;
if (rWinImpl.mpFrameData->mbHasFocus)
return true;
if (rWinImpl.mbFakeFocusSet)
return true;
return false;
}
// -----------------------------------------------------------------------
void Window::ImplGrabFocus( sal_uInt16 nFlags )
{
// #143570# no focus for destructing windows
if( mpWindowImpl->mbInDtor )
return;
// some event listeners do really bad stuff
// => prepare for the worst
ImplDelData aDogTag( this );
// Currently the client window should always get the focus
// Should the border window at some point be focusable
// we need to change all GrabFocus() instances in VCL,
// e.g. in ToTop()
if ( mpWindowImpl->mpClientWindow )
{
// For a lack of design we need a little hack here to
// ensure that dialogs on close pass the focus back to
// the correct window
if ( mpWindowImpl->mpLastFocusWindow && (mpWindowImpl->mpLastFocusWindow != this) &&
!(mpWindowImpl->mnDlgCtrlFlags & WINDOW_DLGCTRL_WANTFOCUS) &&
mpWindowImpl->mpLastFocusWindow->IsEnabled() &&
mpWindowImpl->mpLastFocusWindow->IsInputEnabled() &&
! mpWindowImpl->mpLastFocusWindow->IsInModalMode()
)
mpWindowImpl->mpLastFocusWindow->GrabFocus();
else
mpWindowImpl->mpClientWindow->GrabFocus();
return;
}
else if ( mpWindowImpl->mbFrame )
{
// For a lack of design we need a little hack here to
// ensure that dialogs on close pass the focus back to
// the correct window
if ( mpWindowImpl->mpLastFocusWindow && (mpWindowImpl->mpLastFocusWindow != this) &&
!(mpWindowImpl->mnDlgCtrlFlags & WINDOW_DLGCTRL_WANTFOCUS) &&
mpWindowImpl->mpLastFocusWindow->IsEnabled() &&
mpWindowImpl->mpLastFocusWindow->IsInputEnabled() &&
! mpWindowImpl->mpLastFocusWindow->IsInModalMode()
)
{
mpWindowImpl->mpLastFocusWindow->GrabFocus();
return;
}
}
// If the Window is disabled, then we don't change the focus
if ( !IsEnabled() || !IsInputEnabled() || IsInModalMode() )
return;
// we only need to set the focus if it is not already set
// note: if some other frame is waiting for an asynchrounous focus event
// we also have to post an asynchronous focus event for this frame
// which is done using ToTop
ImplSVData* pSVData = ImplGetSVData();
sal_Bool bAsyncFocusWaiting = sal_False;
Window *pFrame = pSVData->maWinData.mpFirstFrame;
while( pFrame )
{
if( pFrame != mpWindowImpl->mpFrameWindow && pFrame->mpWindowImpl->mpFrameData->mnFocusId )
{
bAsyncFocusWaiting = sal_True;
break;
}
pFrame = pFrame->mpWindowImpl->mpFrameData->mpNextFrame;
}
bool bHasFocus = IsWindowFocused(*mpWindowImpl);
sal_Bool bMustNotGrabFocus = sal_False;
// #100242#, check parent hierarchy if some floater prohibits grab focus
Window *pParent = this;
while( pParent )
{
// #102158#, ignore grabfocus only if the floating parent grabs keyboard focus by itself (GrabsFocus())
// otherwise we cannot set the focus in a floating toolbox
if( ( (pParent->mpWindowImpl->mbFloatWin && ((FloatingWindow*)pParent)->GrabsFocus()) || ( pParent->GetStyle() & WB_SYSTEMFLOATWIN ) ) && !( pParent->GetStyle() & WB_MOVEABLE ) )
{
bMustNotGrabFocus = sal_True;
break;
}
pParent = pParent->mpWindowImpl->mpParent;
}
if ( ( pSVData->maWinData.mpFocusWin != this && ! mpWindowImpl->mbInDtor ) || ( bAsyncFocusWaiting && !bHasFocus && !bMustNotGrabFocus ) )
{
// EndExtTextInput if it is not the same window
if ( pSVData->maWinData.mpExtTextInputWin &&
(pSVData->maWinData.mpExtTextInputWin != this) )
pSVData->maWinData.mpExtTextInputWin->EndExtTextInput( EXTTEXTINPUT_END_COMPLETE );
// Dieses Fenster als letztes FocusWindow merken
Window* pOverlapWindow = ImplGetFirstOverlapWindow();
pOverlapWindow->mpWindowImpl->mpLastFocusWindow = this;
mpWindowImpl->mpFrameData->mpFocusWin = this;
if( !bHasFocus )
{
// menue windows never get the system focus
// the application will keep the focus
if( bMustNotGrabFocus )
return;
else
{
// Hier setzen wir schon den Focus um, da ToTop() den Focus
// nicht auf ein anderes Fenster setzen darf
//DBG_WARNING( "Window::GrabFocus() - Frame doesn't have the focus" );
mpWindowImpl->mpFrame->ToTop( SAL_FRAME_TOTOP_GRABFOCUS | SAL_FRAME_TOTOP_GRABFOCUS_ONLY );
return;
}
}
Window* pOldFocusWindow = pSVData->maWinData.mpFocusWin;
ImplDelData aOldFocusDel( pOldFocusWindow );
pSVData->maWinData.mpFocusWin = this;
if ( pOldFocusWindow )
{
// Cursor hiden
if ( pOldFocusWindow->mpWindowImpl->mpCursor )
pOldFocusWindow->mpWindowImpl->mpCursor->ImplHide( true );
}
// !!!!! Wegen altem SV-Office Activate/Deavtivate Handling
// !!!!! erstmal so wie frueher
if ( pOldFocusWindow )
{
// Focus merken
Window* pOldOverlapWindow = pOldFocusWindow->ImplGetFirstOverlapWindow();
Window* pNewOverlapWindow = ImplGetFirstOverlapWindow();
if ( pOldOverlapWindow != pNewOverlapWindow )
ImplCallFocusChangeActivate( pNewOverlapWindow, pOldOverlapWindow );
}
else
{
Window* pNewOverlapWindow = ImplGetFirstOverlapWindow();
Window* pNewRealWindow = pNewOverlapWindow->ImplGetWindow();
pNewOverlapWindow->mpWindowImpl->mbActive = sal_True;
pNewOverlapWindow->Activate();
if ( pNewRealWindow != pNewOverlapWindow )
{
pNewRealWindow->mpWindowImpl->mbActive = sal_True;
pNewRealWindow->Activate();
}
}
/*
// call Deactivate and Activate
Window* pDeactivateParent;
Window* pActivateParent;
Window* pParent;
Window* pLastParent;
pDeactivateParent = pOldFocusWindow;
while ( pDeactivateParent )
{
pParent = pDeactivateParent;
if ( pParent->ImplIsChild( this ) )
break;
if ( pDeactivateParent->ImplIsOverlapWindow() )
{
if ( !pDeactivateParent->mpWindowImpl->mbParentActive )
break;
}
pDeactivateParent = pDeactivateParent->ImplGetParent();
}
if ( pOldFocusWindow )
{
pActivateParent = this;
while ( pActivateParent )
{
pParent = pActivateParent;
if ( pParent->ImplIsChild( pOldFocusWindow ) )
break;
if ( pActivateParent->ImplIsOverlapWindow() )
{
if ( !pActivateParent->mpWindowImpl->mbParentActive )
break;
}
pActivateParent = pActivateParent->ImplGetParent();
}
}
else
{
if ( ImplIsOverlapWindow() )
pActivateParent = this;
else
pActivateParent = mpWindowImpl->mpOverlapWindow;
while ( pActivateParent )
{
if ( pActivateParent->ImplIsOverlapWindow() )
{
if ( !pActivateParent->mpWindowImpl->mbParentActive )
break;
}
pActivateParent = pActivateParent->ImplGetParent();
}
}
if ( pDeactivateParent )
{
do
{
pLastParent = pOldFocusWindow;
if ( pLastParent != pDeactivateParent )
{
pParent = pLastParent->ImplGetParent();
while ( pParent )
{
if ( pParent == pDeactivateParent )
break;
pLastParent = pParent;
pParent = pParent->ImplGetParent();
}
}
else
pParent = pLastParent;
pParent->mpWindowImpl->mbActive = sal_False;
pParent->Deactivate();
pDeactivateParent = pLastParent;
}
while ( pDeactivateParent != pOldFocusWindow );
}
do
{
pLastParent = this;
if ( pLastParent != pActivateParent )
{
pParent = pLastParent->ImplGetParent();
while ( pParent )
{
if ( pParent == pActivateParent )
break;
pLastParent = pParent;
pParent = pParent->ImplGetParent();
}
}
else
pParent = pLastParent;
pParent->mpWindowImpl->mbActive = sal_True;
pParent->Activate();
pActivateParent = pLastParent;
}
while ( pActivateParent != this );
*/
// call Get- and LoseFocus
if ( pOldFocusWindow && ! aOldFocusDel.IsDelete() )
{
if ( pOldFocusWindow->IsTracking() &&
(pSVData->maWinData.mnTrackFlags & STARTTRACK_FOCUSCANCEL) )
pOldFocusWindow->EndTracking( ENDTRACK_CANCEL | ENDTRACK_FOCUS );
NotifyEvent aNEvt( EVENT_LOSEFOCUS, pOldFocusWindow );
if ( !ImplCallPreNotify( aNEvt ) )
pOldFocusWindow->LoseFocus();
pOldFocusWindow->ImplCallDeactivateListeners( this );
}
if ( pSVData->maWinData.mpFocusWin == this )
{
if ( mpWindowImpl->mpSysObj )
{
mpWindowImpl->mpFrameData->mpFocusWin = this;
if ( !mpWindowImpl->mpFrameData->mbInSysObjFocusHdl )
mpWindowImpl->mpSysObj->GrabFocus();
}
if ( pSVData->maWinData.mpFocusWin == this )
{
if ( mpWindowImpl->mpCursor )
mpWindowImpl->mpCursor->ImplShow();
mpWindowImpl->mbInFocusHdl = sal_True;
mpWindowImpl->mnGetFocusFlags = nFlags;
// if we're changing focus due to closing a popup floating window
// notify the new focus window so it can restore the inner focus
// eg, toolboxes can select their recent active item
if( pOldFocusWindow &&
! aOldFocusDel.IsDelete() &&
( pOldFocusWindow->GetDialogControlFlags() & WINDOW_DLGCTRL_FLOATWIN_POPUPMODEEND_CANCEL ) )
mpWindowImpl->mnGetFocusFlags |= GETFOCUS_FLOATWIN_POPUPMODEEND_CANCEL;
NotifyEvent aNEvt( EVENT_GETFOCUS, this );
if ( !ImplCallPreNotify( aNEvt ) && !aDogTag.IsDelete() )
GetFocus();
if( !aDogTag.IsDelete() )
ImplCallActivateListeners( (pOldFocusWindow && ! aOldFocusDel.IsDelete()) ? pOldFocusWindow : NULL );
if( !aDogTag.IsDelete() )
{
mpWindowImpl->mnGetFocusFlags = 0;
mpWindowImpl->mbInFocusHdl = sal_False;
}
}
}
GetpApp()->FocusChanged();
ImplNewInputContext();
}
}
// -----------------------------------------------------------------------
void Window::ImplNewInputContext()
{
ImplSVData* pSVData = ImplGetSVData();
Window* pFocusWin = pSVData->maWinData.mpFocusWin;
if ( !pFocusWin )
return;
// Is InputContext changed?
const InputContext& rInputContext = pFocusWin->GetInputContext();
if ( rInputContext == pFocusWin->mpWindowImpl->mpFrameData->maOldInputContext )
return;
pFocusWin->mpWindowImpl->mpFrameData->maOldInputContext = rInputContext;
SalInputContext aNewContext;
const Font& rFont = rInputContext.GetFont();
const XubString& rFontName = rFont.GetName();
ImplFontEntry* pFontEntry = NULL;
aNewContext.mpFont = NULL;
if ( rFontName.Len() )
{
Size aSize = pFocusWin->ImplLogicToDevicePixel( rFont.GetSize() );
if ( !aSize.Height() )
{
// Nur dann Defaultgroesse setzen, wenn Fonthoehe auch in logischen
// Koordinaaten 0 ist
if ( rFont.GetSize().Height() )
aSize.Height() = 1;
else
aSize.Height() = (12*pFocusWin->mnDPIY)/72;
}
// TODO: No display device uses ImplDirectFontSubstitution thingy, right? => remove it
ImplDirectFontSubstitution* pFontSubst = NULL;
//if( pFocusWin->mpOutDevData )
// pFontSubst = &pFocusWin->mpOutDevData->maDevFontSubst;
pFontEntry = pFocusWin->mpFontCache->GetFontEntry( pFocusWin->mpFontList,
rFont, aSize, static_cast<float>(aSize.Height()), pFontSubst );
if ( pFontEntry )
aNewContext.mpFont = &pFontEntry->maFontSelData;
}
aNewContext.meLanguage = rFont.GetLanguage();
aNewContext.mnOptions = rInputContext.GetOptions();
pFocusWin->ImplGetFrame()->SetInputContext( &aNewContext );
if ( pFontEntry )
pFocusWin->mpFontCache->Release( pFontEntry );
}
// -----------------------------------------------------------------------
Window::Window( WindowType nType )
{
DBG_CTOR( Window, ImplDbgCheckWindow );
ImplInitWindowData( nType );
}
// -----------------------------------------------------------------------
Window::Window( Window* pParent, WinBits nStyle )
{
DBG_CTOR( Window, ImplDbgCheckWindow );
ImplInitWindowData( WINDOW_WINDOW );
ImplInit( pParent, nStyle, NULL );
}
// -----------------------------------------------------------------------
Window::Window( Window* pParent, const ResId& rResId )
{
DBG_CTOR( Window, ImplDbgCheckWindow );
ImplInitWindowData( WINDOW_WINDOW );
rResId.SetRT( RSC_WINDOW );
WinBits nStyle = ImplInitRes( rResId );
ImplInit( pParent, nStyle, NULL );
ImplLoadRes( rResId );
if ( !(nStyle & WB_HIDE) )
Show();
}
// -----------------------------------------------------------------------
#if OSL_DEBUG_LEVEL > 0
namespace
{
void lcl_appendWindowInfo( ByteString& io_rErrorString, const Window& i_rWindow )
{
// skip border windows, they don't carry information which helps diagnosing the problem
const Window* pWindow( &i_rWindow );
while ( pWindow && ( pWindow->GetType() == WINDOW_BORDERWINDOW ) )
pWindow = pWindow->GetWindow( WINDOW_FIRSTCHILD );
if ( !pWindow )
pWindow = &i_rWindow;
io_rErrorString += char(13);
io_rErrorString += typeid( *pWindow ).name();
io_rErrorString += " (window text: '";
io_rErrorString += ByteString( pWindow->GetText(), RTL_TEXTENCODING_UTF8 );
io_rErrorString += "')";
}
}
#endif
// -----------------------------------------------------------------------
Window::~Window()
{
ImplFreeExtWindowImpl();
vcl::LazyDeletor<Window>::Undelete( this );
DBG_DTOR( Window, ImplDbgCheckWindow );
DBG_ASSERT( !mpWindowImpl->mbInDtor, "~Window - already in DTOR!" );
// remove Key and Mouse events issued by Application::PostKey/MouseEvent
Application::RemoveMouseAndKeyEvents( this );
// Dispose of the canvas implementation (which, currently, has an
// own wrapper window as a child to this one.
uno::Reference< rendering::XCanvas > xCanvas( mpWindowImpl->mxCanvas );
if( xCanvas.is() )
{
uno::Reference < lang::XComponent > xCanvasComponent( xCanvas,
uno::UNO_QUERY );
if( xCanvasComponent.is() )
xCanvasComponent->dispose();
}
mpWindowImpl->mbInDtor = sal_True;
ImplCallEventListeners( VCLEVENT_OBJECT_DYING );
// do not send child events for frames that were registered as native frames
if( !ImplIsAccessibleNativeFrame() && mpWindowImpl->mbReallyVisible )
if ( ImplIsAccessibleCandidate() && GetAccessibleParentWindow() )
GetAccessibleParentWindow()->ImplCallEventListeners( VCLEVENT_WINDOW_CHILDDESTROYED, this );
// remove associated data structures from dockingmanager
ImplGetDockingManager()->RemoveWindow( this );
// remove ownerdraw decorated windows from list in the top-most frame window
if( (GetStyle() & WB_OWNERDRAWDECORATION) && mpWindowImpl->mbFrame )
{
::std::vector< Window* >& rList = ImplGetOwnerDrawList();
::std::vector< Window* >::iterator p;
p = ::std::find( rList.begin(), rList.end(), this );
if( p != rList.end() )
rList.erase( p );
}
// shutdown drag and drop
::com::sun::star::uno::Reference < ::com::sun::star::lang::XComponent > xDnDComponent( mpWindowImpl->mxDNDListenerContainer, ::com::sun::star::uno::UNO_QUERY );
if( xDnDComponent.is() )
xDnDComponent->dispose();
if( mpWindowImpl->mbFrame && mpWindowImpl->mpFrameData )
{
try
{
// deregister drop target listener
if( mpWindowImpl->mpFrameData->mxDropTargetListener.is() )
{
uno::Reference< XDragGestureRecognizer > xDragGestureRecognizer =
uno::Reference< XDragGestureRecognizer > (mpWindowImpl->mpFrameData->mxDragSource, UNO_QUERY);
if( xDragGestureRecognizer.is() )
{
xDragGestureRecognizer->removeDragGestureListener(
uno::Reference< XDragGestureListener > (mpWindowImpl->mpFrameData->mxDropTargetListener, UNO_QUERY));
}
mpWindowImpl->mpFrameData->mxDropTarget->removeDropTargetListener( mpWindowImpl->mpFrameData->mxDropTargetListener );
mpWindowImpl->mpFrameData->mxDropTargetListener.clear();
}
// shutdown drag and drop for this frame window
uno::Reference< XComponent > xComponent( mpWindowImpl->mpFrameData->mxDropTarget, UNO_QUERY );
// DNDEventDispatcher does not hold a reference of the DropTarget,
// so it's ok if it does not support XComponent
if( xComponent.is() )
xComponent->dispose();
}
catch ( Exception&)
{
// can be safely ignored here.
}
}
UnoWrapperBase* pWrapper = Application::GetUnoWrapper( sal_False );
if ( pWrapper )
pWrapper->WindowDestroyed( this );
// MT: Must be called after WindowDestroyed!
// Otherwise, if the accessible is a VCLXWindow, it will try to destroy this window again!
// But accessibility implementations from applications need this dispose.
if ( mpWindowImpl->mxAccessible.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent> xC( mpWindowImpl->mxAccessible, ::com::sun::star::uno::UNO_QUERY );
if ( xC.is() )
xC->dispose();
}
ImplSVData* pSVData = ImplGetSVData();
if ( pSVData->maHelpData.mpHelpWin && (pSVData->maHelpData.mpHelpWin->GetParent() == this) )
ImplDestroyHelpWindow( true );
DBG_ASSERT( pSVData->maWinData.mpTrackWin != this,
"Window::~Window(): Window is in TrackingMode" );
DBG_ASSERT( pSVData->maWinData.mpCaptureWin != this,
"Window::~Window(): Window has the mouse captured" );
// #103442# DefModalDialogParent is now determined on-the-fly, so this pointer is unimportant now
//DBG_ASSERT( pSVData->maWinData.mpDefDialogParent != this,
// "Window::~Window(): Window is DefModalDialogParent" );
// Wegen alter kompatibilitaet
if ( pSVData->maWinData.mpTrackWin == this )
EndTracking();
if ( pSVData->maWinData.mpCaptureWin == this )
ReleaseMouse();
if ( pSVData->maWinData.mpDefDialogParent == this )
pSVData->maWinData.mpDefDialogParent = NULL;
#ifdef DBG_UTIL
if ( sal_True ) // always perform these tests in non-pro versions
{
ByteString aErrorStr;
sal_Bool bError = sal_False;
Window* pTempWin = mpWindowImpl->mpFrameData->mpFirstOverlap;
while ( pTempWin )
{
if ( ImplIsRealParentPath( pTempWin ) )
{
bError = sal_True;
lcl_appendWindowInfo( aErrorStr, *pTempWin );
}
pTempWin = pTempWin->mpWindowImpl->mpNextOverlap;
}
if ( bError )
{
ByteString aTempStr( "Window (" );
aTempStr += ByteString( GetText(), RTL_TEXTENCODING_UTF8 );
aTempStr += ") with living SystemWindow(s) destroyed: ";
aTempStr += aErrorStr;
DBG_ERROR( aTempStr.GetBuffer() );
GetpApp()->Abort( String( aTempStr, RTL_TEXTENCODING_UTF8 ) ); // abort in non-pro version, this must be fixed!
}
bError = sal_False;
pTempWin = pSVData->maWinData.mpFirstFrame;
while ( pTempWin )
{
if ( ImplIsRealParentPath( pTempWin ) )
{
bError = sal_True;
lcl_appendWindowInfo( aErrorStr, *pTempWin );
}
pTempWin = pTempWin->mpWindowImpl->mpFrameData->mpNextFrame;
}
if ( bError )
{
ByteString aTempStr( "Window (" );
aTempStr += ByteString( GetText(), RTL_TEXTENCODING_UTF8 );
aTempStr += ") with living SystemWindow(s) destroyed: ";
aTempStr += aErrorStr;
DBG_ERROR( aTempStr.GetBuffer() );
GetpApp()->Abort( String( aTempStr, RTL_TEXTENCODING_UTF8 ) ); // abort in non-pro version, this must be fixed!
}
if ( mpWindowImpl->mpFirstChild )
{
ByteString aTempStr( "Window (" );
aTempStr += ByteString( GetText(), RTL_TEXTENCODING_UTF8 );
aTempStr += ") with living Child(s) destroyed: ";
pTempWin = mpWindowImpl->mpFirstChild;
while ( pTempWin )
{
lcl_appendWindowInfo( aTempStr, *pTempWin );
pTempWin = pTempWin->mpWindowImpl->mpNext;
}
DBG_ERROR( aTempStr.GetBuffer() );
GetpApp()->Abort( String( aTempStr, RTL_TEXTENCODING_UTF8 ) ); // abort in non-pro version, this must be fixed!
}
if ( mpWindowImpl->mpFirstOverlap )
{
ByteString aTempStr( "Window (" );
aTempStr += ByteString( GetText(), RTL_TEXTENCODING_UTF8 );
aTempStr += ") with living SystemWindow(s) destroyed: ";
pTempWin = mpWindowImpl->mpFirstOverlap;
while ( pTempWin )
{
lcl_appendWindowInfo( aTempStr, *pTempWin );
pTempWin = pTempWin->mpWindowImpl->mpNext;
}
DBG_ERROR( aTempStr.GetBuffer() );
GetpApp()->Abort( String( aTempStr, RTL_TEXTENCODING_UTF8 ) ); // abort in non-pro version, this must be fixed!
}
Window* pMyParent = this;
SystemWindow* pMySysWin = NULL;
while ( pMyParent )
{
if ( pMyParent->IsSystemWindow() )
pMySysWin = (SystemWindow*)pMyParent;
pMyParent = pMyParent->GetParent();
}
if ( pMySysWin && pMySysWin->ImplIsInTaskPaneList( this ) )
{
ByteString aTempStr( "Window (" );
aTempStr += ByteString( GetText(), RTL_TEXTENCODING_UTF8 );
aTempStr += ") still in TaskPanelList!";
DBG_ERROR( aTempStr.GetBuffer() );
GetpApp()->Abort( String( aTempStr, RTL_TEXTENCODING_UTF8 ) ); // abort in non-pro version, this must be fixed!
}
}
#endif
if( mpWindowImpl->mbIsInTaskPaneList )
{
Window* pMyParent = this;
SystemWindow* pMySysWin = NULL;
while ( pMyParent )
{
if ( pMyParent->IsSystemWindow() )
pMySysWin = (SystemWindow*)pMyParent;
pMyParent = pMyParent->GetParent();
}
if ( pMySysWin && pMySysWin->ImplIsInTaskPaneList( this ) )
{
pMySysWin->GetTaskPaneList()->RemoveWindow( this );
}
else
{
ByteString aTempStr( "Window (" );
aTempStr += ByteString( GetText(), RTL_TEXTENCODING_UTF8 );
aTempStr += ") not found in TaskPanelList!";
DBG_ERROR( aTempStr.GetBuffer() );
}
}
// Fenster hiden, um das entsprechende Paint-Handling auszuloesen
Hide();
// Mitteilen, das Fenster zerstoert wird
{
NotifyEvent aNEvt( EVENT_DESTROY, this );
Notify( aNEvt );
}
// EndExtTextInputMode
if ( pSVData->maWinData.mpExtTextInputWin == this )
{
EndExtTextInput( EXTTEXTINPUT_END_COMPLETE );
if ( pSVData->maWinData.mpExtTextInputWin == this )
pSVData->maWinData.mpExtTextInputWin = NULL;
}
// check if the focus window is our child
sal_Bool bHasFocussedChild = sal_False;
if( pSVData->maWinData.mpFocusWin && ImplIsRealParentPath( pSVData->maWinData.mpFocusWin ) )
{
// #122232#, this must not happen and is an application bug ! but we try some cleanup to hopefully avoid crashes, see below
bHasFocussedChild = sal_True;
#ifdef DBG_UTIL
ByteString aTempStr( "Window (" );
aTempStr += ByteString( GetText(), RTL_TEXTENCODING_UTF8 );
aTempStr += ") with focussed child window destroyed ! THIS WILL LEAD TO CRASHES AND MUST BE FIXED !";
DBG_ERROR( aTempStr.GetBuffer() );
GetpApp()->Abort( String( aTempStr, RTL_TEXTENCODING_UTF8 ) ); // abort in non-pro version, this must be fixed!
#endif
}
// Wenn wir den Focus haben, dann den Focus auf ein anderes Fenster setzen
Window* pOverlapWindow = ImplGetFirstOverlapWindow();
if ( pSVData->maWinData.mpFocusWin == this
|| bHasFocussedChild ) // #122232#, see above, try some cleanup
{
if ( mpWindowImpl->mbFrame )
{
pSVData->maWinData.mpFocusWin = NULL;
pOverlapWindow->mpWindowImpl->mpLastFocusWindow = NULL;
GetpApp()->FocusChanged();
}
else
{
Window* pParent = GetParent();
Window* pBorderWindow = mpWindowImpl->mpBorderWindow;
// Bei ueberlappenden Fenstern wird der Focus auf den
// Parent vom naechsten FrameWindow gesetzt
if ( pBorderWindow )
{
if ( pBorderWindow->ImplIsOverlapWindow() )
pParent = pBorderWindow->mpWindowImpl->mpOverlapWindow;
}
else if ( ImplIsOverlapWindow() )
pParent = mpWindowImpl->mpOverlapWindow;
if ( pParent && pParent->IsEnabled() && pParent->IsInputEnabled() && ! pParent->IsInModalMode() )
pParent->GrabFocus();
else
mpWindowImpl->mpFrameWindow->GrabFocus();
// If the focus was set back to 'this' set it to nothing
if ( pSVData->maWinData.mpFocusWin == this )
{
pSVData->maWinData.mpFocusWin = NULL;
pOverlapWindow->mpWindowImpl->mpLastFocusWindow = NULL;
GetpApp()->FocusChanged();
}
}
}
if ( pOverlapWindow->mpWindowImpl->mpLastFocusWindow == this )
pOverlapWindow->mpWindowImpl->mpLastFocusWindow = NULL;
// reset hint for DefModalDialogParent
if( pSVData->maWinData.mpActiveApplicationFrame == this )
pSVData->maWinData.mpActiveApplicationFrame = NULL;
// gemerkte Fenster zuruecksetzen
if ( mpWindowImpl->mpFrameData->mpFocusWin == this )
mpWindowImpl->mpFrameData->mpFocusWin = NULL;
if ( mpWindowImpl->mpFrameData->mpMouseMoveWin == this )
mpWindowImpl->mpFrameData->mpMouseMoveWin = NULL;
if ( mpWindowImpl->mpFrameData->mpMouseDownWin == this )
mpWindowImpl->mpFrameData->mpMouseDownWin = NULL;
// Deactivate-Window zuruecksetzen
if ( pSVData->maWinData.mpLastDeacWin == this )
pSVData->maWinData.mpLastDeacWin = NULL;
if ( mpWindowImpl->mbFrame )
{
if ( mpWindowImpl->mpFrameData->mnFocusId )
Application::RemoveUserEvent( mpWindowImpl->mpFrameData->mnFocusId );
if ( mpWindowImpl->mpFrameData->mnMouseMoveId )
Application::RemoveUserEvent( mpWindowImpl->mpFrameData->mnMouseMoveId );
}
// release SalGraphics
ImplReleaseGraphics();
// notify ImplDelData subscribers of this window about the window deletion
ImplDelData* pDelData = mpWindowImpl->mpFirstDel;
while ( pDelData )
{
pDelData->mbDel = sal_True;
pDelData->mpWindow = NULL; // #112873# pDel is not associated with a Window anymore
pDelData = pDelData->mpNext;
}
// remove window from the lists
ImplRemoveWindow( sal_True );
// de-register as "top window child" at our parent, if necessary
if ( mpWindowImpl->mbFrame )
{
sal_Bool bIsTopWindow = mpWindowImpl->mpWinData && ( mpWindowImpl->mpWinData->mnIsTopWindow == 1 );
if ( mpWindowImpl->mpRealParent && bIsTopWindow )
{
ImplWinData* pParentWinData = mpWindowImpl->mpRealParent->ImplGetWinData();
::std::list< Window* >::iterator myPos = ::std::find( pParentWinData->maTopWindowChildren.begin(),
pParentWinData->maTopWindowChildren.end(), this );
DBG_ASSERT( myPos != pParentWinData->maTopWindowChildren.end(), "Window::~Window: inconsistency in top window chain!" );
if ( myPos != pParentWinData->maTopWindowChildren.end() )
pParentWinData->maTopWindowChildren.erase( myPos );
}
}
// cleanup Extra Window Data, TODO: add and use ImplWinData destructor
if ( mpWindowImpl->mpWinData )
{
if ( mpWindowImpl->mpWinData->mpExtOldText )
delete mpWindowImpl->mpWinData->mpExtOldText;
if ( mpWindowImpl->mpWinData->mpExtOldAttrAry )
delete mpWindowImpl->mpWinData->mpExtOldAttrAry;
if ( mpWindowImpl->mpWinData->mpCursorRect )
delete mpWindowImpl->mpWinData->mpCursorRect;
if ( mpWindowImpl->mpWinData->mpFocusRect )
delete mpWindowImpl->mpWinData->mpFocusRect;
if ( mpWindowImpl->mpWinData->mpTrackRect )
delete mpWindowImpl->mpWinData->mpTrackRect;
delete mpWindowImpl->mpWinData;
}
// cleanup overlap related window data
if ( mpWindowImpl->mpOverlapData )
delete mpWindowImpl->mpOverlapData;
// remove BorderWindow or Frame window data
if ( mpWindowImpl->mpBorderWindow )
delete mpWindowImpl->mpBorderWindow;
else if ( mpWindowImpl->mbFrame )
{
if ( pSVData->maWinData.mpFirstFrame == this )
pSVData->maWinData.mpFirstFrame = mpWindowImpl->mpFrameData->mpNextFrame;
else
{
Window* pSysWin = pSVData->maWinData.mpFirstFrame;
while ( pSysWin->mpWindowImpl->mpFrameData->mpNextFrame != this )
pSysWin = pSysWin->mpWindowImpl->mpFrameData->mpNextFrame;
pSysWin->mpWindowImpl->mpFrameData->mpNextFrame = mpWindowImpl->mpFrameData->mpNextFrame;
}
mpWindowImpl->mpFrame->SetCallback( NULL, NULL );
pSVData->mpDefInst->DestroyFrame( mpWindowImpl->mpFrame );
delete mpWindowImpl->mpFrameData;
}
// should be the last statements
delete mpWindowImpl; mpWindowImpl = NULL;
}
// -----------------------------------------------------------------------
void Window::doLazyDelete()
{
SystemWindow* pSysWin = dynamic_cast<SystemWindow*>(this);
DockingWindow* pDockWin = dynamic_cast<DockingWindow*>(this);
if( pSysWin || ( pDockWin && pDockWin->IsFloatingMode() ) )
{
Show( sal_False );
SetParent( ImplGetDefaultWindow() );
}
vcl::LazyDeletor<Window>::Delete( this );
}
// -----------------------------------------------------------------------
void Window::InterceptChildWindowKeyDown( sal_Bool bIntercept )
{
if( mpWindowImpl->mpSysObj )
mpWindowImpl->mpSysObj->InterceptChildWindowKeyDown( bIntercept );
}
// -----------------------------------------------------------------------
void Window::MouseMove( const MouseEvent& rMEvt )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
NotifyEvent aNEvt( EVENT_MOUSEMOVE, this, &rMEvt );
if ( !Notify( aNEvt ) )
mpWindowImpl->mbMouseMove = sal_True;
}
// -----------------------------------------------------------------------
void Window::MouseButtonDown( const MouseEvent& rMEvt )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
NotifyEvent aNEvt( EVENT_MOUSEBUTTONDOWN, this, &rMEvt );
if ( !Notify( aNEvt ) )
mpWindowImpl->mbMouseButtonDown = sal_True;
}
// -----------------------------------------------------------------------
void Window::MouseButtonUp( const MouseEvent& rMEvt )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
NotifyEvent aNEvt( EVENT_MOUSEBUTTONUP, this, &rMEvt );
if ( !Notify( aNEvt ) )
mpWindowImpl->mbMouseButtonUp = sal_True;
}
// -----------------------------------------------------------------------
void Window::KeyInput( const KeyEvent& rKEvt )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
NotifyEvent aNEvt( EVENT_KEYINPUT, this, &rKEvt );
if ( !Notify( aNEvt ) )
mpWindowImpl->mbKeyInput = sal_True;
}
// -----------------------------------------------------------------------
void Window::KeyUp( const KeyEvent& rKEvt )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
NotifyEvent aNEvt( EVENT_KEYUP, this, &rKEvt );
if ( !Notify( aNEvt ) )
mpWindowImpl->mbKeyUp = sal_True;
}
// -----------------------------------------------------------------------
void Window::PrePaint()
{
}
// -----------------------------------------------------------------------
void Window::Paint( const Rectangle& rRect )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
ImplCallEventListeners( VCLEVENT_WINDOW_PAINT, (void*)&rRect );
}
// -----------------------------------------------------------------------
void Window::PostPaint()
{
}
// -----------------------------------------------------------------------
void Window::Draw( OutputDevice*, const Point&, const Size&, sal_uLong )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
// -----------------------------------------------------------------------
void Window::Move()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
// -----------------------------------------------------------------------
void Window::Resize()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
// -----------------------------------------------------------------------
void Window::Activate()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
// -----------------------------------------------------------------------
void Window::Deactivate()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
// -----------------------------------------------------------------------
void Window::GetFocus()
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
if ( HasFocus() && mpWindowImpl->mpLastFocusWindow && !(mpWindowImpl->mnDlgCtrlFlags & WINDOW_DLGCTRL_WANTFOCUS) )
{
ImplDelData aDogtag( this );
mpWindowImpl->mpLastFocusWindow->GrabFocus();
if( aDogtag.IsDelete() )
return;
}
NotifyEvent aNEvt( EVENT_GETFOCUS, this );
Notify( aNEvt );
}
// -----------------------------------------------------------------------
void Window::LoseFocus()
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
NotifyEvent aNEvt( EVENT_LOSEFOCUS, this );
Notify( aNEvt );
}
// -----------------------------------------------------------------------
void Window::RequestHelp( const HelpEvent& rHEvt )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
// Wenn Balloon-Help angefordert wird, dann den Balloon mit dem
// gesetzten Hilfetext anzeigen
if ( rHEvt.GetMode() & HELPMODE_BALLOON )
{
const XubString* pStr = &(GetHelpText());
if ( !pStr->Len() )
pStr = &(GetQuickHelpText());
if ( !pStr->Len() && ImplGetParent() && !ImplIsOverlapWindow() )
ImplGetParent()->RequestHelp( rHEvt );
else
Help::ShowBalloon( this, rHEvt.GetMousePosPixel(), *pStr );
}
else if ( rHEvt.GetMode() & HELPMODE_QUICK )
{
const XubString* pStr = &(GetQuickHelpText());
if ( !pStr->Len() && ImplGetParent() && !ImplIsOverlapWindow() )
ImplGetParent()->RequestHelp( rHEvt );
else
{
Point aPos = GetPosPixel();
if ( ImplGetParent() && !ImplIsOverlapWindow() )
aPos = ImplGetParent()->OutputToScreenPixel( aPos );
Rectangle aRect( aPos, GetSizePixel() );
String aHelpText;
if ( pStr->Len() )
aHelpText = GetHelpText();
Help::ShowQuickHelp( this, aRect, *pStr, aHelpText, QUICKHELP_CTRLTEXT );
}
}
else
{
String aStrHelpId( rtl::OStringToOUString( GetHelpId(), RTL_TEXTENCODING_UTF8 ) );
if ( aStrHelpId.Len() == 0 && ImplGetParent() )
ImplGetParent()->RequestHelp( rHEvt );
else
{
Help* pHelp = Application::GetHelp();
if ( pHelp )
{
if( aStrHelpId.Len() > 0 )
pHelp->Start( aStrHelpId, this );
else
pHelp->Start( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OOO_HELP_INDEX ) ), this );
}
}
}
}
// -----------------------------------------------------------------------
void Window::Command( const CommandEvent& rCEvt )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
ImplCallEventListeners( VCLEVENT_WINDOW_COMMAND, (void*)&rCEvt );
NotifyEvent aNEvt( EVENT_COMMAND, this, &rCEvt );
if ( !Notify( aNEvt ) )
mpWindowImpl->mbCommand = sal_True;
}
// -----------------------------------------------------------------------
void Window::Tracking( const TrackingEvent& rTEvt )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
if( pWrapper )
pWrapper->Tracking( rTEvt );
}
// -----------------------------------------------------------------------
void Window::UserEvent( sal_uLong, void* )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
// -----------------------------------------------------------------------
void Window::StateChanged( StateChangedType )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
// -----------------------------------------------------------------------
void Window::DataChanged( const DataChangedEvent& )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
// -----------------------------------------------------------------------
void Window::ImplNotifyKeyMouseCommandEventListeners( NotifyEvent& rNEvt )
{
if( rNEvt.GetType() == EVENT_COMMAND )
{
const CommandEvent* pCEvt = rNEvt.GetCommandEvent();
if ( pCEvt->GetCommand() != COMMAND_CONTEXTMENU )
// non context menu events are not to be notified up the chain
// so we return immediately
return;
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
{
if ( rNEvt.GetWindow() == this )
// not interested in: The event listeners are already called in ::Command,
// and calling them here a second time doesn't make sense
;
else
{
CommandEvent aCommandEvent = ImplTranslateCommandEvent( *pCEvt, rNEvt.GetWindow(), this );
ImplCallEventListeners( VCLEVENT_WINDOW_COMMAND, &aCommandEvent );
}
}
}
// #82968# notify event listeners for mouse and key events seperately and
// not in PreNotify ( as for focus listeners )
// this allows for procesing those events internally first and pass it to
// the toolkit later
ImplDelData aDelData;
ImplAddDel( &aDelData );
if( rNEvt.GetType() == EVENT_MOUSEMOVE )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
{
if ( rNEvt.GetWindow() == this )
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEMOVE, (void*)rNEvt.GetMouseEvent() );
else
{
MouseEvent aMouseEvent = ImplTranslateMouseEvent( *rNEvt.GetMouseEvent(), rNEvt.GetWindow(), this );
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEMOVE, &aMouseEvent );
}
}
}
else if( rNEvt.GetType() == EVENT_MOUSEBUTTONUP )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
{
if ( rNEvt.GetWindow() == this )
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEBUTTONUP, (void*)rNEvt.GetMouseEvent() );
else
{
MouseEvent aMouseEvent = ImplTranslateMouseEvent( *rNEvt.GetMouseEvent(), rNEvt.GetWindow(), this );
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEBUTTONUP, &aMouseEvent );
}
}
}
else if( rNEvt.GetType() == EVENT_MOUSEBUTTONDOWN )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
{
if ( rNEvt.GetWindow() == this )
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEBUTTONDOWN, (void*)rNEvt.GetMouseEvent() );
else
{
MouseEvent aMouseEvent = ImplTranslateMouseEvent( *rNEvt.GetMouseEvent(), rNEvt.GetWindow(), this );
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEBUTTONDOWN, &aMouseEvent );
}
}
}
else if( rNEvt.GetType() == EVENT_KEYINPUT )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
ImplCallEventListeners( VCLEVENT_WINDOW_KEYINPUT, (void*)rNEvt.GetKeyEvent() );
}
else if( rNEvt.GetType() == EVENT_KEYUP )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
ImplCallEventListeners( VCLEVENT_WINDOW_KEYUP, (void*)rNEvt.GetKeyEvent() );
}
if ( aDelData.IsDelete() )
return;
ImplRemoveDel( &aDelData );
// #106721# check if we're part of a compound control and notify
Window *pParent = ImplGetParent();
while( pParent )
{
if( pParent->IsCompoundControl() )
{
pParent->ImplNotifyKeyMouseCommandEventListeners( rNEvt );
break;
}
pParent = pParent->ImplGetParent();
}
}
// -----------------------------------------------------------------------
long Window::PreNotify( NotifyEvent& rNEvt )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
long bDone = sal_False;
if ( mpWindowImpl->mpParent && !ImplIsOverlapWindow() )
bDone = mpWindowImpl->mpParent->PreNotify( rNEvt );
if ( !bDone )
{
if( rNEvt.GetType() == EVENT_GETFOCUS )
{
sal_Bool bCompoundFocusChanged = sal_False;
if ( mpWindowImpl->mbCompoundControl && !mpWindowImpl->mbCompoundControlHasFocus && HasChildPathFocus() )
{
mpWindowImpl->mbCompoundControlHasFocus = sal_True;
bCompoundFocusChanged = sal_True;
}
if ( bCompoundFocusChanged || ( rNEvt.GetWindow() == this ) )
ImplCallEventListeners( VCLEVENT_WINDOW_GETFOCUS );
}
else if( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
sal_Bool bCompoundFocusChanged = sal_False;
if ( mpWindowImpl->mbCompoundControl && mpWindowImpl->mbCompoundControlHasFocus && !HasChildPathFocus() )
{
mpWindowImpl->mbCompoundControlHasFocus = sal_False ;
bCompoundFocusChanged = sal_True;
}
if ( bCompoundFocusChanged || ( rNEvt.GetWindow() == this ) )
ImplCallEventListeners( VCLEVENT_WINDOW_LOSEFOCUS );
}
// #82968# mouse and key events will be notified after processing ( in ImplNotifyKeyMouseCommandEventListeners() )!
// see also ImplHandleMouseEvent(), ImplHandleKey()
/*
else if( rNEvt.GetType() == EVENT_MOUSEMOVE )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
{
if ( rNEvt.GetWindow() == this )
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEMOVE, (void*)rNEvt.GetMouseEvent() );
else
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEMOVE, &ImplTranslateMouseEvent( *rNEvt.GetMouseEvent(), rNEvt.GetWindow(), this ) );
}
}
else if( rNEvt.GetType() == EVENT_MOUSEBUTTONUP )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
{
if ( rNEvt.GetWindow() == this )
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEBUTTONUP, (void*)rNEvt.GetMouseEvent() );
else
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEBUTTONUP, &ImplTranslateMouseEvent( *rNEvt.GetMouseEvent(), rNEvt.GetWindow(), this ) );
}
}
else if( rNEvt.GetType() == EVENT_MOUSEBUTTONDOWN )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
{
if ( rNEvt.GetWindow() == this )
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEBUTTONDOWN, (void*)rNEvt.GetMouseEvent() );
else
ImplCallEventListeners( VCLEVENT_WINDOW_MOUSEBUTTONDOWN, &ImplTranslateMouseEvent( *rNEvt.GetMouseEvent(), rNEvt.GetWindow(), this ) );
}
}
else if( rNEvt.GetType() == EVENT_KEYINPUT )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
ImplCallEventListeners( VCLEVENT_WINDOW_KEYINPUT, (void*)rNEvt.GetKeyEvent() );
}
else if( rNEvt.GetType() == EVENT_KEYUP )
{
if ( mpWindowImpl->mbCompoundControl || ( rNEvt.GetWindow() == this ) )
ImplCallEventListeners( VCLEVENT_WINDOW_KEYUP, (void*)rNEvt.GetKeyEvent() );
}
*/
}
return bDone;
}
// -----------------------------------------------------------------------
long Window::Notify( NotifyEvent& rNEvt )
{
{ // Klammerung, da in diesem Handler das Window zerstoert werden darf
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
}
long nRet = sal_False;
// check for docking window
// but do nothing if window is docked and locked
ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
if( pWrapper && !( !pWrapper->IsFloatingMode() && pWrapper->IsLocked() ) )
{
if ( rNEvt.GetType() == EVENT_MOUSEBUTTONDOWN )
{
const MouseEvent* pMEvt = rNEvt.GetMouseEvent();
sal_Bool bHit = pWrapper->GetDragArea().IsInside( pMEvt->GetPosPixel() );
if ( pMEvt->IsLeft() )
{
if ( pMEvt->IsMod1() && (pMEvt->GetClicks() == 2) )
{
// ctrl double click toggles floating mode
pWrapper->SetFloatingMode( !pWrapper->IsFloatingMode() );
return sal_True;
}
else if ( pMEvt->GetClicks() == 1 && bHit)
{
// allow start docking during mouse move
pWrapper->ImplEnableStartDocking();
return sal_True;
}
}
}
else if ( rNEvt.GetType() == EVENT_MOUSEMOVE )
{
const MouseEvent* pMEvt = rNEvt.GetMouseEvent();
sal_Bool bHit = pWrapper->GetDragArea().IsInside( pMEvt->GetPosPixel() );
if ( pMEvt->IsLeft() )
{
// check if a single click initiated this sequence ( ImplStartDockingEnabled() )
// check if window is docked and
if( pWrapper->ImplStartDockingEnabled() && !pWrapper->IsFloatingMode() &&
!pWrapper->IsDocking() && bHit )
{
Point aPos = pMEvt->GetPosPixel();
Window* pWindow = rNEvt.GetWindow();
if ( pWindow != this )
{
aPos = pWindow->OutputToScreenPixel( aPos );
aPos = ScreenToOutputPixel( aPos );
}
pWrapper->ImplStartDocking( aPos );
}
return sal_True;
}
}
else if( rNEvt.GetType() == EVENT_KEYINPUT )
{
const KeyCode& rKey = rNEvt.GetKeyEvent()->GetKeyCode();
if( rKey.GetCode() == KEY_F10 && rKey.GetModifier() &&
rKey.IsShift() && rKey.IsMod1() )
{
pWrapper->SetFloatingMode( !pWrapper->IsFloatingMode() );
/* At this point the floating toolbar frame does not have the
* input focus since these frames don't get the focus per default
* To enable keyboard handling of this toolbar set the input focus
* to the frame. This needs to be done with ToTop since GrabFocus
* would not notice any change since "this" already has the focus.
*/
if( pWrapper->IsFloatingMode() )
ToTop( TOTOP_GRABFOCUSONLY );
return sal_True;
}
}
}
// Dialog-Steuerung
if ( (GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) == WB_DIALOGCONTROL )
{
// Wenn Parent auch DialogSteuerung aktiviert hat, uebernimmt dieser die Steuerung
if ( (rNEvt.GetType() == EVENT_KEYINPUT) || (rNEvt.GetType() == EVENT_KEYUP) )
{
if ( ImplIsOverlapWindow() ||
((ImplGetParent()->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) != WB_DIALOGCONTROL) )
{
nRet = ImplDlgCtrl( *rNEvt.GetKeyEvent(), rNEvt.GetType() == EVENT_KEYINPUT );
}
}
else if ( (rNEvt.GetType() == EVENT_GETFOCUS) || (rNEvt.GetType() == EVENT_LOSEFOCUS) )
{
ImplDlgCtrlFocusChanged( rNEvt.GetWindow(), rNEvt.GetType() == EVENT_GETFOCUS );
if ( (rNEvt.GetWindow() == this) && (rNEvt.GetType() == EVENT_GETFOCUS) &&
!(GetStyle() & WB_TABSTOP) && !(mpWindowImpl->mnDlgCtrlFlags & WINDOW_DLGCTRL_WANTFOCUS) )
{
sal_uInt16 n = 0;
Window* pFirstChild = ImplGetDlgWindow( n, DLGWINDOW_FIRST );
if ( pFirstChild )
pFirstChild->ImplControlFocus();
}
}
}
if ( !nRet )
{
if ( mpWindowImpl->mpParent && !ImplIsOverlapWindow() )
nRet = mpWindowImpl->mpParent->Notify( rNEvt );
}
return nRet;
}
void Window::NotifyVCLEvent( sal_uLong nEvent ,void* pData /*= NULL*/)
{
ImplCallEventListeners( nEvent ,pData);
}
::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > > Window::GetAccFlowToSequence()
{
return ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > >();
}
// -----------------------------------------------------------------------
void Window::ImplCallEventListeners( sal_uLong nEvent, void* pData )
{
// The implementation was moved to CallEventListeners(),
// because derived classes in svtools must be able to
// call the event listeners and ImplCallEventListeners()
// is not exported.
// TODO: replace ImplCallEventListeners() by CallEventListeners() in vcl
CallEventListeners( nEvent, pData );
}
// -----------------------------------------------------------------------
void Window::CallEventListeners( sal_uLong nEvent, void* pData )
{
VclWindowEvent aEvent( this, nEvent, pData );
ImplDelData aDelData;
ImplAddDel( &aDelData );
ImplGetSVData()->mpApp->ImplCallEventListeners( &aEvent );
if ( aDelData.IsDelete() )
return;
if ( !mpWindowImpl->maEventListeners.empty() )
mpWindowImpl->maEventListeners.Call( &aEvent );
if ( aDelData.IsDelete() )
return;
ImplRemoveDel( &aDelData );
Window* pWindow = this;
while ( pWindow )
{
pWindow->ImplAddDel( &aDelData );
if ( !pWindow->mpWindowImpl->maChildEventListeners.empty() )
pWindow->mpWindowImpl->maChildEventListeners.Call( &aEvent );
if ( aDelData.IsDelete() )
return;
pWindow->ImplRemoveDel( &aDelData );
pWindow = pWindow->GetParent();
}
}
void Window::FireVclEvent( VclSimpleEvent* pEvent )
{
ImplGetSVData()->mpApp->ImplCallEventListeners(pEvent);
}
// -----------------------------------------------------------------------
void Window::AddEventListener( const Link& rEventListener )
{
mpWindowImpl->maEventListeners.push_back( rEventListener );
}
// -----------------------------------------------------------------------
void Window::RemoveEventListener( const Link& rEventListener )
{
mpWindowImpl->maEventListeners.remove( rEventListener );
}
// -----------------------------------------------------------------------
void Window::AddChildEventListener( const Link& rEventListener )
{
mpWindowImpl->maChildEventListeners.push_back( rEventListener );
}
// -----------------------------------------------------------------------
void Window::RemoveChildEventListener( const Link& rEventListener )
{
mpWindowImpl->maChildEventListeners.remove( rEventListener );
}
// -----------------------------------------------------------------------
sal_uLong Window::PostUserEvent( sal_uLong nEvent, void* pEventData )
{
sal_uLong nEventId;
PostUserEvent( nEventId, nEvent, pEventData );
return nEventId;
}
// -----------------------------------------------------------------------
sal_uLong Window::PostUserEvent( const Link& rLink, void* pCaller )
{
sal_uLong nEventId;
PostUserEvent( nEventId, rLink, pCaller );
return nEventId;
}
// -----------------------------------------------------------------------
sal_Bool Window::PostUserEvent( sal_uLong& rEventId, sal_uLong nEvent, void* pEventData )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplSVEvent* pSVEvent = new ImplSVEvent;
pSVEvent->mnEvent = nEvent;
pSVEvent->mpData = pEventData;
pSVEvent->mpLink = NULL;
pSVEvent->mpWindow = this;
pSVEvent->mbCall = sal_True;
ImplAddDel( &(pSVEvent->maDelData) );
rEventId = (sal_uLong)pSVEvent;
if ( mpWindowImpl->mpFrame->PostEvent( pSVEvent ) )
return sal_True;
else
{
rEventId = 0;
ImplRemoveDel( &(pSVEvent->maDelData) );
delete pSVEvent;
return sal_False;
}
}
// -----------------------------------------------------------------------
sal_Bool Window::PostUserEvent( sal_uLong& rEventId, const Link& rLink, void* pCaller )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplSVEvent* pSVEvent = new ImplSVEvent;
pSVEvent->mnEvent = 0;
pSVEvent->mpData = pCaller;
pSVEvent->mpLink = new Link( rLink );
pSVEvent->mpWindow = this;
pSVEvent->mbCall = sal_True;
ImplAddDel( &(pSVEvent->maDelData) );
rEventId = (sal_uLong)pSVEvent;
if ( mpWindowImpl->mpFrame->PostEvent( pSVEvent ) )
return sal_True;
else
{
rEventId = 0;
ImplRemoveDel( &(pSVEvent->maDelData) );
delete pSVEvent;
return sal_False;
}
}
// -----------------------------------------------------------------------
void Window::RemoveUserEvent( sal_uLong nUserEvent )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplSVEvent* pSVEvent = (ImplSVEvent*)nUserEvent;
DBG_ASSERT( pSVEvent->mpWindow == this,
"Window::RemoveUserEvent(): Event doesn't send to this window or is already removed" );
DBG_ASSERT( pSVEvent->mbCall,
"Window::RemoveUserEvent(): Event is already removed" );
if ( pSVEvent->mpWindow )
{
pSVEvent->mpWindow->ImplRemoveDel( &(pSVEvent->maDelData) );
pSVEvent->mpWindow = NULL;
}
pSVEvent->mbCall = sal_False;
}
// -----------------------------------------------------------------------
IMPL_LINK( Window, ImplAsyncStateChangedHdl, void*, pState )
{
StateChanged( (StateChangedType)(sal_uLong)pState );
return 0;
}
// -----------------------------------------------------------------------
void Window::PostStateChanged( StateChangedType nState )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
PostUserEvent( LINK( this, Window, ImplAsyncStateChangedHdl ), (void*)(sal_uLong)nState );
}
// -----------------------------------------------------------------------
sal_Bool Window::IsLocked( sal_Bool bChilds ) const
{
if ( mpWindowImpl->mnLockCount != 0 )
return sal_True;
if ( bChilds || mpWindowImpl->mbChildNotify )
{
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
if ( pChild->IsLocked( sal_True ) )
return sal_True;
pChild = pChild->mpWindowImpl->mpNext;
}
}
return sal_False;
}
// -----------------------------------------------------------------------
void Window::SetStyle( WinBits nStyle )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mnStyle != nStyle )
{
mpWindowImpl->mnPrevStyle = mpWindowImpl->mnStyle;
mpWindowImpl->mnStyle = nStyle;
StateChanged( STATE_CHANGE_STYLE );
}
}
// -----------------------------------------------------------------------
void Window::SetExtendedStyle( WinBits nExtendedStyle )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mnExtendedStyle != nExtendedStyle )
{
Window* pWindow = ImplGetBorderWindow();
if( ! pWindow )
pWindow = this;
if( pWindow->mpWindowImpl->mbFrame )
{
SalExtStyle nExt = 0;
if( (nExtendedStyle & WB_EXT_DOCUMENT) )
nExt |= SAL_FRAME_EXT_STYLE_DOCUMENT;
if( (nExtendedStyle & WB_EXT_DOCMODIFIED) )
nExt |= SAL_FRAME_EXT_STYLE_DOCMODIFIED;
pWindow->ImplGetFrame()->SetExtendedFrameStyle( nExt );
}
mpWindowImpl->mnPrevExtendedStyle = mpWindowImpl->mnExtendedStyle;
mpWindowImpl->mnExtendedStyle = nExtendedStyle;
StateChanged( STATE_CHANGE_EXTENDEDSTYLE );
}
}
// -----------------------------------------------------------------------
SystemWindow* Window::GetSystemWindow() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
const Window* pWin = this;
while ( pWin && !pWin->IsSystemWindow() )
pWin = pWin->GetParent();
return (SystemWindow*)pWin;
}
// -----------------------------------------------------------------------
void Window::SetBorderStyle( sal_uInt16 nBorderStyle )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
{
if( nBorderStyle == WINDOW_BORDER_REMOVEBORDER &&
! mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame &&
mpWindowImpl->mpBorderWindow->mpWindowImpl->mpParent
)
{
// this is a little awkward: some controls (e.g. svtools ProgressBar)
// cannot avoid getting constructed with WB_BORDER but want to disable
// borders in case of NWF drawing. So they need a method to remove their border window
Window* pBorderWin = mpWindowImpl->mpBorderWindow;
// remove us as border window's client
pBorderWin->mpWindowImpl->mpClientWindow = NULL;
mpWindowImpl->mpBorderWindow = NULL;
mpWindowImpl->mpRealParent = pBorderWin->mpWindowImpl->mpParent;
// reparent us above the border window
SetParent( pBorderWin->mpWindowImpl->mpParent );
// set us to the position and size of our previous border
Point aBorderPos( pBorderWin->GetPosPixel() );
Size aBorderSize( pBorderWin->GetSizePixel() );
SetPosSizePixel( aBorderPos.X(), aBorderPos.Y(), aBorderSize.Width(), aBorderSize.Height() );
// release border window
delete pBorderWin;
// set new style bits
SetStyle( GetStyle() & (~WB_BORDER) );
}
else
{
if ( mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW )
((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetBorderStyle( nBorderStyle );
else
mpWindowImpl->mpBorderWindow->SetBorderStyle( nBorderStyle );
}
}
}
// -----------------------------------------------------------------------
sal_uInt16 Window::GetBorderStyle() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
{
if ( mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW )
return ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->GetBorderStyle();
else
return mpWindowImpl->mpBorderWindow->GetBorderStyle();
}
return 0;
}
// -----------------------------------------------------------------------
long Window::CalcTitleWidth() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
{
if ( mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW )
return ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->CalcTitleWidth();
else
return mpWindowImpl->mpBorderWindow->CalcTitleWidth();
}
else if ( mpWindowImpl->mbFrame && (mpWindowImpl->mnStyle & WB_MOVEABLE) )
{
// Fuer Frame-Fenster raten wir die Breite, da wir den Border fuer
// externe Dialoge nicht kennen
const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
Font aFont = GetFont();
((Window*)this)->SetPointFont( rStyleSettings.GetTitleFont() );
long nTitleWidth = GetTextWidth( GetText() );
((Window*)this)->SetFont( aFont );
nTitleWidth += rStyleSettings.GetTitleHeight() * 3;
nTitleWidth += rStyleSettings.GetBorderSize() * 2;
nTitleWidth += 10;
return nTitleWidth;
}
return 0;
}
// -----------------------------------------------------------------------
void Window::EnableClipSiblings( sal_Bool bClipSiblings )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->EnableClipSiblings( bClipSiblings );
mpWindowImpl->mbClipSiblings = bClipSiblings;
}
// -----------------------------------------------------------------------
void Window::SetMouseTransparent( sal_Bool bTransparent )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->SetMouseTransparent( bTransparent );
if( mpWindowImpl->mpSysObj )
mpWindowImpl->mpSysObj->SetMouseTransparent( bTransparent );
mpWindowImpl->mbMouseTransparent = bTransparent;
}
// -----------------------------------------------------------------------
void Window::SetPaintTransparent( sal_Bool bTransparent )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
// transparency is not useful for frames as the background would have to be provided by a different frame
if( bTransparent && mpWindowImpl->mbFrame )
return;
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->SetPaintTransparent( bTransparent );
mpWindowImpl->mbPaintTransparent = bTransparent;
}
// -----------------------------------------------------------------------
void Window::SetInputContext( const InputContext& rInputContext )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
mpWindowImpl->maInputContext = rInputContext;
if ( !mpWindowImpl->mbInFocusHdl && HasFocus() )
ImplNewInputContext();
}
// -----------------------------------------------------------------------
void Window::EndExtTextInput( sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mbExtTextInput )
ImplGetFrame()->EndExtTextInput( nFlags );
}
// -----------------------------------------------------------------------
void Window::SetCursorRect( const Rectangle* pRect, long nExtTextInputWidth )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplWinData* pWinData = ImplGetWinData();
if ( pWinData->mpCursorRect )
{
if ( pRect )
*pWinData->mpCursorRect = *pRect;
else
{
delete pWinData->mpCursorRect;
pWinData->mpCursorRect = NULL;
}
}
else
{
if ( pRect )
pWinData->mpCursorRect = new Rectangle( *pRect );
}
pWinData->mnCursorExtWidth = nExtTextInputWidth;
}
// -----------------------------------------------------------------------
const Rectangle* Window::GetCursorRect() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplWinData* pWinData = ImplGetWinData();
return pWinData->mpCursorRect;
}
// -----------------------------------------------------------------------
long Window::GetCursorExtTextInputWidth() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplWinData* pWinData = ImplGetWinData();
return pWinData->mnCursorExtWidth;
}
// -----------------------------------------------------------------------
void Window::SetSettings( const AllSettings& rSettings )
{
SetSettings( rSettings, sal_False );
}
void Window::SetSettings( const AllSettings& rSettings, sal_Bool bChild )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
{
mpWindowImpl->mpBorderWindow->SetSettings( rSettings, sal_False );
if ( (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) &&
((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->mpMenuBarWindow )
((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->mpMenuBarWindow->SetSettings( rSettings, sal_True );
}
AllSettings aOldSettings = maSettings;
OutputDevice::SetSettings( rSettings );
sal_uLong nChangeFlags = aOldSettings.GetChangeFlags( rSettings );
// AppFont-Aufloesung und DPI-Aufloesung neu berechnen
ImplInitResolutionSettings();
if ( nChangeFlags )
{
DataChangedEvent aDCEvt( DATACHANGED_SETTINGS, &aOldSettings, nChangeFlags );
DataChanged( aDCEvt );
}
if ( bChild || mpWindowImpl->mbChildNotify )
{
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->SetSettings( rSettings, bChild );
pChild = pChild->mpWindowImpl->mpNext;
}
}
}
// -----------------------------------------------------------------------
void Window::UpdateSettings( const AllSettings& rSettings, sal_Bool bChild )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
{
mpWindowImpl->mpBorderWindow->UpdateSettings( rSettings, sal_False );
if ( (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) &&
((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->mpMenuBarWindow )
((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->mpMenuBarWindow->UpdateSettings( rSettings, sal_True );
}
AllSettings aOldSettings = maSettings;
sal_uLong nChangeFlags = maSettings.Update( maSettings.GetWindowUpdate(), rSettings );
nChangeFlags |= SETTINGS_IN_UPDATE_SETTINGS; // Set this flag so the receiver of the data changed
// event can distinguish between the changing of global
// setting and a local change ( with SetSettings )
// AppFont-Aufloesung und DPI-Aufloesung neu berechnen
ImplInitResolutionSettings();
/* #i73785#
* do not overwrite a WheelBehavior with false
* this looks kind of a hack, but WheelBehavior
* is always a local change, not a system property,
* so we can spare all our users the hassle of reacting on
* this in their respective DataChanged.
*/
MouseSettings aSet( maSettings.GetMouseSettings() );
aSet.SetWheelBehavior( aOldSettings.GetMouseSettings().GetWheelBehavior() );
maSettings.SetMouseSettings( aSet );
if( (nChangeFlags & SETTINGS_STYLE) && IsBackground() )
{
Wallpaper aWallpaper = GetBackground();
if( !aWallpaper.IsBitmap() && !aWallpaper.IsGradient() )
{
if ( mpWindowImpl->mnStyle & WB_3DLOOK )
SetBackground( Wallpaper( rSettings.GetStyleSettings().GetFaceColor() ) );
else
SetBackground( Wallpaper( rSettings.GetStyleSettings().GetWindowColor() ) );
}
}
if ( nChangeFlags )
{
DataChangedEvent aDCEvt( DATACHANGED_SETTINGS, &aOldSettings, nChangeFlags );
DataChanged( aDCEvt );
// notify data change handler
ImplCallEventListeners( VCLEVENT_WINDOW_DATACHANGED, &aDCEvt);
}
if ( bChild || mpWindowImpl->mbChildNotify )
{
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->UpdateSettings( rSettings, bChild );
pChild = pChild->mpWindowImpl->mpNext;
}
}
}
// -----------------------------------------------------------------------
void Window::NotifyAllChilds( DataChangedEvent& rDCEvt )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
DataChanged( rDCEvt );
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->NotifyAllChilds( rDCEvt );
pChild = pChild->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
void Window::SetPointFont( const Font& rFont )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
Font aFont = rFont;
ImplPointToLogic( aFont );
SetFont( aFont );
}
// -----------------------------------------------------------------------
Font Window::GetPointFont() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
Font aFont = GetFont();
ImplLogicToPoint( aFont );
return aFont;
}
// -----------------------------------------------------------------------
// TODO: remove in next incompatible build
void Window::GetFontResolution( sal_Int32& nDPIX, sal_Int32& nDPIY ) const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
nDPIX = mpWindowImpl->mpFrameData->mnDPIX;
nDPIY = mpWindowImpl->mpFrameData->mnDPIY;
}
// -----------------------------------------------------------------------
void Window::SetParentClipMode( sal_uInt16 nMode )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->SetParentClipMode( nMode );
else
{
if ( !ImplIsOverlapWindow() )
{
mpWindowImpl->mnParentClipMode = nMode;
if ( nMode & PARENTCLIPMODE_CLIP )
mpWindowImpl->mpParent->mpWindowImpl->mbClipChildren = sal_True;
}
}
}
// -----------------------------------------------------------------------
sal_uInt16 Window::GetParentClipMode() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
return mpWindowImpl->mpBorderWindow->GetParentClipMode();
else
return mpWindowImpl->mnParentClipMode;
}
// -----------------------------------------------------------------------
void Window::SetWindowRegionPixel()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->SetWindowRegionPixel();
else if( mpWindowImpl->mbFrame )
{
mpWindowImpl->maWinRegion = Region(true);
mpWindowImpl->mbWinRegion = sal_False;
mpWindowImpl->mpFrame->ResetClipRegion();
}
else
{
if ( mpWindowImpl->mbWinRegion )
{
mpWindowImpl->maWinRegion = Region(true);
mpWindowImpl->mbWinRegion = sal_False;
ImplSetClipFlag();
if ( IsReallyVisible() )
{
// Hintergrund-Sicherung zuruecksetzen
if ( mpWindowImpl->mpOverlapData && mpWindowImpl->mpOverlapData->mpSaveBackDev )
ImplDeleteOverlapBackground();
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
Rectangle aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
Region aRegion( aRect );
ImplInvalidateParentFrameRegion( aRegion );
}
}
}
}
// -----------------------------------------------------------------------
void Window::SetWindowRegionPixel( const Region& rRegion )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->SetWindowRegionPixel( rRegion );
else if( mpWindowImpl->mbFrame )
{
if( !rRegion.IsNull() )
{
mpWindowImpl->maWinRegion = rRegion;
mpWindowImpl->mbWinRegion = ! rRegion.IsEmpty();
if( mpWindowImpl->mbWinRegion )
{
// ClipRegion setzen/updaten
RectangleVector aRectangles;
mpWindowImpl->maWinRegion.GetRegionRectangles(aRectangles);
mpWindowImpl->mpFrame->BeginSetClipRegion(aRectangles.size());
for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++)
{
mpWindowImpl->mpFrame->UnionClipRegion(
aRectIter->Left(),
aRectIter->Top(),
aRectIter->GetWidth(), // orig nWidth was ((R - L) + 1), same as GetWidth does
aRectIter->GetHeight()); // same for height
}
mpWindowImpl->mpFrame->EndSetClipRegion();
//long nX;
//long nY;
//long nWidth;
//long nHeight;
//sal_uLong nRectCount;
//ImplRegionInfo aInfo;
//sal_Bool bRegionRect;
//
//nRectCount = mpWindowImpl->maWinRegion.GetRectCount();
//mpWindowImpl->mpFrame->BeginSetClipRegion( nRectCount );
//bRegionRect = mpWindowImpl->maWinRegion.ImplGetFirstRect( aInfo, nX, nY, nWidth, nHeight );
//while ( bRegionRect )
//{
// mpWindowImpl->mpFrame->UnionClipRegion( nX, nY, nWidth, nHeight );
// bRegionRect = mpWindowImpl->maWinRegion.ImplGetNextRect( aInfo, nX, nY, nWidth, nHeight );
//}
//mpWindowImpl->mpFrame->EndSetClipRegion();
}
else
SetWindowRegionPixel();
}
else
SetWindowRegionPixel();
}
else
{
sal_Bool bInvalidate = sal_False;
if ( rRegion.IsNull() )
{
if ( mpWindowImpl->mbWinRegion )
{
mpWindowImpl->maWinRegion = Region(true);
mpWindowImpl->mbWinRegion = sal_False;
ImplSetClipFlag();
bInvalidate = sal_True;
}
}
else
{
mpWindowImpl->maWinRegion = rRegion;
mpWindowImpl->mbWinRegion = sal_True;
ImplSetClipFlag();
bInvalidate = sal_True;
}
if ( IsReallyVisible() )
{
// Hintergrund-Sicherung zuruecksetzen
if ( mpWindowImpl->mpOverlapData && mpWindowImpl->mpOverlapData->mpSaveBackDev )
ImplDeleteOverlapBackground();
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
Rectangle aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
Region aRegion( aRect );
ImplInvalidateParentFrameRegion( aRegion );
}
}
}
// -----------------------------------------------------------------------
const Region& Window::GetWindowRegionPixel() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
return mpWindowImpl->mpBorderWindow->GetWindowRegionPixel();
else
return mpWindowImpl->maWinRegion;
}
// -----------------------------------------------------------------------
sal_Bool Window::IsWindowRegionPixel() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
return mpWindowImpl->mpBorderWindow->IsWindowRegionPixel();
else
return mpWindowImpl->mbWinRegion;
}
// -----------------------------------------------------------------------
Region Window::GetWindowClipRegionPixel( sal_uInt16 nFlags ) const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
Region aWinClipRegion;
if ( nFlags & WINDOW_GETCLIPREGION_NOCHILDREN )
{
if ( mpWindowImpl->mbInitWinClipRegion )
((Window*)this)->ImplInitWinClipRegion();
aWinClipRegion = mpWindowImpl->maWinClipRegion;
}
else
{
Region* pWinChildClipRegion = ((Window*)this)->ImplGetWinChildClipRegion();
aWinClipRegion = *pWinChildClipRegion;
// --- RTL --- remirror clip region before passing it to somebody
if( ImplIsAntiparallel() )
ImplReMirror( aWinClipRegion );
}
if ( nFlags & WINDOW_GETCLIPREGION_NULL )
{
Rectangle aWinRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
Region aWinRegion( aWinRect );
if ( aWinRegion == aWinClipRegion )
aWinClipRegion.SetNull();
}
aWinClipRegion.Move( -mnOutOffX, -mnOutOffY );
return aWinClipRegion;
}
// -----------------------------------------------------------------------
Region Window::GetPaintRegion() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpPaintRegion )
{
Region aRegion = *mpWindowImpl->mpPaintRegion;
aRegion.Move( -mnOutOffX, -mnOutOffY );
return PixelToLogic( aRegion );
}
else
{
Region aPaintRegion(true);
return aPaintRegion;
}
}
// -----------------------------------------------------------------------
void Window::ExpandPaintClipRegion( const Region& rRegion )
{
if( mpWindowImpl->mpPaintRegion )
{
Region aPixRegion = LogicToPixel( rRegion );
Region aDevPixRegion = ImplPixelToDevicePixel( aPixRegion );
Region aWinChildRegion = *ImplGetWinChildClipRegion();
// --- RTL -- only this region is in frame coordinates, so re-mirror it
if( ImplIsAntiparallel() )
ImplReMirror( aWinChildRegion );
aDevPixRegion.Intersect( aWinChildRegion );
if( ! aDevPixRegion.IsEmpty() )
{
mpWindowImpl->mpPaintRegion->Union( aDevPixRegion );
mbInitClipRegion = sal_True;
}
}
}
// -----------------------------------------------------------------------
static SystemWindow *ImplGetLastSystemWindow( Window *pWin )
{
// get the most top-level system window, the one that contains the taskpanelist
SystemWindow *pSysWin = NULL;
if( !pWin )
return pSysWin;
Window *pMyParent = pWin;
while ( pMyParent )
{
if ( pMyParent->IsSystemWindow() )
pSysWin = (SystemWindow*)pMyParent;
pMyParent = pMyParent->GetParent();
}
return pSysWin;
}
void Window::SetParent( Window* pNewParent )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
DBG_ASSERT( pNewParent, "Window::SetParent(): pParent == NULL" );
DBG_ASSERT( pNewParent != this, "someone tried to reparent a window to itself" );
if( pNewParent == this )
return;
// check if the taskpanelist would change and move the window pointer accordingly
SystemWindow *pSysWin = ImplGetLastSystemWindow(this);
SystemWindow *pNewSysWin = NULL;
sal_Bool bChangeTaskPaneList = sal_False;
if( pSysWin && pSysWin->ImplIsInTaskPaneList( this ) )
{
pNewSysWin = ImplGetLastSystemWindow( pNewParent );
if( pNewSysWin && pNewSysWin != pSysWin )
{
bChangeTaskPaneList = sal_True;
pSysWin->GetTaskPaneList()->RemoveWindow( this );
}
}
// remove ownerdraw decorated windows from list in the top-most frame window
if( (GetStyle() & WB_OWNERDRAWDECORATION) && mpWindowImpl->mbFrame )
{
::std::vector< Window* >& rList = ImplGetOwnerDrawList();
::std::vector< Window* >::iterator p;
p = ::std::find( rList.begin(), rList.end(), this );
if( p != rList.end() )
rList.erase( p );
}
ImplSetFrameParent( pNewParent );
if ( mpWindowImpl->mpBorderWindow )
{
mpWindowImpl->mpRealParent = pNewParent;
mpWindowImpl->mpBorderWindow->SetParent( pNewParent );
return;
}
if ( mpWindowImpl->mpParent == pNewParent )
return;
if ( mpWindowImpl->mbFrame )
mpWindowImpl->mpFrame->SetParent( pNewParent->mpWindowImpl->mpFrame );
sal_Bool bVisible = IsVisible();
Show( sal_False, SHOW_NOFOCUSCHANGE );
// Testen, ob sich das Overlap-Window aendert
Window* pOldOverlapWindow;
Window* pNewOverlapWindow = NULL;
if ( ImplIsOverlapWindow() )
pOldOverlapWindow = NULL;
else
{
pNewOverlapWindow = pNewParent->ImplGetFirstOverlapWindow();
if ( mpWindowImpl->mpOverlapWindow != pNewOverlapWindow )
pOldOverlapWindow = mpWindowImpl->mpOverlapWindow;
else
pOldOverlapWindow = NULL;
}
// Fenster in der Hirachie umsetzen
sal_Bool bFocusOverlapWin = HasChildPathFocus( sal_True );
sal_Bool bFocusWin = HasChildPathFocus();
sal_Bool bNewFrame = pNewParent->mpWindowImpl->mpFrameWindow != mpWindowImpl->mpFrameWindow;
if ( bNewFrame )
{
if ( mpWindowImpl->mpFrameData->mpFocusWin )
{
if ( IsWindowOrChild( mpWindowImpl->mpFrameData->mpFocusWin ) )
mpWindowImpl->mpFrameData->mpFocusWin = NULL;
}
if ( mpWindowImpl->mpFrameData->mpMouseMoveWin )
{
if ( IsWindowOrChild( mpWindowImpl->mpFrameData->mpMouseMoveWin ) )
mpWindowImpl->mpFrameData->mpMouseMoveWin = NULL;
}
if ( mpWindowImpl->mpFrameData->mpMouseDownWin )
{
if ( IsWindowOrChild( mpWindowImpl->mpFrameData->mpMouseDownWin ) )
mpWindowImpl->mpFrameData->mpMouseDownWin = NULL;
}
}
ImplRemoveWindow( bNewFrame );
ImplInsertWindow( pNewParent );
if ( mpWindowImpl->mnParentClipMode & PARENTCLIPMODE_CLIP )
pNewParent->mpWindowImpl->mbClipChildren = sal_True;
ImplUpdateWindowPtr();
if ( ImplUpdatePos() )
ImplUpdateSysObjPos();
// Wenn sich das Overlap-Window geaendert hat, dann muss getestet werden,
// ob auch OverlapWindow die das Child-Fenster als Parent gehabt haben
// in der Window-Hirachie umgesetzt werden muessen
if ( ImplIsOverlapWindow() )
{
if ( bNewFrame )
{
Window* pOverlapWindow = mpWindowImpl->mpFirstOverlap;
while ( pOverlapWindow )
{
Window* pNextOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
pOverlapWindow->ImplUpdateOverlapWindowPtr( bNewFrame );
pOverlapWindow = pNextOverlapWindow;
}
}
}
else if ( pOldOverlapWindow )
{
// Focus-Save zuruecksetzen
if ( bFocusWin ||
(pOldOverlapWindow->mpWindowImpl->mpLastFocusWindow &&
IsWindowOrChild( pOldOverlapWindow->mpWindowImpl->mpLastFocusWindow )) )
pOldOverlapWindow->mpWindowImpl->mpLastFocusWindow = NULL;
Window* pOverlapWindow = pOldOverlapWindow->mpWindowImpl->mpFirstOverlap;
while ( pOverlapWindow )
{
Window* pNextOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
if ( ImplIsRealParentPath( pOverlapWindow->ImplGetWindow() ) )
pOverlapWindow->ImplUpdateOverlapWindowPtr( bNewFrame );
pOverlapWindow = pNextOverlapWindow;
}
// Activate-Status beim naechsten Overlap-Window updaten
if ( HasChildPathFocus( sal_True ) )
ImplCallFocusChangeActivate( pNewOverlapWindow, pOldOverlapWindow );
}
// Activate-Status mit umsetzen
if ( bNewFrame )
{
if ( (GetType() == WINDOW_BORDERWINDOW) &&
(ImplGetWindow()->GetType() == WINDOW_FLOATINGWINDOW) )
((ImplBorderWindow*)this)->SetDisplayActive( mpWindowImpl->mpFrameData->mbHasFocus );
}
// Focus evtl. auf den neuen Frame umsetzen, wenn FocusWindow mit
// SetParent() umgesetzt wird
if ( bFocusOverlapWin )
{
mpWindowImpl->mpFrameData->mpFocusWin = Application::GetFocusWindow();
if ( !mpWindowImpl->mpFrameData->mbHasFocus )
{
mpWindowImpl->mpFrame->ToTop( 0 );
}
}
// Assure DragSource and DropTarget members are created
if ( bNewFrame )
{
GetDropTarget();
}
if( bChangeTaskPaneList )
pNewSysWin->GetTaskPaneList()->AddWindow( this );
if( (GetStyle() & WB_OWNERDRAWDECORATION) && mpWindowImpl->mbFrame )
ImplGetOwnerDrawList().push_back( this );
if ( bVisible )
Show( sal_True, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
}
// -----------------------------------------------------------------------
void Window::Show( sal_Bool bVisible, sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mbVisible == bVisible )
return;
ImplDelData aDogTag( this );
sal_Bool bRealVisibilityChanged = sal_False;
mpWindowImpl->mbVisible = (bVisible != 0);
if ( !bVisible )
{
ImplHideAllOverlaps();
if( aDogTag.IsDelete() )
return;
if ( mpWindowImpl->mpBorderWindow )
{
sal_Bool bOldUpdate = mpWindowImpl->mpBorderWindow->mpWindowImpl->mbNoParentUpdate;
if ( mpWindowImpl->mbNoParentUpdate )
mpWindowImpl->mpBorderWindow->mpWindowImpl->mbNoParentUpdate = sal_True;
mpWindowImpl->mpBorderWindow->Show( sal_False, nFlags );
mpWindowImpl->mpBorderWindow->mpWindowImpl->mbNoParentUpdate = bOldUpdate;
}
else if ( mpWindowImpl->mbFrame )
{
mpWindowImpl->mbSuppressAccessibilityEvents = sal_True;
mpWindowImpl->mpFrame->Show( sal_False, sal_False );
}
StateChanged( STATE_CHANGE_VISIBLE );
if ( mpWindowImpl->mbReallyVisible )
{
Region aInvRegion;
sal_Bool bSaveBack = sal_False;
if ( ImplIsOverlapWindow() && !mpWindowImpl->mbFrame )
{
if ( ImplRestoreOverlapBackground( aInvRegion ) )
bSaveBack = sal_True;
}
if ( !bSaveBack )
{
if ( mpWindowImpl->mbInitWinClipRegion )
ImplInitWinClipRegion();
aInvRegion = mpWindowImpl->maWinClipRegion;
}
if( aDogTag.IsDelete() )
return;
bRealVisibilityChanged = mpWindowImpl->mbReallyVisible;
ImplResetReallyVisible();
ImplSetClipFlag();
if ( ImplIsOverlapWindow() && !mpWindowImpl->mbFrame )
{
// Focus umsetzen
if ( !(nFlags & SHOW_NOFOCUSCHANGE) && HasChildPathFocus() )
{
if ( mpWindowImpl->mpOverlapWindow->IsEnabled() &&
mpWindowImpl->mpOverlapWindow->IsInputEnabled() &&
! mpWindowImpl->mpOverlapWindow->IsInModalMode()
)
mpWindowImpl->mpOverlapWindow->GrabFocus();
}
}
if ( !mpWindowImpl->mbFrame )
{
if( mpWindowImpl->mpWinData && mpWindowImpl->mpWinData->mbEnableNativeWidget )
{
/*
* #i48371# native theming: some themes draw outside the control
* area we tell them to (bad thing, but we cannot do much about it ).
* On hiding these controls they get invalidated with their window rectangle
* which leads to the parts outside the control area being left and not
* invalidated. Workaround: invalidate an area on the parent, too
*/
const int workaround_border = 5;
Rectangle aBounds( aInvRegion.GetBoundRect() );
aBounds.Left() -= workaround_border;
aBounds.Top() -= workaround_border;
aBounds.Right() += workaround_border;
aBounds.Bottom() += workaround_border;
aInvRegion = aBounds;
}
if ( !mpWindowImpl->mbNoParentUpdate && !(nFlags & SHOW_NOPARENTUPDATE) )
{
if ( !aInvRegion.IsEmpty() )
ImplInvalidateParentFrameRegion( aInvRegion );
}
ImplGenerateMouseMove();
}
}
}
else
{
// inherit native widget flag for form controls
// required here, because frames never show up in the child hierarchy - which should be fixed....
// eg, the drop down of a combobox which is a system floating window
if( mpWindowImpl->mbFrame && GetParent() && GetParent()->IsCompoundControl() &&
GetParent()->IsNativeWidgetEnabled() != IsNativeWidgetEnabled() )
EnableNativeWidget( GetParent()->IsNativeWidgetEnabled() );
if ( mpWindowImpl->mbCallMove )
{
ImplCallMove();
}
if ( mpWindowImpl->mbCallResize )
{
ImplCallResize();
}
StateChanged( STATE_CHANGE_VISIBLE );
Window* pTestParent;
if ( ImplIsOverlapWindow() )
pTestParent = mpWindowImpl->mpOverlapWindow;
else
pTestParent = ImplGetParent();
if ( mpWindowImpl->mbFrame || pTestParent->mpWindowImpl->mbReallyVisible )
{
// Wenn ein Window gerade sichtbar wird, schicken wir allen
// Child-Fenstern ein StateChanged, damit diese sich
// initialisieren koennen
ImplCallInitShow();
// Wenn es ein SystemWindow ist, dann kommt es auch automatisch
// nach vorne, wenn es gewuenscht ist
if ( ImplIsOverlapWindow() && !(nFlags & SHOW_NOACTIVATE) )
{
ImplStartToTop(( nFlags & SHOW_FOREGROUNDTASK ) ? TOTOP_FOREGROUNDTASK : 0 );
ImplFocusToTop( 0, sal_False );
}
// Hintergrund sichern
if ( mpWindowImpl->mpOverlapData && mpWindowImpl->mpOverlapData->mbSaveBack )
ImplSaveOverlapBackground();
// adjust mpWindowImpl->mbReallyVisible
bRealVisibilityChanged = !mpWindowImpl->mbReallyVisible;
ImplSetReallyVisible();
// Dafuer sorgen, das Clip-Rechtecke neu berechnet werden
ImplSetClipFlag();
if ( !mpWindowImpl->mbFrame )
{
sal_uInt16 nInvalidateFlags = INVALIDATE_CHILDREN;
if( ! IsPaintTransparent() )
nInvalidateFlags |= INVALIDATE_NOTRANSPARENT;
ImplInvalidate( NULL, nInvalidateFlags );
ImplGenerateMouseMove();
}
}
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->Show( sal_True, nFlags );
else if ( mpWindowImpl->mbFrame )
{
ImplSVData* pSVData = ImplGetSVData();
// #106431#, hide SplashScreen
if( pSVData->mpIntroWindow && !ImplIsWindowOrChild( pSVData->mpIntroWindow ) )
pSVData->mpIntroWindow->Hide();
//DBG_ASSERT( !mpWindowImpl->mbSuppressAccessibilityEvents, "Window::Show() - Frame reactivated");
mpWindowImpl->mbSuppressAccessibilityEvents = sal_False;
mpWindowImpl->mbPaintFrame = sal_True;
sal_Bool bNoActivate = (nFlags & (SHOW_NOACTIVATE|SHOW_NOFOCUSCHANGE)) ? sal_True : sal_False;
mpWindowImpl->mpFrame->Show( sal_True, bNoActivate );
if( aDogTag.IsDelete() )
return;
// Query the correct size of the window, if we are waiting for
// a system resize
if ( mpWindowImpl->mbWaitSystemResize )
{
long nOutWidth;
long nOutHeight;
mpWindowImpl->mpFrame->GetClientSize( nOutWidth, nOutHeight );
ImplHandleResize( this, nOutWidth, nOutHeight );
}
}
if( aDogTag.IsDelete() )
return;
#ifdef DBG_UTIL
if ( IsDialog() || (GetType() == WINDOW_TABPAGE) || (GetType() == WINDOW_DOCKINGWINDOW) )
{
DBG_DIALOGTEST( this );
}
#endif
ImplShowAllOverlaps();
}
if( aDogTag.IsDelete() )
return;
// invalidate all saved backgrounds
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
// the SHOW/HIDE events also serve as indicators to send child creation/destroy events to the access bridge
// However, the access bridge only uses this event if the data member is not NULL (it's kind of a hack that
// we re-use the SHOW/HIDE events this way, with this particular semantics).
// Since #104887#, the notifications for the access bridge are done in Impl(Set|Reset)ReallyVisible. Here, we
// now only notify with a NULL data pointer, for all other clients except the access bridge.
if ( !bRealVisibilityChanged )
ImplCallEventListeners( mpWindowImpl->mbVisible ? VCLEVENT_WINDOW_SHOW : VCLEVENT_WINDOW_HIDE, NULL );
if( aDogTag.IsDelete() )
return;
// #107575#, if a floating windows is shown that grabs the focus, we have to notify the toolkit about it
// ImplGrabFocus() is not called in this case
// Because this might lead to problems the task will be shifted to 6.y
// Note: top-level context menues are registered at the access bridge after being shown,
// so this will probably not help here....
/*
if( mpWindowImpl->mbFloatWin && ((FloatingWindow*) this )->GrabsFocus() )
{
ImplSVData* pSVData = ImplGetSVData();
if( !mpWindowImpl->mbVisible )
{
ImplCallEventListeners( VCLEVENT_WINDOW_LOSEFOCUS );
if( pSVData->maWinData.mpFocusWin )
pSVData->maWinData.mpFocusWin->ImplCallEventListeners( VCLEVENT_WINDOW_GETFOCUS );
}
else
{
if( pSVData->maWinData.mpFocusWin )
pSVData->maWinData.mpFocusWin->ImplCallEventListeners( VCLEVENT_WINDOW_LOSEFOCUS );
ImplCallEventListeners( VCLEVENT_WINDOW_GETFOCUS );
}
}
*/
}
// -----------------------------------------------------------------------
Size Window::GetSizePixel() const
{
// #i43257# trigger pending resize handler to assure correct window sizes
if( mpWindowImpl->mpFrameData->maResizeTimer.IsActive() )
{
ImplDelData aDogtag( this );
mpWindowImpl->mpFrameData->maResizeTimer.Stop();
mpWindowImpl->mpFrameData->maResizeTimer.GetTimeoutHdl().Call( NULL );
if( aDogtag.IsDelete() )
return Size(0,0);
}
return Size( mnOutWidth+mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder,
mnOutHeight+mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder );
}
void Window::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
{
rLeftBorder = mpWindowImpl->mnLeftBorder;
rTopBorder = mpWindowImpl->mnTopBorder;
rRightBorder = mpWindowImpl->mnRightBorder;
rBottomBorder = mpWindowImpl->mnBottomBorder;
}
// -----------------------------------------------------------------------
void Window::Enable( bool bEnable, bool bChild )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( !bEnable )
{
// Wenn ein Fenster disablte wird, wird automatisch der Tracking-Modus
// beendet oder der Capture geklaut
if ( IsTracking() )
EndTracking( ENDTRACK_CANCEL );
if ( IsMouseCaptured() )
ReleaseMouse();
// Wenn Fenster den Focus hat und in der Dialog-Steuerung enthalten,
// wird versucht, den Focus auf das naechste Control weiterzuschalten
// mpWindowImpl->mbDisabled darf erst nach Aufruf von ImplDlgCtrlNextWindow() gesetzt
// werden. Ansonsten muss ImplDlgCtrlNextWindow() umgestellt werden
if ( HasFocus() )
ImplDlgCtrlNextWindow();
}
if ( mpWindowImpl->mpBorderWindow )
{
mpWindowImpl->mpBorderWindow->Enable( bEnable, sal_False );
if ( (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) &&
((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->mpMenuBarWindow )
((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->mpMenuBarWindow->Enable( bEnable, sal_True );
}
// #i56102# restore app focus win in case the
// window was disabled when the frame focus changed
ImplSVData* pSVData = ImplGetSVData();
if( bEnable &&
pSVData->maWinData.mpFocusWin == NULL &&
mpWindowImpl->mpFrameData->mbHasFocus &&
mpWindowImpl->mpFrameData->mpFocusWin == this )
pSVData->maWinData.mpFocusWin = this;
if ( mpWindowImpl->mbDisabled != !bEnable )
{
mpWindowImpl->mbDisabled = !bEnable;
if ( mpWindowImpl->mpSysObj )
mpWindowImpl->mpSysObj->Enable( bEnable && !mpWindowImpl->mbInputDisabled );
// if ( mpWindowImpl->mbFrame )
// mpWindowImpl->mpFrame->Enable( bEnable && !mpWindowImpl->mbInputDisabled );
StateChanged( STATE_CHANGE_ENABLE );
ImplCallEventListeners( bEnable ? VCLEVENT_WINDOW_ENABLED : VCLEVENT_WINDOW_DISABLED );
}
if ( bChild || mpWindowImpl->mbChildNotify )
{
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->Enable( bEnable, bChild );
pChild = pChild->mpWindowImpl->mpNext;
}
}
if ( IsReallyVisible() )
ImplGenerateMouseMove();
}
// -----------------------------------------------------------------------
void Window::SetCallHandlersOnInputDisabled( bool bCall )
{
mpWindowImpl->mbCallHandlersDuringInputDisabled = bCall ? sal_True : sal_False;
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->SetCallHandlersOnInputDisabled( bCall );
pChild = pChild->mpWindowImpl->mpNext;
}
}
// -----------------------------------------------------------------------
bool Window::IsCallHandlersOnInputDisabled() const
{
return mpWindowImpl->mbCallHandlersDuringInputDisabled ? true : false;
}
// -----------------------------------------------------------------------
void Window::EnableInput( sal_Bool bEnable, sal_Bool bChild )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
sal_Bool bNotify = (bEnable != mpWindowImpl->mbInputDisabled);
if ( mpWindowImpl->mpBorderWindow )
{
mpWindowImpl->mpBorderWindow->EnableInput( bEnable, sal_False );
if ( (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) &&
((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->mpMenuBarWindow )
((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->mpMenuBarWindow->EnableInput( bEnable, sal_True );
}
if ( (! bEnable && mpWindowImpl->meAlwaysInputMode != AlwaysInputEnabled) ||
( bEnable && mpWindowImpl->meAlwaysInputMode != AlwaysInputDisabled) )
{
// Wenn ein Fenster disablte wird, wird automatisch der
// Tracking-Modus beendet oder der Capture geklaut
if ( !bEnable )
{
if ( IsTracking() )
EndTracking( ENDTRACK_CANCEL );
if ( IsMouseCaptured() )
ReleaseMouse();
}
if ( mpWindowImpl->mbInputDisabled != !bEnable )
{
mpWindowImpl->mbInputDisabled = !bEnable;
if ( mpWindowImpl->mpSysObj )
mpWindowImpl->mpSysObj->Enable( !mpWindowImpl->mbDisabled && bEnable );
// if ( mpWindowImpl->mbFrame )
// mpWindowImpl->mpFrame->Enable( !mpWindowImpl->mbDisabled && bEnable );
}
}
// #i56102# restore app focus win in case the
// window was disabled when the frame focus changed
ImplSVData* pSVData = ImplGetSVData();
if( bEnable &&
pSVData->maWinData.mpFocusWin == NULL &&
mpWindowImpl->mpFrameData->mbHasFocus &&
mpWindowImpl->mpFrameData->mpFocusWin == this )
pSVData->maWinData.mpFocusWin = this;
if ( bChild || mpWindowImpl->mbChildNotify )
{
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->EnableInput( bEnable, bChild );
pChild = pChild->mpWindowImpl->mpNext;
}
}
if ( IsReallyVisible() )
ImplGenerateMouseMove();
// #104827# notify parent
if ( bNotify )
{
NotifyEvent aNEvt( bEnable ? EVENT_INPUTENABLE : EVENT_INPUTDISABLE, this );
Notify( aNEvt );
}
}
// -----------------------------------------------------------------------
void Window::EnableInput( sal_Bool bEnable, sal_Bool bChild, sal_Bool bSysWin,
const Window* pExcludeWindow )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
EnableInput( bEnable, bChild );
if ( bSysWin )
{
// pExculeWindow is the first Overlap-Frame --> if this
// shouldn't be the case, than this must be changed in dialog.cxx
if( pExcludeWindow )
pExcludeWindow = pExcludeWindow->ImplGetFirstOverlapWindow();
Window* pSysWin = mpWindowImpl->mpFrameWindow->mpWindowImpl->mpFrameData->mpFirstOverlap;
while ( pSysWin )
{
// Is Window in the path from this window
if ( ImplGetFirstOverlapWindow()->ImplIsWindowOrChild( pSysWin, sal_True ) )
{
// Is Window not in the exclude window path or not the
// exclude window, than change the status
if ( !pExcludeWindow || !pExcludeWindow->ImplIsWindowOrChild( pSysWin, sal_True ) )
pSysWin->EnableInput( bEnable, bChild );
}
pSysWin = pSysWin->mpWindowImpl->mpNextOverlap;
}
// enable/disable floating system windows as well
Window* pFrameWin = ImplGetSVData()->maWinData.mpFirstFrame;
while ( pFrameWin )
{
if( pFrameWin->ImplIsFloatingWindow() )
{
// Is Window in the path from this window
if ( ImplGetFirstOverlapWindow()->ImplIsWindowOrChild( pFrameWin, sal_True ) )
{
// Is Window not in the exclude window path or not the
// exclude window, than change the status
if ( !pExcludeWindow || !pExcludeWindow->ImplIsWindowOrChild( pFrameWin, sal_True ) )
pFrameWin->EnableInput( bEnable, bChild );
}
}
pFrameWin = pFrameWin->mpWindowImpl->mpFrameData->mpNextFrame;
}
// the same for ownerdraw floating windows
if( mpWindowImpl->mbFrame )
{
::std::vector< Window* >& rList = mpWindowImpl->mpFrameData->maOwnerDrawList;
::std::vector< Window* >::iterator p = rList.begin();
while( p != rList.end() )
{
// Is Window in the path from this window
if ( ImplGetFirstOverlapWindow()->ImplIsWindowOrChild( (*p), sal_True ) )
{
// Is Window not in the exclude window path or not the
// exclude window, than change the status
if ( !pExcludeWindow || !pExcludeWindow->ImplIsWindowOrChild( (*p), sal_True ) )
(*p)->EnableInput( bEnable, bChild );
}
p++;
}
}
}
}
// -----------------------------------------------------------------------
void Window::AlwaysEnableInput( sal_Bool bAlways, sal_Bool bChild )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->AlwaysEnableInput( bAlways, sal_False );
if( bAlways && mpWindowImpl->meAlwaysInputMode != AlwaysInputEnabled )
{
mpWindowImpl->meAlwaysInputMode = AlwaysInputEnabled;
if ( bAlways )
EnableInput( sal_True, sal_False );
}
else if( ! bAlways && mpWindowImpl->meAlwaysInputMode == AlwaysInputEnabled )
{
mpWindowImpl->meAlwaysInputMode = AlwaysInputNone;
}
if ( bChild || mpWindowImpl->mbChildNotify )
{
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->AlwaysEnableInput( bAlways, bChild );
pChild = pChild->mpWindowImpl->mpNext;
}
}
}
// -----------------------------------------------------------------------
void Window::AlwaysDisableInput( sal_Bool bAlways, sal_Bool bChild )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->AlwaysDisableInput( bAlways, sal_False );
if( bAlways && mpWindowImpl->meAlwaysInputMode != AlwaysInputDisabled )
{
mpWindowImpl->meAlwaysInputMode = AlwaysInputDisabled;
if ( bAlways )
EnableInput( sal_False, sal_False );
}
else if( ! bAlways && mpWindowImpl->meAlwaysInputMode == AlwaysInputDisabled )
{
mpWindowImpl->meAlwaysInputMode = AlwaysInputNone;
}
if ( bChild || mpWindowImpl->mbChildNotify )
{
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
pChild->AlwaysDisableInput( bAlways, bChild );
pChild = pChild->mpWindowImpl->mpNext;
}
}
}
// -----------------------------------------------------------------------
void Window::SetActivateMode( sal_uInt16 nMode )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->SetActivateMode( nMode );
if ( mpWindowImpl->mnActivateMode != nMode )
{
mpWindowImpl->mnActivateMode = nMode;
// Evtl. ein Decativate/Activate ausloesen
if ( mpWindowImpl->mnActivateMode )
{
if ( (mpWindowImpl->mbActive || (GetType() == WINDOW_BORDERWINDOW)) &&
!HasChildPathFocus( sal_True ) )
{
mpWindowImpl->mbActive = sal_False;
Deactivate();
}
}
else
{
if ( !mpWindowImpl->mbActive || (GetType() == WINDOW_BORDERWINDOW) )
{
mpWindowImpl->mbActive = sal_True;
Activate();
}
}
}
}
// -----------------------------------------------------------------------
void Window::ToTop( sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplStartToTop( nFlags );
ImplFocusToTop( nFlags, IsReallyVisible() );
}
// -----------------------------------------------------------------------
void Window::SetZOrder( Window* pRefWindow, sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
{
mpWindowImpl->mpBorderWindow->SetZOrder( pRefWindow, nFlags );
return;
}
if ( nFlags & WINDOW_ZORDER_FIRST )
{
if ( ImplIsOverlapWindow() )
pRefWindow = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
else
pRefWindow = mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild;
nFlags |= WINDOW_ZORDER_BEFOR;
}
else if ( nFlags & WINDOW_ZORDER_LAST )
{
if ( ImplIsOverlapWindow() )
pRefWindow = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap;
else
pRefWindow = mpWindowImpl->mpParent->mpWindowImpl->mpLastChild;
nFlags |= WINDOW_ZORDER_BEHIND;
}
while ( pRefWindow->mpWindowImpl->mpBorderWindow )
pRefWindow = pRefWindow->mpWindowImpl->mpBorderWindow;
if ( (pRefWindow == this) || mpWindowImpl->mbFrame )
return;
DBG_ASSERT( pRefWindow->mpWindowImpl->mpParent == mpWindowImpl->mpParent, "Window::SetZOrder() - pRefWindow has other parent" );
if ( nFlags & WINDOW_ZORDER_BEFOR )
{
if ( pRefWindow->mpWindowImpl->mpPrev == this )
return;
if ( ImplIsOverlapWindow() )
{
if ( mpWindowImpl->mpPrev )
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
else
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = mpWindowImpl->mpNext;
if ( mpWindowImpl->mpNext )
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
else
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = mpWindowImpl->mpPrev;
if ( !pRefWindow->mpWindowImpl->mpPrev )
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = this;
}
else
{
if ( mpWindowImpl->mpPrev )
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
else
mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = mpWindowImpl->mpNext;
if ( mpWindowImpl->mpNext )
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
else
mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = mpWindowImpl->mpPrev;
if ( !pRefWindow->mpWindowImpl->mpPrev )
mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = this;
}
mpWindowImpl->mpPrev = pRefWindow->mpWindowImpl->mpPrev;
mpWindowImpl->mpNext = pRefWindow;
if ( mpWindowImpl->mpPrev )
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = this;
}
else if ( nFlags & WINDOW_ZORDER_BEHIND )
{
if ( pRefWindow->mpWindowImpl->mpNext == this )
return;
if ( ImplIsOverlapWindow() )
{
if ( mpWindowImpl->mpPrev )
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
else
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = mpWindowImpl->mpNext;
if ( mpWindowImpl->mpNext )
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
else
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = mpWindowImpl->mpPrev;
if ( !pRefWindow->mpWindowImpl->mpNext )
mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = this;
}
else
{
if ( mpWindowImpl->mpPrev )
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
else
mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = mpWindowImpl->mpNext;
if ( mpWindowImpl->mpNext )
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
else
mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = mpWindowImpl->mpPrev;
if ( !pRefWindow->mpWindowImpl->mpNext )
mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = this;
}
mpWindowImpl->mpPrev = pRefWindow;
mpWindowImpl->mpNext = pRefWindow->mpWindowImpl->mpNext;
if ( mpWindowImpl->mpNext )
mpWindowImpl->mpNext->mpWindowImpl->mpPrev = this;
mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
}
if ( IsReallyVisible() )
{
// Hintergrund-Sicherung zuruecksetzen
if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
ImplInvalidateAllOverlapBackgrounds();
if ( mpWindowImpl->mbInitWinClipRegion || !mpWindowImpl->maWinClipRegion.IsEmpty() )
{
sal_Bool bInitWinClipRegion = mpWindowImpl->mbInitWinClipRegion;
ImplSetClipFlag();
// Wenn ClipRegion noch nicht initalisiert wurde, dann
// gehen wir davon aus, das das Fenster noch nicht
// ausgegeben wurde und loesen somit auch keine
// Invalidates aus. Dies ist eine Optimierung fuer
// HTML-Dokumenten mit vielen Controls. Wenn es mal
// Probleme mit dieser Abfrage gibt, sollte man ein
// Flag einfuehren, ob das Fenster nach Show schon
// einmal ausgegeben wurde.
if ( !bInitWinClipRegion )
{
// Alle nebeneinanderliegen Fenster invalidieren
// Noch nicht komplett implementiert !!!
Rectangle aWinRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
Window* pWindow = NULL;
if ( ImplIsOverlapWindow() )
{
if ( mpWindowImpl->mpOverlapWindow )
pWindow = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
}
else
pWindow = ImplGetParent()->mpWindowImpl->mpFirstChild;
// Alle Fenster, die vor uns liegen und von uns verdeckt wurden,
// invalidieren
while ( pWindow )
{
if ( pWindow == this )
break;
Rectangle aCompRect( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ),
Size( pWindow->mnOutWidth, pWindow->mnOutHeight ) );
if ( aWinRect.IsOver( aCompRect ) )
pWindow->Invalidate( INVALIDATE_CHILDREN | INVALIDATE_NOTRANSPARENT );
pWindow = pWindow->mpWindowImpl->mpNext;
}
// Wenn uns ein Fenster welches im Hinterund liegt verdeckt hat,
// dann muessen wir uns neu ausgeben
while ( pWindow )
{
if ( pWindow != this )
{
Rectangle aCompRect( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ),
Size( pWindow->mnOutWidth, pWindow->mnOutHeight ) );
if ( aWinRect.IsOver( aCompRect ) )
{
Invalidate( INVALIDATE_CHILDREN | INVALIDATE_NOTRANSPARENT );
break;
}
}
pWindow = pWindow->mpWindowImpl->mpNext;
}
}
}
}
}
// -----------------------------------------------------------------------
void Window::EnableAlwaysOnTop( sal_Bool bEnable )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
mpWindowImpl->mbAlwaysOnTop = bEnable;
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->EnableAlwaysOnTop( bEnable );
else if ( bEnable && IsReallyVisible() )
ToTop();
if ( mpWindowImpl->mbFrame )
mpWindowImpl->mpFrame->SetAlwaysOnTop( bEnable );
}
// -----------------------------------------------------------------------
void Window::SetPosSizePixel( long nX, long nY,
long nWidth, long nHeight, sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
sal_Bool bHasValidSize = !mpWindowImpl->mbDefSize;
if ( nFlags & WINDOW_POSSIZE_POS )
mpWindowImpl->mbDefPos = sal_False;
if ( nFlags & WINDOW_POSSIZE_SIZE )
mpWindowImpl->mbDefSize = sal_False;
// Oberstes BorderWindow ist das Window, welches positioniert werden soll
Window* pWindow = this;
while ( pWindow->mpWindowImpl->mpBorderWindow )
pWindow = pWindow->mpWindowImpl->mpBorderWindow;
if ( pWindow->mpWindowImpl->mbFrame )
{
// Note: if we're positioning a frame, the coordinates are interpreted
// as being the top-left corner of the window's client area and NOT
// as the position of the border ! (due to limitations of several UNIX window managers)
long nOldWidth = pWindow->mnOutWidth;
if ( !(nFlags & WINDOW_POSSIZE_WIDTH) )
nWidth = pWindow->mnOutWidth;
if ( !(nFlags & WINDOW_POSSIZE_HEIGHT) )
nHeight = pWindow->mnOutHeight;
sal_uInt16 nSysFlags=0;
if( nFlags & WINDOW_POSSIZE_WIDTH )
nSysFlags |= SAL_FRAME_POSSIZE_WIDTH;
if( nFlags & WINDOW_POSSIZE_HEIGHT )
nSysFlags |= SAL_FRAME_POSSIZE_HEIGHT;
if( nFlags & WINDOW_POSSIZE_X )
{
nSysFlags |= SAL_FRAME_POSSIZE_X;
if( pWindow->GetParent() && (pWindow->GetStyle() & WB_SYSTEMCHILDWINDOW) )
{
Window* pParent = pWindow->GetParent();
nX += pParent->mnOutOffX;
}
if( GetParent() && GetParent()->ImplIsAntiparallel() )
{
// --- RTL --- (re-mirror at parent window)
Rectangle aRect( Point ( nX, nY ), Size( nWidth, nHeight ) );
GetParent()->ImplReMirror( aRect );
nX = aRect.nLeft;
}
}
if( !(nFlags & WINDOW_POSSIZE_X) && bHasValidSize && pWindow->mpWindowImpl->mpFrame->maGeometry.nWidth )
{
// --- RTL --- make sure the old right aligned position is not changed
// system windows will always grow to the right
if( pWindow->GetParent() && pWindow->GetParent()->ImplHasMirroredGraphics() )
{
long myWidth = nOldWidth;
if( !myWidth )
myWidth = mpWindowImpl->mpFrame->GetUnmirroredGeometry().nWidth;
if( !myWidth )
myWidth = nWidth;
nFlags |= WINDOW_POSSIZE_X;
nSysFlags |= SAL_FRAME_POSSIZE_X;
nX = mpWindowImpl->mpFrame->GetUnmirroredGeometry().nX - pWindow->GetParent()->mpWindowImpl->mpFrame->GetUnmirroredGeometry().nX -
mpWindowImpl->mpFrame->GetUnmirroredGeometry().nLeftDecoration;
nX = pWindow->GetParent()->mpWindowImpl->mpFrame->GetUnmirroredGeometry().nX - mpWindowImpl->mpFrame->GetUnmirroredGeometry().nLeftDecoration +
pWindow->GetParent()->mpWindowImpl->mpFrame->GetUnmirroredGeometry().nWidth - myWidth - 1 - mpWindowImpl->mpFrame->GetUnmirroredGeometry().nX;
if(!(nFlags & WINDOW_POSSIZE_Y))
{
nFlags |= WINDOW_POSSIZE_Y;
nSysFlags |= SAL_FRAME_POSSIZE_Y;
nY = mpWindowImpl->mpFrame->GetUnmirroredGeometry().nY - pWindow->GetParent()->mpWindowImpl->mpFrame->GetUnmirroredGeometry().nY -
mpWindowImpl->mpFrame->GetUnmirroredGeometry().nTopDecoration;
}
}
}
if( nFlags & WINDOW_POSSIZE_Y )
{
nSysFlags |= SAL_FRAME_POSSIZE_Y;
if( pWindow->GetParent() && (pWindow->GetStyle() & WB_SYSTEMCHILDWINDOW) )
{
Window* pParent = pWindow->GetParent();
nY += pParent->mnOutOffY;
}
}
if( nSysFlags & (SAL_FRAME_POSSIZE_WIDTH|SAL_FRAME_POSSIZE_HEIGHT) )
{
// check for min/max client size and adjust size accordingly
// otherwise it may happen that the resize event is ignored, i.e. the old size remains
// unchanged but ImplHandleResize() is called with the wrong size
SystemWindow *pSystemWindow = dynamic_cast< SystemWindow* >( pWindow );
if( pSystemWindow )
{
Size aMinSize = pSystemWindow->GetMinOutputSizePixel();
Size aMaxSize = pSystemWindow->GetMaxOutputSizePixel();
if( nWidth < aMinSize.Width() )
nWidth = aMinSize.Width();
if( nHeight < aMinSize.Height() )
nHeight = aMinSize.Height();
if( nWidth > aMaxSize.Width() )
nWidth = aMaxSize.Width();
if( nHeight > aMaxSize.Height() )
nHeight = aMaxSize.Height();
}
}
pWindow->mpWindowImpl->mpFrame->SetPosSize( nX, nY, nWidth, nHeight, nSysFlags );
// Resize should be called directly. If we havn't
// set the correct size, we get a second resize from
// the system with the correct size. This can be happend
// if the size is to small or to large.
ImplHandleResize( pWindow, nWidth, nHeight );
}
else
{
pWindow->ImplPosSizeWindow( nX, nY, nWidth, nHeight, nFlags );
if ( IsReallyVisible() )
ImplGenerateMouseMove();
}
}
// -----------------------------------------------------------------------
Point Window::GetPosPixel() const
{
return mpWindowImpl->maPos;
}
// -----------------------------------------------------------------------
Rectangle Window::GetDesktopRectPixel() const
{
Rectangle rRect;
mpWindowImpl->mpFrameWindow->mpWindowImpl->mpFrame->GetWorkArea( rRect );
return rRect;
}
// -----------------------------------------------------------------------
Point Window::OutputToScreenPixel( const Point& rPos ) const
{
// relative to top level parent
return Point( rPos.X()+mnOutOffX, rPos.Y()+mnOutOffY );
}
// -----------------------------------------------------------------------
Point Window::ScreenToOutputPixel( const Point& rPos ) const
{
// relative to top level parent
return Point( rPos.X()-mnOutOffX, rPos.Y()-mnOutOffY );
}
// -----------------------------------------------------------------------
long Window::ImplGetUnmirroredOutOffX()
{
// revert mnOutOffX changes that were potentially made in ImplPosSizeWindow
long offx = mnOutOffX;
if( ImplHasMirroredGraphics() )
{
if( mpWindowImpl->mpParent && !mpWindowImpl->mpParent->mpWindowImpl->mbFrame && mpWindowImpl->mpParent->ImplIsAntiparallel() )
{
if ( !ImplIsOverlapWindow() )
offx -= mpWindowImpl->mpParent->mnOutOffX;
offx = mpWindowImpl->mpParent->mnOutWidth - mnOutWidth - offx;
if ( !ImplIsOverlapWindow() )
offx += mpWindowImpl->mpParent->mnOutOffX;
}
}
return offx;
}
// normalized screen pixel are independent of mirroring
Point Window::OutputToNormalizedScreenPixel( const Point& rPos ) const
{
// relative to top level parent
long offx = ((Window*) this)->ImplGetUnmirroredOutOffX();
return Point( rPos.X()+offx, rPos.Y()+mnOutOffY );
}
Point Window::NormalizedScreenToOutputPixel( const Point& rPos ) const
{
// relative to top level parent
long offx = ((Window*) this)->ImplGetUnmirroredOutOffX();
return Point( rPos.X()-offx, rPos.Y()-mnOutOffY );
}
// -----------------------------------------------------------------------
Point Window::OutputToAbsoluteScreenPixel( const Point& rPos ) const
{
// relative to the screen
Point p = OutputToScreenPixel( rPos );
SalFrameGeometry g = mpWindowImpl->mpFrame->GetGeometry();
p.X() += g.nX;
p.Y() += g.nY;
return p;
}
// -----------------------------------------------------------------------
Point Window::AbsoluteScreenToOutputPixel( const Point& rPos ) const
{
// relative to the screen
Point p = ScreenToOutputPixel( rPos );
SalFrameGeometry g = mpWindowImpl->mpFrame->GetGeometry();
p.X() -= g.nX;
p.Y() -= g.nY;
return p;
}
// -----------------------------------------------------------------------
Rectangle Window::ImplOutputToUnmirroredAbsoluteScreenPixel( const Rectangle &rRect ) const
{
// this method creates unmirrored screen coordinates to be compared with the desktop
// and is used for positioning of RTL popup windows correctly on the screen
SalFrameGeometry g = mpWindowImpl->mpFrame->GetUnmirroredGeometry();
Point p1 = OutputToScreenPixel( rRect.TopRight() );
p1.X() = g.nX+g.nWidth-p1.X();
p1.Y() += g.nY;
Point p2 = OutputToScreenPixel( rRect.BottomLeft() );
p2.X() = g.nX+g.nWidth-p2.X();
p2.Y() += g.nY;
return Rectangle( p1, p2 );
}
// -----------------------------------------------------------------------
Rectangle Window::GetWindowExtentsRelative( Window *pRelativeWindow ) const
{
// with decoration
return ImplGetWindowExtentsRelative( pRelativeWindow, sal_False );
}
Rectangle Window::GetClientWindowExtentsRelative( Window *pRelativeWindow ) const
{
// without decoration
return ImplGetWindowExtentsRelative( pRelativeWindow, sal_True );
}
// -----------------------------------------------------------------------
Rectangle Window::ImplGetWindowExtentsRelative( Window *pRelativeWindow, sal_Bool bClientOnly ) const
{
SalFrameGeometry g = mpWindowImpl->mpFrame->GetGeometry();
// make sure we use the extent of our border window,
// otherwise we miss a few pixels
const Window *pWin = (!bClientOnly && mpWindowImpl->mpBorderWindow) ? mpWindowImpl->mpBorderWindow : this;
Point aPos( pWin->OutputToScreenPixel( Point(0,0) ) );
aPos.X() += g.nX;
aPos.Y() += g.nY;
Size aSize ( pWin->GetSizePixel() );
// #104088# do not add decoration to the workwindow to be compatible to java accessibility api
if( !bClientOnly && (mpWindowImpl->mbFrame || (mpWindowImpl->mpBorderWindow && mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame && GetType() != WINDOW_WORKWINDOW)) )
{
aPos.X() -= g.nLeftDecoration;
aPos.Y() -= g.nTopDecoration;
aSize.Width() += g.nLeftDecoration + g.nRightDecoration;
aSize.Height() += g.nTopDecoration + g.nBottomDecoration;
}
if( pRelativeWindow )
{
// #106399# express coordinates relative to borderwindow
Window *pRelWin = (!bClientOnly && pRelativeWindow->mpWindowImpl->mpBorderWindow) ? pRelativeWindow->mpWindowImpl->mpBorderWindow : pRelativeWindow;
aPos = pRelWin->AbsoluteScreenToOutputPixel( aPos );
}
return Rectangle( aPos, aSize );
}
// -----------------------------------------------------------------------
void Window::Scroll( long nHorzScroll, long nVertScroll, sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplScroll( Rectangle( Point( mnOutOffX, mnOutOffY ),
Size( mnOutWidth, mnOutHeight ) ),
nHorzScroll, nVertScroll, nFlags & ~SCROLL_CLIP );
}
// -----------------------------------------------------------------------
void Window::Scroll( long nHorzScroll, long nVertScroll,
const Rectangle& rRect, sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
Rectangle aRect = ImplLogicToDevicePixel( rRect );
aRect.Intersection( Rectangle( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) ) );
if ( !aRect.IsEmpty() )
ImplScroll( aRect, nHorzScroll, nVertScroll, nFlags );
}
// -----------------------------------------------------------------------
void Window::Invalidate( sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( !IsDeviceOutputNecessary() || !mnOutWidth || !mnOutHeight )
return;
ImplInvalidate( NULL, nFlags );
}
// -----------------------------------------------------------------------
void Window::Invalidate( const Rectangle& rRect, sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( !IsDeviceOutputNecessary() || !mnOutWidth || !mnOutHeight )
return;
Rectangle aRect = ImplLogicToDevicePixel( rRect );
if ( !aRect.IsEmpty() )
{
Region aRegion( aRect );
ImplInvalidate( &aRegion, nFlags );
}
}
// -----------------------------------------------------------------------
void Window::Invalidate( const Region& rRegion, sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( !IsDeviceOutputNecessary() || !mnOutWidth || !mnOutHeight )
return;
if ( rRegion.IsNull() )
ImplInvalidate( NULL, nFlags );
else
{
Region aRegion = ImplPixelToDevicePixel( LogicToPixel( rRegion ) );
if ( !aRegion.IsEmpty() )
ImplInvalidate( &aRegion, nFlags );
}
}
// -----------------------------------------------------------------------
void Window::Validate( sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( !IsDeviceOutputNecessary() || !mnOutWidth || !mnOutHeight )
return;
ImplValidate( NULL, nFlags );
}
// -----------------------------------------------------------------------
void Window::Validate( const Rectangle& rRect, sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( !IsDeviceOutputNecessary() || !mnOutWidth || !mnOutHeight )
return;
Rectangle aRect = ImplLogicToDevicePixel( rRect );
if ( !aRect.IsEmpty() )
{
Region aRegion( aRect );
ImplValidate( &aRegion, nFlags );
}
}
// -----------------------------------------------------------------------
void Window::Validate( const Region& rRegion, sal_uInt16 nFlags )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( !IsDeviceOutputNecessary() || !mnOutWidth || !mnOutHeight )
return;
if ( rRegion.IsNull() )
ImplValidate( NULL, nFlags );
else
{
Region aRegion = ImplPixelToDevicePixel( LogicToPixel( rRegion ) );
if ( !aRegion.IsEmpty() )
ImplValidate( &aRegion, nFlags );
}
}
// -----------------------------------------------------------------------
sal_Bool Window::HasPaintEvent() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( !mpWindowImpl->mbReallyVisible )
return sal_False;
if ( mpWindowImpl->mpFrameWindow->mpWindowImpl->mbPaintFrame )
return sal_True;
if ( mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINT )
return sal_True;
if ( !ImplIsOverlapWindow() )
{
const Window* pTempWindow = this;
do
{
pTempWindow = pTempWindow->ImplGetParent();
if ( pTempWindow->mpWindowImpl->mnPaintFlags & (IMPL_PAINT_PAINTCHILDS | IMPL_PAINT_PAINTALLCHILDS) )
return sal_True;
}
while ( !pTempWindow->ImplIsOverlapWindow() );
}
return sal_False;
}
// -----------------------------------------------------------------------
void Window::Update()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpBorderWindow )
{
mpWindowImpl->mpBorderWindow->Update();
return;
}
if ( !mpWindowImpl->mbReallyVisible )
return;
sal_Bool bFlush = sal_False;
if ( mpWindowImpl->mpFrameWindow->mpWindowImpl->mbPaintFrame )
{
Point aPoint( 0, 0 );
Region aRegion( Rectangle( aPoint, Size( mnOutWidth, mnOutHeight ) ) );
ImplInvalidateOverlapFrameRegion( aRegion );
if ( mpWindowImpl->mbFrame || (mpWindowImpl->mpBorderWindow && mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame) )
bFlush = sal_True;
}
// Zuerst muessen wir alle Fenster ueberspringen, die Paint-Transparent
// sind
Window* pUpdateWindow = this;
Window* pWindow = pUpdateWindow;
while ( !pWindow->ImplIsOverlapWindow() )
{
if ( !pWindow->mpWindowImpl->mbPaintTransparent )
{
pUpdateWindow = pWindow;
break;
}
pWindow = pWindow->ImplGetParent();
}
// Ein Update wirkt immer auf das Window, wo PAINTALLCHILDS gesetzt
// ist, damit nicht zuviel gemalt wird
pWindow = pUpdateWindow;
do
{
if ( pWindow->mpWindowImpl->mnPaintFlags & IMPL_PAINT_PAINTALLCHILDS )
pUpdateWindow = pWindow;
if ( pWindow->ImplIsOverlapWindow() )
break;
pWindow = pWindow->ImplGetParent();
}
while ( pWindow );
// Wenn es etwas zu malen gibt, dann ein Paint ausloesen
if ( pUpdateWindow->mpWindowImpl->mnPaintFlags & (IMPL_PAINT_PAINT | IMPL_PAINT_PAINTCHILDS) )
{
// und fuer alle ueber uns stehende System-Fenster auch ein Update
// ausloesen, damit nicht die ganze Zeit luecken stehen bleiben
Window* pUpdateOverlapWindow = ImplGetFirstOverlapWindow()->mpWindowImpl->mpFirstOverlap;
while ( pUpdateOverlapWindow )
{
pUpdateOverlapWindow->Update();
pUpdateOverlapWindow = pUpdateOverlapWindow->mpWindowImpl->mpNext;
}
pUpdateWindow->ImplCallPaint( NULL, pUpdateWindow->mpWindowImpl->mnPaintFlags );
}
if ( bFlush )
Flush();
}
// -----------------------------------------------------------------------
void Window::Flush()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
const Rectangle aWinRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
mpWindowImpl->mpFrame->Flush( aWinRect );
}
// -----------------------------------------------------------------------
void Window::Sync()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
mpWindowImpl->mpFrame->Sync();
}
// -----------------------------------------------------------------------
void Window::SetUpdateMode( sal_Bool bUpdate )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
mpWindowImpl->mbNoUpdate = !bUpdate;
StateChanged( STATE_CHANGE_UPDATEMODE );
}
// -----------------------------------------------------------------------
void Window::GrabFocus()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplGrabFocus( 0 );
}
// -----------------------------------------------------------------------
sal_Bool Window::HasFocus() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
// #107575# the first floating window always has the keyboard focus, see also winproc.cxx: ImplGetKeyInputWindow()
// task was shifted to 6.y, so its commented out
/*
Window* pFocusWin = ImplGetSVData()->maWinData.mpFirstFloat;
if( pFocusWin && pFocusWin->mpWindowImpl->mbFloatWin && ((FloatingWindow *)pFocusWin)->GrabsFocus() )
pFocusWin = pFocusWin->GetPreferredKeyInputWindow();
else
pFocusWin = ImplGetSVData()->maWinData.mpFocusWin;
return (this == pFocusWin);
*/
return (this == ImplGetSVData()->maWinData.mpFocusWin);
}
// -----------------------------------------------------------------------
void Window::GrabFocusToDocument()
{
Window *pWin = this;
while( pWin )
{
if( !pWin->GetParent() )
{
pWin->ImplGetFrameWindow()->GetWindow( WINDOW_CLIENT )->GrabFocus();
return;
}
pWin = pWin->GetParent();
}
}
void Window::SetFakeFocus( bool bFocus )
{
ImplGetWindowImpl()->mbFakeFocusSet = bFocus;
}
// -----------------------------------------------------------------------
sal_Bool Window::HasChildPathFocus( sal_Bool bSystemWindow ) const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
// #107575#, the first floating window always has the keyboard focus, see also winproc.cxx: ImplGetKeyInputWindow()
// task was shifted to 6.y, so its commented out
/*
Window* pFocusWin = ImplGetSVData()->maWinData.mpFirstFloat;
if( pFocusWin && pFocusWin->mpWindowImpl->mbFloatWin && ((FloatingWindow *)pFocusWin)->GrabsFocus() )
pFocusWin = pFocusWin->GetPreferredKeyInputWindow();
else
pFocusWin = ImplGetSVData()->maWinData.mpFocusWin;
*/
Window* pFocusWin = ImplGetSVData()->maWinData.mpFocusWin;
if ( pFocusWin )
return ImplIsWindowOrChild( pFocusWin, bSystemWindow );
return sal_False;
}
// -----------------------------------------------------------------------
void Window::CaptureMouse()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplSVData* pSVData = ImplGetSVData();
// Tracking evt. beenden
if ( pSVData->maWinData.mpTrackWin != this )
{
if ( pSVData->maWinData.mpTrackWin )
pSVData->maWinData.mpTrackWin->EndTracking( ENDTRACK_CANCEL );
}
if ( pSVData->maWinData.mpCaptureWin != this )
{
pSVData->maWinData.mpCaptureWin = this;
mpWindowImpl->mpFrame->CaptureMouse( sal_True );
}
}
// -----------------------------------------------------------------------
void Window::ReleaseMouse()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
ImplSVData* pSVData = ImplGetSVData();
DBG_ASSERTWARNING( pSVData->maWinData.mpCaptureWin == this,
"Window::ReleaseMouse(): window doesn't have the mouse capture" );
if ( pSVData->maWinData.mpCaptureWin == this )
{
pSVData->maWinData.mpCaptureWin = NULL;
mpWindowImpl->mpFrame->CaptureMouse( sal_False );
ImplGenerateMouseMove();
}
}
// -----------------------------------------------------------------------
sal_Bool Window::IsMouseCaptured() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
return (this == ImplGetSVData()->maWinData.mpCaptureWin);
}
// -----------------------------------------------------------------------
void Window::SetPointer( const Pointer& rPointer )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->maPointer == rPointer )
return;
mpWindowImpl->maPointer = rPointer;
// Pointer evt. direkt umsetzen
if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
}
// -----------------------------------------------------------------------
void Window::EnableChildPointerOverwrite( sal_Bool bOverwrite )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mbChildPtrOverwrite == bOverwrite )
return;
mpWindowImpl->mbChildPtrOverwrite = bOverwrite;
// Pointer evt. direkt umsetzen
if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
}
// -----------------------------------------------------------------------
void Window::SetPointerPosPixel( const Point& rPos )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
Point aPos = ImplOutputToFrame( rPos );
if( ImplHasMirroredGraphics() )
{
if( !IsRTLEnabled() )
{
// --- RTL --- (re-mirror mouse pos at this window)
ImplReMirror( aPos );
}
// mirroring is required here, SetPointerPos bypasses SalGraphics
mpGraphics->mirror( aPos.X(), this );
}
else if( ImplIsAntiparallel() )
{
ImplReMirror( aPos );
}
mpWindowImpl->mpFrame->SetPointerPos( aPos.X(), aPos.Y() );
}
// -----------------------------------------------------------------------
Point Window::GetPointerPosPixel()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
Point aPos( mpWindowImpl->mpFrameData->mnLastMouseX, mpWindowImpl->mpFrameData->mnLastMouseY );
if( ImplIsAntiparallel() )
{
// --- RTL --- (re-mirror mouse pos at this window)
ImplReMirror( aPos );
}
return ImplFrameToOutput( aPos );
}
// -----------------------------------------------------------------------
Point Window::GetLastPointerPosPixel()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
Point aPos( mpWindowImpl->mpFrameData->mnBeforeLastMouseX, mpWindowImpl->mpFrameData->mnBeforeLastMouseY );
if( ImplIsAntiparallel() )
{
// --- RTL --- (re-mirror mouse pos at this window)
ImplReMirror( aPos );
}
return ImplFrameToOutput( aPos );
}
// -----------------------------------------------------------------------
void Window::ShowPointer( sal_Bool bVisible )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mbNoPtrVisible != !bVisible )
{
mpWindowImpl->mbNoPtrVisible = !bVisible;
// Pointer evt. direkt umsetzen
if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
}
}
// -----------------------------------------------------------------------
Window::PointerState Window::GetPointerState()
{
PointerState aState;
aState.mnState = 0;
if (mpWindowImpl->mpFrame)
{
SalFrame::SalPointerState aSalPointerState;
aSalPointerState = mpWindowImpl->mpFrame->GetPointerState();
if( ImplIsAntiparallel() )
{
// --- RTL --- (re-mirror mouse pos at this window)
ImplReMirror( aSalPointerState.maPos );
}
aState.maPos = ImplFrameToOutput( aSalPointerState.maPos );
aState.mnState = aSalPointerState.mnState;
}
return aState;
}
// -----------------------------------------------------------------------
sal_Bool Window::IsMouseOver()
{
return ImplGetWinData()->mbMouseOver;
}
// -----------------------------------------------------------------------
void Window::EnterWait()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
mpWindowImpl->mnWaitCount++;
if ( mpWindowImpl->mnWaitCount == 1 )
{
// Pointer evt. direkt umsetzen
if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
}
}
// -----------------------------------------------------------------------
void Window::LeaveWait()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mnWaitCount )
{
mpWindowImpl->mnWaitCount--;
if ( !mpWindowImpl->mnWaitCount )
{
// Pointer evt. direkt umsetzen
if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
}
}
}
// -----------------------------------------------------------------------
void Window::SetCursor( Cursor* pCursor )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if ( mpWindowImpl->mpCursor != pCursor )
{
if ( mpWindowImpl->mpCursor )
mpWindowImpl->mpCursor->ImplHide( true );
mpWindowImpl->mpCursor = pCursor;
if ( pCursor )
pCursor->ImplShow();
}
}
// -----------------------------------------------------------------------
void Window::SetText( const XubString& rStr )
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
String oldTitle( mpWindowImpl->maText );
mpWindowImpl->maText = rStr;
if ( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->SetText( rStr );
else if ( mpWindowImpl->mbFrame )
mpWindowImpl->mpFrame->SetTitle( rStr );
ImplCallEventListeners( VCLEVENT_WINDOW_FRAMETITLECHANGED, &oldTitle );
// #107247# needed for accessibility
// The VCLEVENT_WINDOW_FRAMETITLECHANGED is (mis)used to notify accessible name changes.
// Therefore a window, which is labeled by this window, must also notify an accessible
// name change.
if ( IsReallyVisible() )
{
Window* pWindow = GetAccessibleRelationLabelFor();
if ( pWindow && pWindow != this )
pWindow->ImplCallEventListeners( VCLEVENT_WINDOW_FRAMETITLECHANGED, &oldTitle );
}
StateChanged( STATE_CHANGE_TEXT );
}
// -----------------------------------------------------------------------
String Window::GetText() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
return mpWindowImpl->maText;
}
// -----------------------------------------------------------------------
String Window::GetDisplayText() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
return GetText();
}
// -----------------------------------------------------------------------
const Wallpaper& Window::GetDisplayBackground() const
{
// FIXME: fix issue 52349, need to fix this really in
// all NWF enabled controls
const ToolBox* pTB = dynamic_cast<const ToolBox*>(this);
if( pTB )
{
if( IsNativeWidgetEnabled() )
return pTB->ImplGetToolBoxPrivateData()->maDisplayBackground;
}
if( !IsBackground() )
{
if( mpWindowImpl->mpParent )
return mpWindowImpl->mpParent->GetDisplayBackground();
}
const Wallpaper& rBack = GetBackground();
if( ! rBack.IsBitmap() &&
! rBack.IsGradient() &&
rBack.GetColor().GetColor() == COL_TRANSPARENT &&
mpWindowImpl->mpParent )
return mpWindowImpl->mpParent->GetDisplayBackground();
return rBack;
}
// -----------------------------------------------------------------------
const XubString& Window::GetHelpText() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
String aStrHelpId( rtl::OStringToOUString( GetHelpId(), RTL_TEXTENCODING_UTF8 ) );
bool bStrHelpId = (aStrHelpId.Len() > 0);
if ( !mpWindowImpl->maHelpText.Len() && bStrHelpId )
{
if ( !IsDialog() && (mpWindowImpl->mnType != WINDOW_TABPAGE) && (mpWindowImpl->mnType != WINDOW_FLOATINGWINDOW) )
{
Help* pHelp = Application::GetHelp();
if ( pHelp )
{
((Window*)this)->mpWindowImpl->maHelpText = pHelp->GetHelpText( aStrHelpId, this );
mpWindowImpl->mbHelpTextDynamic = sal_False;
}
}
}
else if( mpWindowImpl->mbHelpTextDynamic && bStrHelpId )
{
static const char* pEnv = getenv( "HELP_DEBUG" );
if( pEnv && *pEnv )
{
rtl::OUStringBuffer aTxt( 64+mpWindowImpl->maHelpText.Len() );
aTxt.append( mpWindowImpl->maHelpText );
aTxt.appendAscii( "\n------------------\n" );
aTxt.append( rtl::OUString( aStrHelpId ) );
mpWindowImpl->maHelpText = aTxt.makeStringAndClear();
}
mpWindowImpl->mbHelpTextDynamic = sal_False;
}
return mpWindowImpl->maHelpText;
}
// -----------------------------------------------------------------------
Window* Window::FindWindow( const Point& rPos ) const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
Point aPos = OutputToScreenPixel( rPos );
return ((Window*)this)->ImplFindWindow( aPos );
}
// -----------------------------------------------------------------------
sal_uInt16 Window::GetChildCount() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
sal_uInt16 nChildCount = 0;
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
nChildCount++;
pChild = pChild->mpWindowImpl->mpNext;
}
return nChildCount;
}
// -----------------------------------------------------------------------
Window* Window::GetChild( sal_uInt16 nChild ) const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
sal_uInt16 nChildCount = 0;
Window* pChild = mpWindowImpl->mpFirstChild;
while ( pChild )
{
if ( nChild == nChildCount )
return pChild;
pChild = pChild->mpWindowImpl->mpNext;
nChildCount++;
}
return NULL;
}
// -----------------------------------------------------------------------
Window* Window::GetWindow( sal_uInt16 nType ) const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
switch ( nType )
{
case WINDOW_PARENT:
return mpWindowImpl->mpRealParent;
case WINDOW_FIRSTCHILD:
return mpWindowImpl->mpFirstChild;
case WINDOW_LASTCHILD:
return mpWindowImpl->mpLastChild;
case WINDOW_PREV:
return mpWindowImpl->mpPrev;
case WINDOW_NEXT:
return mpWindowImpl->mpNext;
case WINDOW_FIRSTOVERLAP:
return mpWindowImpl->mpFirstOverlap;
case WINDOW_LASTOVERLAP:
return mpWindowImpl->mpLastOverlap;
case WINDOW_OVERLAP:
if ( ImplIsOverlapWindow() )
return (Window*)this;
else
return mpWindowImpl->mpOverlapWindow;
case WINDOW_PARENTOVERLAP:
if ( ImplIsOverlapWindow() )
return mpWindowImpl->mpOverlapWindow;
else
return mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpOverlapWindow;
case WINDOW_CLIENT:
return ((Window*)this)->ImplGetWindow();
case WINDOW_REALPARENT:
return ImplGetParent();
case WINDOW_FRAME:
return mpWindowImpl->mpFrameWindow;
case WINDOW_BORDER:
if ( mpWindowImpl->mpBorderWindow )
return mpWindowImpl->mpBorderWindow->GetWindow( WINDOW_BORDER );
return (Window*)this;
case WINDOW_FIRSTTOPWINDOWCHILD:
return ImplGetWinData()->maTopWindowChildren.empty() ? NULL : *ImplGetWinData()->maTopWindowChildren.begin();
case WINDOW_LASTTOPWINDOWCHILD:
return ImplGetWinData()->maTopWindowChildren.empty() ? NULL : *ImplGetWinData()->maTopWindowChildren.rbegin();
case WINDOW_PREVTOPWINDOWSIBLING:
{
if ( !mpWindowImpl->mpRealParent )
return NULL;
const ::std::list< Window* >& rTopWindows( mpWindowImpl->mpRealParent->ImplGetWinData()->maTopWindowChildren );
::std::list< Window* >::const_iterator myPos =
::std::find( rTopWindows.begin(), rTopWindows.end(), this );
if ( myPos == rTopWindows.end() )
return NULL;
if ( myPos == rTopWindows.begin() )
return NULL;
return *--myPos;
}
case WINDOW_NEXTTOPWINDOWSIBLING:
{
if ( !mpWindowImpl->mpRealParent )
return NULL;
const ::std::list< Window* >& rTopWindows( mpWindowImpl->mpRealParent->ImplGetWinData()->maTopWindowChildren );
::std::list< Window* >::const_iterator myPos =
::std::find( rTopWindows.begin(), rTopWindows.end(), this );
if ( ( myPos == rTopWindows.end() ) || ( ++myPos == rTopWindows.end() ) )
return NULL;
return *myPos;
}
}
return NULL;
}
// -----------------------------------------------------------------------
sal_Bool Window::IsChild( const Window* pWindow, sal_Bool bSystemWindow ) const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
DBG_CHKOBJ( pWindow, Window, ImplDbgCheckWindow );
do
{
if ( !bSystemWindow && pWindow->ImplIsOverlapWindow() )
break;
pWindow = pWindow->ImplGetParent();
if ( pWindow == this )
return sal_True;
}
while ( pWindow );
return sal_False;
}
// -----------------------------------------------------------------------
sal_Bool Window::IsWindowOrChild( const Window* pWindow, sal_Bool bSystemWindow ) const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
DBG_CHKOBJ( pWindow, Window, ImplDbgCheckWindow );
if ( this == pWindow )
return sal_True;
return ImplIsChild( pWindow, bSystemWindow );
}
// -----------------------------------------------------------------------
const SystemEnvData* Window::GetSystemData() const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
return mpWindowImpl->mpFrame ? mpWindowImpl->mpFrame->GetSystemData() : NULL;
}
::com::sun::star::uno::Any Window::GetSystemDataAny() const
{
::com::sun::star::uno::Any aRet;
const SystemEnvData* pSysData = GetSystemData();
if( pSysData )
{
::com::sun::star::uno::Sequence< sal_Int8 > aSeq( (sal_Int8*)pSysData, pSysData->nSize );
aRet <<= aSeq;
}
return aRet;
}
// -----------------------------------------------------------------------
void Window::SetWindowPeer( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > xPeer, VCLXWindow* pVCLXWindow )
{
// be safe against re-entrance: first clear the old ref, then assign the new one
// #133706# / 2006-03-30 / frank.schoenheit@sun.com
mpWindowImpl->mxWindowPeer.clear();
mpWindowImpl->mxWindowPeer = xPeer;
mpWindowImpl->mpVCLXWindow = pVCLXWindow;
}
// -----------------------------------------------------------------------
::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > Window::GetComponentInterface( sal_Bool bCreate )
{
if ( !mpWindowImpl->mxWindowPeer.is() && bCreate )
{
UnoWrapperBase* pWrapper = Application::GetUnoWrapper();
if ( pWrapper )
mpWindowImpl->mxWindowPeer = pWrapper->GetWindowInterface( this, sal_True );
}
return mpWindowImpl->mxWindowPeer;
}
// -----------------------------------------------------------------------
void Window::SetComponentInterface( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > xIFace )
{
UnoWrapperBase* pWrapper = Application::GetUnoWrapper();
DBG_ASSERT( pWrapper, "SetComponentInterface: No Wrapper!" );
if ( pWrapper )
pWrapper->SetWindowInterface( this, xIFace );
}
// -----------------------------------------------------------------------
void Window::ImplCallDeactivateListeners( Window *pNew )
{
// no deactivation if the the newly activated window is my child
if ( !pNew || !ImplIsChild( pNew ) )
{
ImplDelData aDogtag( this );
ImplCallEventListeners( VCLEVENT_WINDOW_DEACTIVATE );
if( aDogtag.IsDelete() )
return;
// #100759#, avoid walking the wrong frame's hierarchy
// eg, undocked docking windows (ImplDockFloatWin)
if ( ImplGetParent() && mpWindowImpl->mpFrameWindow == ImplGetParent()->mpWindowImpl->mpFrameWindow )
ImplGetParent()->ImplCallDeactivateListeners( pNew );
}
}
// -----------------------------------------------------------------------
void Window::ImplCallActivateListeners( Window *pOld )
{
// no activation if the the old active window is my child
if ( !pOld || !ImplIsChild( pOld ) )
{
ImplDelData aDogtag( this );
ImplCallEventListeners( VCLEVENT_WINDOW_ACTIVATE, pOld );
if( aDogtag.IsDelete() )
return;
// #106298# revoke the change for 105369, because this change
// disabled the activate event for the parent,
// if the parent is a compound control
//if( !GetParent() || !GetParent()->IsCompoundControl() )
//{
// #100759#, avoid walking the wrong frame's hierarchy
// eg, undocked docking windows (ImplDockFloatWin)
// #104714#, revert the changes for 100759 because it has a side effect when pOld is a dialog
// additionally the gallery is not dockable anymore, so 100759 canot occur
if ( ImplGetParent() ) /* && mpWindowImpl->mpFrameWindow == ImplGetParent()->mpWindowImpl->mpFrameWindow ) */
ImplGetParent()->ImplCallActivateListeners( pOld );
else if( (mpWindowImpl->mnStyle & WB_INTROWIN) == 0 )
{
// top level frame reached: store hint for DefModalDialogParent
ImplGetSVData()->maWinData.mpActiveApplicationFrame = mpWindowImpl->mpFrameWindow;
}
//}
}
}
// -----------------------------------------------------------------------
bool Window::ImplStopDnd()
{
bool bRet = false;
if( mpWindowImpl->mpFrameData && mpWindowImpl->mpFrameData->mxDropTargetListener.is() )
{
bRet = true;
mpWindowImpl->mpFrameData->mxDropTarget.clear();
mpWindowImpl->mpFrameData->mxDragSource.clear();
mpWindowImpl->mpFrameData->mxDropTargetListener.clear();
}
return bRet;
}
// -----------------------------------------------------------------------
void Window::ImplStartDnd()
{
GetDropTarget();
}
// -----------------------------------------------------------------------
uno::Reference< XDropTarget > Window::GetDropTarget()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if( ! mpWindowImpl->mxDNDListenerContainer.is() )
{
sal_Int8 nDefaultActions = 0;
if( mpWindowImpl->mpFrameData )
{
if( ! mpWindowImpl->mpFrameData->mxDropTarget.is() )
{
// initialization is done in GetDragSource
uno::Reference< XDragSource > xDragSource = GetDragSource();
}
if( mpWindowImpl->mpFrameData->mxDropTarget.is() )
{
nDefaultActions = mpWindowImpl->mpFrameData->mxDropTarget->getDefaultActions();
if( ! mpWindowImpl->mpFrameData->mxDropTargetListener.is() )
{
mpWindowImpl->mpFrameData->mxDropTargetListener = new DNDEventDispatcher( mpWindowImpl->mpFrameWindow );
try
{
mpWindowImpl->mpFrameData->mxDropTarget->addDropTargetListener( mpWindowImpl->mpFrameData->mxDropTargetListener );
// register also as drag gesture listener if directly supported by drag source
uno::Reference< XDragGestureRecognizer > xDragGestureRecognizer =
uno::Reference< XDragGestureRecognizer > (mpWindowImpl->mpFrameData->mxDragSource, UNO_QUERY);
if( xDragGestureRecognizer.is() )
{
xDragGestureRecognizer->addDragGestureListener(
uno::Reference< XDragGestureListener > (mpWindowImpl->mpFrameData->mxDropTargetListener, UNO_QUERY));
}
else
mpWindowImpl->mpFrameData->mbInternalDragGestureRecognizer = sal_True;
}
catch( RuntimeException&)
{
// release all instances
mpWindowImpl->mpFrameData->mxDropTarget.clear();
mpWindowImpl->mpFrameData->mxDragSource.clear();
}
}
}
}
mpWindowImpl->mxDNDListenerContainer = static_cast < XDropTarget * > ( new DNDListenerContainer( nDefaultActions ) );
}
// this object is located in the same process, so there will be no runtime exception
return uno::Reference< XDropTarget > ( mpWindowImpl->mxDNDListenerContainer, UNO_QUERY );
}
// -----------------------------------------------------------------------
uno::Reference< XDragSource > Window::GetDragSource()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if( mpWindowImpl->mpFrameData )
{
if( ! mpWindowImpl->mpFrameData->mxDragSource.is() )
{
try
{
uno::Reference< XMultiServiceFactory > xFactory = vcl::unohelper::GetMultiServiceFactory();
if ( xFactory.is() )
{
const SystemEnvData * pEnvData = GetSystemData();
if( pEnvData )
{
Sequence< Any > aDragSourceAL( 2 ), aDropTargetAL( 2 );
OUString aDragSourceSN, aDropTargetSN;
#if defined WNT
aDragSourceSN = OUString::createFromAscii( "com.sun.star.datatransfer.dnd.OleDragSource" );
aDropTargetSN = OUString::createFromAscii( "com.sun.star.datatransfer.dnd.OleDropTarget" );
aDragSourceAL[ 1 ] = makeAny( (sal_uInt32) pEnvData->hWnd );
aDropTargetAL[ 0 ] = makeAny( (sal_uInt32) pEnvData->hWnd );
#elif defined QUARTZ
/* FIXME: Mac OS X specific dnd interface does not exist! *
* Using Windows based dnd as a temporary solution */
aDragSourceSN = OUString::createFromAscii( "com.sun.star.datatransfer.dnd.OleDragSource" );
aDropTargetSN = OUString::createFromAscii( "com.sun.star.datatransfer.dnd.OleDropTarget" );
aDragSourceAL[ 1 ] = makeAny( static_cast<sal_uInt64>( reinterpret_cast<sal_IntPtr>(pEnvData->mpNSView) ) );
aDropTargetAL[ 0 ] = makeAny( static_cast<sal_uInt64>( reinterpret_cast<sal_IntPtr>(pEnvData->mpNSView) ) );
#elif defined UNX
aDropTargetAL.realloc( 3 );
aDragSourceAL.realloc( 3 );
aDragSourceSN = OUString::createFromAscii( "com.sun.star.datatransfer.dnd.X11DragSource" );
aDropTargetSN = OUString::createFromAscii( "com.sun.star.datatransfer.dnd.X11DropTarget" );
aDragSourceAL[ 0 ] = makeAny( Application::GetDisplayConnection() );
aDragSourceAL[ 2 ] = makeAny( vcl::createBmpConverter() );
aDropTargetAL[ 0 ] = makeAny( Application::GetDisplayConnection() );
aDropTargetAL[ 1 ] = makeAny( (sal_Size)(pEnvData->aShellWindow) );
aDropTargetAL[ 2 ] = makeAny( vcl::createBmpConverter() );
#endif
if( aDragSourceSN.getLength() )
mpWindowImpl->mpFrameData->mxDragSource = uno::Reference< XDragSource > ( xFactory->createInstanceWithArguments( aDragSourceSN, aDragSourceAL ), UNO_QUERY );
if( aDropTargetSN.getLength() )
mpWindowImpl->mpFrameData->mxDropTarget = uno::Reference< XDropTarget > ( xFactory->createInstanceWithArguments( aDropTargetSN, aDropTargetAL ), UNO_QUERY );
}
}
}
// createInstance can throw any exception
catch( Exception&)
{
// release all instances
mpWindowImpl->mpFrameData->mxDropTarget.clear();
mpWindowImpl->mpFrameData->mxDragSource.clear();
}
}
return mpWindowImpl->mpFrameData->mxDragSource;
}
return uno::Reference< XDragSource > ();
}
// -----------------------------------------------------------------------
void Window::GetDragSourceDropTarget(uno::Reference< XDragSource >& xDragSource, uno::Reference< XDropTarget > &xDropTarget )
// only for RVP transmission
{
if( mpWindowImpl->mpFrameData )
{
// initialization is done in GetDragSource
xDragSource = GetDragSource();
xDropTarget = mpWindowImpl->mpFrameData->mxDropTarget;
}
else
{
xDragSource.clear();
xDropTarget.clear();
}
}
// -----------------------------------------------------------------------
uno::Reference< XDragGestureRecognizer > Window::GetDragGestureRecognizer()
{
return uno::Reference< XDragGestureRecognizer > ( GetDropTarget(), UNO_QUERY );
}
// -----------------------------------------------------------------------
uno::Reference< XClipboard > Window::GetClipboard()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if( mpWindowImpl->mpFrameData )
{
if( ! mpWindowImpl->mpFrameData->mxClipboard.is() )
{
try
{
uno::Reference< XMultiServiceFactory > xFactory( vcl::unohelper::GetMultiServiceFactory() );
if( xFactory.is() )
{
mpWindowImpl->mpFrameData->mxClipboard = uno::Reference< XClipboard >( xFactory->createInstance( OUString::createFromAscii( "com.sun.star.datatransfer.clipboard.SystemClipboardExt" ) ), UNO_QUERY );
if( !mpWindowImpl->mpFrameData->mxClipboard.is() )
mpWindowImpl->mpFrameData->mxClipboard = uno::Reference< XClipboard >( xFactory->createInstance( OUString::createFromAscii( "com.sun.star.datatransfer.clipboard.SystemClipboard" ) ), UNO_QUERY );
#if defined(UNX) && !defined(QUARTZ) // unix clipboard needs to be initialized
if( mpWindowImpl->mpFrameData->mxClipboard.is() )
{
uno::Reference< XInitialization > xInit = uno::Reference< XInitialization >( mpWindowImpl->mpFrameData->mxClipboard, UNO_QUERY );
if( xInit.is() )
{
Sequence< Any > aArgumentList( 3 );
aArgumentList[ 0 ] = makeAny( Application::GetDisplayConnection() );
aArgumentList[ 1 ] = makeAny( OUString::createFromAscii( "CLIPBOARD" ) );
aArgumentList[ 2 ] = makeAny( vcl::createBmpConverter() );
xInit->initialize( aArgumentList );
}
}
#endif
}
}
// createInstance can throw any exception
catch( Exception&)
{
// release all instances
mpWindowImpl->mpFrameData->mxClipboard.clear();
}
}
return mpWindowImpl->mpFrameData->mxClipboard;
}
return static_cast < XClipboard * > (0);
}
// -----------------------------------------------------------------------
uno::Reference< XClipboard > Window::GetPrimarySelection()
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if( mpWindowImpl->mpFrameData )
{
if( ! mpWindowImpl->mpFrameData->mxSelection.is() )
{
try
{
uno::Reference< XMultiServiceFactory > xFactory( vcl::unohelper::GetMultiServiceFactory() );
if( xFactory.is() )
{
#if defined(UNX) && !defined(QUARTZ)
Sequence< Any > aArgumentList( 3 );
aArgumentList[ 0 ] = makeAny( Application::GetDisplayConnection() );
aArgumentList[ 1 ] = makeAny( OUString::createFromAscii( "PRIMARY" ) );
aArgumentList[ 2 ] = makeAny( vcl::createBmpConverter() );
mpWindowImpl->mpFrameData->mxSelection = uno::Reference< XClipboard >( xFactory->createInstanceWithArguments(
OUString::createFromAscii( "com.sun.star.datatransfer.clipboard.SystemClipboard" ), aArgumentList ), UNO_QUERY );
# else
static uno::Reference< XClipboard > s_xSelection;
if ( !s_xSelection.is() )
s_xSelection = uno::Reference< XClipboard >( xFactory->createInstance( OUString::createFromAscii( "com.sun.star.datatransfer.clipboard.GenericClipboardExt" ) ), UNO_QUERY );
if ( !s_xSelection.is() )
s_xSelection = uno::Reference< XClipboard >( xFactory->createInstance( OUString::createFromAscii( "com.sun.star.datatransfer.clipboard.GenericClipboard" ) ), UNO_QUERY );
mpWindowImpl->mpFrameData->mxSelection = s_xSelection;
# endif
}
}
// createInstance can throw any exception
catch( Exception&)
{
// release all instances
mpWindowImpl->mpFrameData->mxSelection.clear();
}
}
return mpWindowImpl->mpFrameData->mxSelection;
}
return static_cast < XClipboard * > (0);
}
// -----------------------------------------------------------------------
// Accessibility
// -----------------------------------------------------------------------
::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > Window::GetAccessible( sal_Bool bCreate )
{
// do not optimize hierarchy for the top level border win (ie, when there is no parent)
/* // do not optimize accessible hierarchy at all to better reflect real VCL hierarchy
if ( GetParent() && ( GetType() == WINDOW_BORDERWINDOW ) && ( GetChildCount() == 1 ) )
//if( !ImplIsAccessibleCandidate() )
{
Window* pChild = GetAccessibleChildWindow( 0 );
if ( pChild )
return pChild->GetAccessible();
}
*/
if ( !mpWindowImpl->mxAccessible.is() && bCreate )
mpWindowImpl->mxAccessible = CreateAccessible();
return mpWindowImpl->mxAccessible;
}
::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > Window::CreateAccessible()
{
::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc( GetComponentInterface( sal_True ), ::com::sun::star::uno::UNO_QUERY );
return xAcc;
}
void Window::SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > x )
{
mpWindowImpl->mxAccessible = x;
}
// skip all border windows that are no top level frames
sal_Bool Window::ImplIsAccessibleCandidate() const
{
if( !mpWindowImpl->mbBorderWin )
return sal_True;
else
// #101741 do not check for WB_CLOSEABLE because undecorated floaters (like menues!) are closeable
if( mpWindowImpl->mbFrame && mpWindowImpl->mnStyle & (WB_MOVEABLE | WB_SIZEABLE) )
return sal_True;
else
return sal_False;
}
sal_Bool Window::ImplIsAccessibleNativeFrame() const
{
if( mpWindowImpl->mbFrame )
// #101741 do not check for WB_CLOSEABLE because undecorated floaters (like menues!) are closeable
if( (mpWindowImpl->mnStyle & (WB_MOVEABLE | WB_SIZEABLE)) )
return sal_True;
else
return sal_False;
else
return sal_False;
}
sal_uInt16 Window::ImplGetAccessibleCandidateChildWindowCount( sal_uInt16 nFirstWindowType ) const
{
sal_uInt16 nChildren = 0;
Window* pChild = GetWindow( nFirstWindowType );
while ( pChild )
{
if( pChild->ImplIsAccessibleCandidate() )
nChildren++;
else
nChildren = sal::static_int_cast<sal_uInt16>(nChildren + pChild->ImplGetAccessibleCandidateChildWindowCount( WINDOW_FIRSTCHILD ));
pChild = pChild->mpWindowImpl->mpNext;
}
return nChildren;
}
Window* Window::ImplGetAccessibleCandidateChild( sal_uInt16 nChild, sal_uInt16& rChildCount, sal_uInt16 nFirstWindowType, sal_Bool bTopLevel ) const
{
DBG_CHKTHIS( Window, ImplDbgCheckWindow );
if( bTopLevel )
rChildCount = 0;
Window* pChild = GetWindow( nFirstWindowType );
while ( pChild )
{
Window *pTmpChild = pChild;
if( !pChild->ImplIsAccessibleCandidate() )
pTmpChild = pChild->ImplGetAccessibleCandidateChild( nChild, rChildCount, WINDOW_FIRSTCHILD, sal_False );
if ( nChild == rChildCount )
return pTmpChild;
pChild = pChild->mpWindowImpl->mpNext;
rChildCount++;
}
return NULL;
}
/*
Window* Window::GetAccessibleParentWindow() const
{
Window* pParent = GetParent();
while ( pParent )
if( pParent->ImplIsAccessibleCandidate() )
break;
else
pParent = pParent->GetParent();
return pParent;
}
*/
Window* Window::GetAccessibleParentWindow() const
{
if ( ImplIsAccessibleNativeFrame() )
return NULL;
Window* pParent = mpWindowImpl->mpParent;
if( GetType() == WINDOW_MENUBARWINDOW )
{
// report the menubar as a child of THE workwindow
Window *pWorkWin = GetParent()->mpWindowImpl->mpFirstChild;
while( pWorkWin && (pWorkWin == this) )
pWorkWin = pWorkWin->mpWindowImpl->mpNext;
pParent = pWorkWin;
}
// If this a floating window which has a native boarder window, this one should be reported as
// accessible parent
else if( GetType() == WINDOW_FLOATINGWINDOW &&
mpWindowImpl->mpBorderWindow && mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame)
{
pParent = mpWindowImpl->mpBorderWindow;
}
else if( pParent && !pParent->ImplIsAccessibleCandidate() )
{
pParent = pParent->mpWindowImpl->mpParent;
}
return pParent;
}
/*
sal_uInt16 Window::GetAccessibleChildWindowCount()
{
sal_uInt16 nChildren = ImplGetAccessibleCandidateChildWindowCount( WINDOW_FIRSTCHILD );
// Search also for SystemWindows.
Window* pOverlap = GetWindow( WINDOW_OVERLAP );
nChildren += pOverlap->ImplGetAccessibleCandidateChildWindowCount( WINDOW_FIRSTOVERLAP );
return nChildren;
}
*/
sal_uInt16 Window::GetAccessibleChildWindowCount()
{
sal_uInt16 nChildren = 0;
Window* pChild = mpWindowImpl->mpFirstChild;
while( pChild )
{
if( pChild->IsVisible() )
nChildren++;
pChild = pChild->mpWindowImpl->mpNext;
}
// #107176# ignore overlapwindows
// this only affects non-system floating windows
// which are either not accessible (like the HelpAgent) or should be changed to system windows anyway
/*
if( ImplIsOverlapWindow() )
{
Window* pOverlap = GetWindow( WINDOW_FIRSTOVERLAP );
while ( pOverlap )
{
if( pOverlap->IsVisible() )
nChildren++;
pOverlap = pOverlap->GetWindow( WINDOW_NEXT );
}
}
*/
// report the menubarwindow as a child of THE workwindow
if( GetType() == WINDOW_BORDERWINDOW )
{
if( ((ImplBorderWindow *) this)->mpMenuBarWindow &&
((ImplBorderWindow *) this)->mpMenuBarWindow->IsVisible()
)
--nChildren;
}
else if( GetType() == WINDOW_WORKWINDOW )
{
if( ((WorkWindow *) this)->GetMenuBar() &&
((WorkWindow *) this)->GetMenuBar()->GetWindow() &&
((WorkWindow *) this)->GetMenuBar()->GetWindow()->IsVisible()
)
++nChildren;
}
return nChildren;
}
/*
Window* Window::GetAccessibleChildWindow( sal_uInt16 n )
{
sal_uInt16 nChildCount; // will be set in ImplGetAccessibleCandidateChild(...)
Window* pChild = ImplGetAccessibleCandidateChild( n, nChildCount, WINDOW_FIRSTCHILD, sal_True );
if ( !pChild && ( n >= nChildCount ) )
{
Window* pOverlap = GetWindow( WINDOW_OVERLAP );
pChild = pOverlap->ImplGetAccessibleCandidateChild( n, nChildCount, WINDOW_FIRSTOVERLAP, sal_False );
}
return pChild;
}
*/
Window* Window::GetAccessibleChildWindow( sal_uInt16 n )
{
// report the menubarwindow as a the first child of THE workwindow
if( GetType() == WINDOW_WORKWINDOW && ((WorkWindow *) this)->GetMenuBar() )
{
if( n == 0 )
{
MenuBar *pMenuBar = ((WorkWindow *) this)->GetMenuBar();
if( pMenuBar->GetWindow() && pMenuBar->GetWindow()->IsVisible() )
return pMenuBar->GetWindow();
}
else
--n;
}
// transform n to child number including invisible children
sal_uInt16 nChildren = n;
Window* pChild = mpWindowImpl->mpFirstChild;
while( pChild )
{
if( pChild->IsVisible() )
{
if( ! nChildren )
break;
nChildren--;
}
pChild = pChild->mpWindowImpl->mpNext;
}
if( GetType() == WINDOW_BORDERWINDOW && pChild && pChild->GetType() == WINDOW_MENUBARWINDOW )
{
do pChild = pChild->mpWindowImpl->mpNext; while( pChild && ! pChild->IsVisible() );
DBG_ASSERT( pChild, "GetAccessibleChildWindow(): wrong index in border window");
}
if ( !pChild )
{
// #107176# ignore overlapwindows
/*
if( ImplIsOverlapWindow() )
{
Window* pOverlap = GetWindow( WINDOW_FIRSTOVERLAP );
while ( !pChild && pOverlap )
{
if ( !nChildren && pOverlap->IsVisible() )
{
pChild = pOverlap;
break;
}
pOverlap = pOverlap->GetWindow( WINDOW_NEXT );
if( pOverlap && pOverlap->IsVisible() )
nChildren--;
}
}
*/
}
if ( pChild && ( pChild->GetType() == WINDOW_BORDERWINDOW ) && ( pChild->GetChildCount() == 1 ) )
{
pChild = pChild->GetChild( 0 );
}
return pChild;
}
void Window::SetAccessibleRole( sal_uInt16 nRole )
{
if ( !mpWindowImpl->mpAccessibleInfos )
mpWindowImpl->mpAccessibleInfos = new ImplAccessibleInfos;
DBG_ASSERT( mpWindowImpl->mpAccessibleInfos->nAccessibleRole == 0xFFFF, "AccessibleRole already set!" );
mpWindowImpl->mpAccessibleInfos->nAccessibleRole = nRole;
}
sal_uInt16 Window::GetAccessibleRole() const
{
using namespace ::com::sun::star;
sal_uInt16 nRole = mpWindowImpl->mpAccessibleInfos ? mpWindowImpl->mpAccessibleInfos->nAccessibleRole : 0xFFFF;
if ( nRole == 0xFFFF )
{
switch ( GetType() )
{
case WINDOW_MESSBOX: // MT: Would be nice to have special roles!
case WINDOW_INFOBOX:
case WINDOW_WARNINGBOX:
case WINDOW_ERRORBOX:
case WINDOW_QUERYBOX: nRole = accessibility::AccessibleRole::ALERT; break;
case WINDOW_MODELESSDIALOG:
case WINDOW_MODALDIALOG:
case WINDOW_SYSTEMDIALOG:
case WINDOW_PRINTERSETUPDIALOG:
case WINDOW_PRINTDIALOG:
case WINDOW_TABDIALOG:
case WINDOW_BUTTONDIALOG:
case WINDOW_DIALOG: nRole = accessibility::AccessibleRole::DIALOG; break;
case WINDOW_PUSHBUTTON:
case WINDOW_OKBUTTON:
case WINDOW_CANCELBUTTON:
case WINDOW_HELPBUTTON:
case WINDOW_IMAGEBUTTON:
//case WINDOW_MENUBUTTON:
case WINDOW_MOREBUTTON:
case WINDOW_SPINBUTTON:
case WINDOW_BUTTON: nRole = accessibility::AccessibleRole::PUSH_BUTTON; break;
case WINDOW_MENUBUTTON: nRole = accessibility::AccessibleRole::BUTTON_MENU; break;
case WINDOW_PATHDIALOG: nRole = accessibility::AccessibleRole::DIRECTORY_PANE; break;
case WINDOW_FILEDIALOG: nRole = accessibility::AccessibleRole::FILE_CHOOSER; break;
case WINDOW_COLORDIALOG: nRole = accessibility::AccessibleRole::COLOR_CHOOSER; break;
case WINDOW_FONTDIALOG: nRole = accessibility::AccessibleRole::FONT_CHOOSER; break;
case WINDOW_IMAGERADIOBUTTON:
case WINDOW_RADIOBUTTON: nRole = accessibility::AccessibleRole::RADIO_BUTTON; break;
case WINDOW_TRISTATEBOX:
case WINDOW_CHECKBOX: nRole = accessibility::AccessibleRole::CHECK_BOX; break;
case WINDOW_MULTILINEEDIT: nRole = accessibility::AccessibleRole::SCROLL_PANE; break;
case WINDOW_PATTERNFIELD:
// Need to set the role of those window control to spinbox
/*
case WINDOW_NUMERICFIELD:
case WINDOW_METRICFIELD:
case WINDOW_CURRENCYFIELD:
case WINDOW_LONGCURRENCYFIELD:
*/
case WINDOW_EDIT: nRole = ( GetStyle() & WB_PASSWORD ) ? (accessibility::AccessibleRole::PASSWORD_TEXT) : (accessibility::AccessibleRole::TEXT); break;
case WINDOW_PATTERNBOX:
case WINDOW_NUMERICBOX:
case WINDOW_METRICBOX:
case WINDOW_CURRENCYBOX:
case WINDOW_LONGCURRENCYBOX:
case WINDOW_COMBOBOX: nRole = accessibility::AccessibleRole::COMBO_BOX; break;
case WINDOW_LISTBOX:
case WINDOW_MULTILISTBOX: nRole = accessibility::AccessibleRole::LIST; break;
case WINDOW_TREELISTBOX: nRole = accessibility::AccessibleRole::TREE; break;
case WINDOW_FIXEDTEXT: nRole = accessibility::AccessibleRole::LABEL; break;
case WINDOW_FIXEDBORDER:
nRole = accessibility::AccessibleRole::SEPARATOR; break;
case WINDOW_FIXEDLINE:
{ if( GetText().Len() > 0 )
nRole = accessibility::AccessibleRole::LABEL;
else
nRole = accessibility::AccessibleRole::SEPARATOR;
break;
}
//case WINDOW_FIXEDLINE: nRole = accessibility::AccessibleRole::SEPARATOR; break;
case WINDOW_FIXEDBITMAP:
case WINDOW_FIXEDIMAGE: nRole = accessibility::AccessibleRole::ICON; break;
case WINDOW_GROUPBOX: nRole = accessibility::AccessibleRole::GROUP_BOX; break;
case WINDOW_SCROLLBAR: nRole = accessibility::AccessibleRole::SCROLL_BAR; break;
case WINDOW_SLIDER:
case WINDOW_SPLITTER:
case WINDOW_SPLITWINDOW: nRole = accessibility::AccessibleRole::SPLIT_PANE; break;
case WINDOW_DATEBOX:
case WINDOW_TIMEBOX:
case WINDOW_DATEFIELD:
case WINDOW_TIMEFIELD: nRole = accessibility::AccessibleRole::DATE_EDITOR; break;
// Need to set the role of those window control to spinbox
case WINDOW_NUMERICFIELD:
case WINDOW_METRICFIELD:
case WINDOW_CURRENCYFIELD:
case WINDOW_LONGCURRENCYFIELD:
case WINDOW_SPINFIELD: nRole = accessibility::AccessibleRole::SPIN_BOX; break;
case WINDOW_TOOLBOX: nRole = accessibility::AccessibleRole::TOOL_BAR; break;
case WINDOW_STATUSBAR: nRole = accessibility::AccessibleRole::STATUS_BAR; break;
case WINDOW_TABPAGE: nRole = accessibility::AccessibleRole::PANEL; break;
case WINDOW_TABCONTROL: nRole = accessibility::AccessibleRole::PAGE_TAB_LIST; break;
case WINDOW_DOCKINGWINDOW:
case WINDOW_SYSWINDOW: nRole = (mpWindowImpl->mbFrame) ? accessibility::AccessibleRole::FRAME :
accessibility::AccessibleRole::PANEL; break;
case WINDOW_FLOATINGWINDOW: nRole = ( mpWindowImpl->mbFrame ||
(mpWindowImpl->mpBorderWindow && mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame) ||
(GetStyle() & WB_OWNERDRAWDECORATION) ) ? accessibility::AccessibleRole::FRAME :
accessibility::AccessibleRole::WINDOW; break;
case WINDOW_WORKWINDOW: nRole = accessibility::AccessibleRole::ROOT_PANE; break;
case WINDOW_SCROLLBARBOX: nRole = accessibility::AccessibleRole::FILLER; break;
case WINDOW_HELPTEXTWINDOW: nRole = accessibility::AccessibleRole::TOOL_TIP; break;
case WINDOW_RULER: nRole = accessibility::AccessibleRole::RULER; break;
case WINDOW_WINDOW:
case WINDOW_CONTROL:
case WINDOW_BORDERWINDOW:
case WINDOW_SYSTEMCHILDWINDOW:
default:
if (ImplIsAccessibleNativeFrame() )
nRole = accessibility::AccessibleRole::FRAME;
else if( IsScrollable() )
nRole = accessibility::AccessibleRole::SCROLL_PANE;
else if( ((Window*)this)->ImplGetWindow()->IsMenuFloatingWindow() )
nRole = accessibility::AccessibleRole::WINDOW; // #106002#, contextmenues are windows (i.e. toplevel)
else
// #104051# WINDOW seems to be a bad default role, use LAYEREDPANE instead
// a WINDOW is interpreted as a top-level window, which is typically not the case
//nRole = accessibility::AccessibleRole::WINDOW;
nRole = accessibility::AccessibleRole::PANEL;
}
}
return nRole;
}
void Window::SetAccessibleName( const String& rName )
{
if ( !mpWindowImpl->mpAccessibleInfos )
mpWindowImpl->mpAccessibleInfos = new ImplAccessibleInfos;
String oldName = GetAccessibleName();
delete mpWindowImpl->mpAccessibleInfos->pAccessibleName;
mpWindowImpl->mpAccessibleInfos->pAccessibleName = new String( rName );
ImplCallEventListeners( VCLEVENT_WINDOW_FRAMETITLECHANGED, &oldName );
}
String Window::GetAccessibleName() const
{
String aAccessibleName;
if ( mpWindowImpl->mpAccessibleInfos && mpWindowImpl->mpAccessibleInfos->pAccessibleName )
{
aAccessibleName = *mpWindowImpl->mpAccessibleInfos->pAccessibleName;
}
else
{
switch ( GetType() )
{
// case WINDOW_IMAGERADIOBUTTON:
// case WINDOW_RADIOBUTTON:
// case WINDOW_TRISTATEBOX:
// case WINDOW_CHECKBOX:
case WINDOW_MULTILINEEDIT:
case WINDOW_PATTERNFIELD:
case WINDOW_NUMERICFIELD:
case WINDOW_METRICFIELD:
case WINDOW_CURRENCYFIELD:
case WINDOW_LONGCURRENCYFIELD:
case WINDOW_EDIT:
case WINDOW_DATEBOX:
case WINDOW_TIMEBOX:
case WINDOW_CURRENCYBOX:
case WINDOW_LONGCURRENCYBOX:
case WINDOW_DATEFIELD:
case WINDOW_TIMEFIELD:
case WINDOW_SPINFIELD:
case WINDOW_COMBOBOX:
case WINDOW_LISTBOX:
case WINDOW_MULTILISTBOX:
case WINDOW_TREELISTBOX:
case WINDOW_METRICBOX:
{
Window *pLabel = GetAccessibleRelationLabeledBy();
if ( pLabel && pLabel != this )
aAccessibleName = pLabel->GetText();
}
if ( !aAccessibleName.Len() )
{
aAccessibleName = GetQuickHelpText();
}
break;
case WINDOW_IMAGEBUTTON:
case WINDOW_PUSHBUTTON:
aAccessibleName = GetText();
if ( !aAccessibleName.Len() )
{
aAccessibleName = GetQuickHelpText();
if ( !aAccessibleName.Len() )
aAccessibleName = GetHelpText();
}
break;
case WINDOW_TOOLBOX:
aAccessibleName = GetText();
if( aAccessibleName.Len() == 0 )
aAccessibleName =XubString( RTL_CONSTASCII_USTRINGPARAM( "Tool Bar" ) );
break;
case WINDOW_MOREBUTTON:
aAccessibleName = mpWindowImpl->maText;
break;
default:
aAccessibleName = GetText();
break;
}
aAccessibleName = GetNonMnemonicString( aAccessibleName );
}
return aAccessibleName;
}
void Window::SetAccessibleDescription( const String& rDescription )
{
if ( ! mpWindowImpl->mpAccessibleInfos )
mpWindowImpl->mpAccessibleInfos = new ImplAccessibleInfos;
DBG_ASSERT( !mpWindowImpl->mpAccessibleInfos->pAccessibleDescription, "AccessibleDescription already set!" );
delete mpWindowImpl->mpAccessibleInfos->pAccessibleDescription;
mpWindowImpl->mpAccessibleInfos->pAccessibleDescription = new String( rDescription );
}
String Window::GetAccessibleDescription() const
{
String aAccessibleDescription;
if ( mpWindowImpl->mpAccessibleInfos && mpWindowImpl->mpAccessibleInfos->pAccessibleDescription )
{
aAccessibleDescription = *mpWindowImpl->mpAccessibleInfos->pAccessibleDescription;
}
else
{
// Special code for help text windows. ZT asks the border window for the
// description so we have to forward this request to our inner window.
const Window* pWin = ((Window *)this)->ImplGetWindow();
if ( pWin->GetType() == WINDOW_HELPTEXTWINDOW )
aAccessibleDescription = pWin->GetHelpText();
else
aAccessibleDescription = GetHelpText();
}
return aAccessibleDescription;
}
void Window::SetAccessibleRelationLabeledBy( Window* pLabeledBy )
{
if ( !mpWindowImpl->mpAccessibleInfos )
mpWindowImpl->mpAccessibleInfos = new ImplAccessibleInfos;
mpWindowImpl->mpAccessibleInfos->pLabeledByWindow = pLabeledBy;
}
void Window::SetAccessibleRelationLabelFor( Window* pLabelFor )
{
if ( !mpWindowImpl->mpAccessibleInfos )
mpWindowImpl->mpAccessibleInfos = new ImplAccessibleInfos;
mpWindowImpl->mpAccessibleInfos->pLabelForWindow = pLabelFor;
}
void Window::SetAccessibleRelationMemberOf( Window* pMemberOfWin )
{
if ( !mpWindowImpl->mpAccessibleInfos )
mpWindowImpl->mpAccessibleInfos = new ImplAccessibleInfos;
mpWindowImpl->mpAccessibleInfos->pMemberOfWindow = pMemberOfWin;
}
sal_Bool Window::IsAccessibilityEventsSuppressed( sal_Bool bTraverseParentPath )
{
if( !bTraverseParentPath )
return mpWindowImpl->mbSuppressAccessibilityEvents;
else
{
Window *pParent = this;
while ( pParent && pParent->mpWindowImpl)
{
if( pParent->mpWindowImpl->mbSuppressAccessibilityEvents )
return sal_True;
else
pParent = pParent->mpWindowImpl->mpParent; // do not use GetParent() to find borderwindows that are frames
}
return sal_False;
}
}
void Window::SetAccessibilityEventsSuppressed(sal_Bool bSuppressed)
{
mpWindowImpl->mbSuppressAccessibilityEvents = bSuppressed;
}
void Window::RecordLayoutData( vcl::ControlLayoutData* pLayout, const Rectangle& rRect )
{
if( ! mpOutDevData )
ImplInitOutDevData();
mpOutDevData->mpRecordLayout = pLayout;
mpOutDevData->maRecordRect = rRect;
Paint( rRect );
mpOutDevData->mpRecordLayout = NULL;
}
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
// returns background color used in this control
// false: could not determine color
sal_Bool Window::ImplGetCurrentBackgroundColor( Color& rCol )
{
sal_Bool bRet = sal_True;
switch ( GetType() )
{
// peform special handling here
case WINDOW_PUSHBUTTON:
case WINDOW_OKBUTTON:
case WINDOW_CANCELBUTTON:
// etc.
default:
if( IsControlBackground() )
rCol = GetControlBackground();
else if( IsBackground() )
{
Wallpaper aWall = GetBackground();
if( !aWall.IsGradient() && !aWall.IsBitmap() )
rCol = aWall.GetColor();
else
bRet = sal_False;
}
else
rCol = GetSettings().GetStyleSettings().GetFaceColor();
break;
}
return bRet;
}
void Window::DrawSelectionBackground( const Rectangle& rRect, sal_uInt16 highlight, sal_Bool bChecked, sal_Bool bDrawBorder, sal_Bool bDrawExtBorderOnly )
{
DrawSelectionBackground( rRect, highlight, bChecked, bDrawBorder, bDrawExtBorderOnly, 0, NULL, NULL );
}
void Window::DrawSelectionBackground( const Rectangle& rRect, sal_uInt16 highlight, sal_Bool bChecked, sal_Bool bDrawBorder, sal_Bool bDrawExtBorderOnly, Color* pSelectionTextColor )
{
DrawSelectionBackground( rRect, highlight, bChecked, bDrawBorder, bDrawExtBorderOnly, 0, pSelectionTextColor, NULL );
}
void Window::DrawSelectionBackground( const Rectangle& rRect,
sal_uInt16 highlight,
sal_Bool bChecked,
sal_Bool bDrawBorder,
sal_Bool bDrawExtBorderOnly,
long nCornerRadius,
Color* pSelectionTextColor,
Color* pPaintColor
)
{
if( rRect.IsEmpty() )
return;
bool bRoundEdges = nCornerRadius > 0;
const StyleSettings& rStyles = GetSettings().GetStyleSettings();
// colors used for item highlighting
Color aSelectionBorderCol( pPaintColor ? *pPaintColor : rStyles.GetHighlightColor() );
Color aSelectionFillCol( aSelectionBorderCol );
sal_Bool bDark = rStyles.GetFaceColor().IsDark();
sal_Bool bBright = ( rStyles.GetFaceColor() == Color( COL_WHITE ) );
int c1 = aSelectionBorderCol.GetLuminance();
int c2 = GetDisplayBackground().GetColor().GetLuminance();
if( !bDark && !bBright && abs( c2-c1 ) < (pPaintColor ? 40 : 75) )
{
// constrast too low
sal_uInt16 h,s,b;
aSelectionFillCol.RGBtoHSB( h, s, b );
if( b > 50 ) b -= 40;
else b += 40;
aSelectionFillCol.SetColor( Color::HSBtoRGB( h, s, b ) );
aSelectionBorderCol = aSelectionFillCol;
}
if( bRoundEdges )
{
if( aSelectionBorderCol.IsDark() )
aSelectionBorderCol.IncreaseLuminance( 128 );
else
aSelectionBorderCol.DecreaseLuminance( 128 );
}
Rectangle aRect( rRect );
if( bDrawExtBorderOnly )
{
aRect.nLeft -= 1;
aRect.nTop -= 1;
aRect.nRight += 1;
aRect.nBottom += 1;
}
Color oldFillCol = GetFillColor();
Color oldLineCol = GetLineColor();
if( bDrawBorder )
SetLineColor( bDark ? Color(COL_WHITE) : ( bBright ? Color(COL_BLACK) : aSelectionBorderCol ) );
else
SetLineColor();
sal_uInt16 nPercent = 0;
if( !highlight )
{
if( bDark )
aSelectionFillCol = COL_BLACK;
else
nPercent = 80; // just checked (light)
}
else
{
if( bChecked && highlight == 2 )
{
if( bDark )
aSelectionFillCol = COL_LIGHTGRAY;
else if ( bBright )
{
aSelectionFillCol = COL_BLACK;
SetLineColor( COL_BLACK );
nPercent = 0;
}
else
nPercent = bRoundEdges ? 40 : 20; // selected, pressed or checked ( very dark )
}
else if( bChecked || highlight == 1 )
{
if( bDark )
aSelectionFillCol = COL_GRAY;
else if ( bBright )
{
aSelectionFillCol = COL_BLACK;
SetLineColor( COL_BLACK );
nPercent = 0;
}
else
nPercent = bRoundEdges ? 60 : 35; // selected, pressed or checked ( very dark )
}
else
{
if( bDark )
aSelectionFillCol = COL_LIGHTGRAY;
else if ( bBright )
{
aSelectionFillCol = COL_BLACK;
SetLineColor( COL_BLACK );
if( highlight == 3 )
nPercent = 80;
else
nPercent = 0;
}
else
nPercent = 70; // selected ( dark )
}
}
if( bDark && bDrawExtBorderOnly )
{
SetFillColor();
if( pSelectionTextColor )
*pSelectionTextColor = rStyles.GetHighlightTextColor();
}
else
{
SetFillColor( aSelectionFillCol );
if( pSelectionTextColor )
{
Color aTextColor = IsControlBackground() ? GetControlForeground() : rStyles.GetButtonTextColor();
Color aHLTextColor = rStyles.GetHighlightTextColor();
int nTextDiff = abs(aSelectionFillCol.GetLuminance() - aTextColor.GetLuminance());
int nHLDiff = abs(aSelectionFillCol.GetLuminance() - aHLTextColor.GetLuminance());
*pSelectionTextColor = (nHLDiff >= nTextDiff) ? aHLTextColor : aTextColor;
}
}
if( bDark )
{
DrawRect( aRect );
}
else
{
if( bRoundEdges )
{
Polygon aPoly( aRect, nCornerRadius, nCornerRadius );
PolyPolygon aPolyPoly( aPoly );
DrawTransparent( aPolyPoly, nPercent );
}
else
{
Polygon aPoly( aRect );
PolyPolygon aPolyPoly( aPoly );
DrawTransparent( aPolyPoly, nPercent );
}
}
SetFillColor( oldFillCol );
SetLineColor( oldLineCol );
}
/*
void Window::DbgAssertNoEventListeners()
{
VclWindowEvent aEvent( this, 0, NULL );
DBG_ASSERT( mpWindowImpl->maEventListeners.empty(), "Eventlistener: Who is still listening???" )
if ( !mpWindowImpl->maEventListeners.empty() )
mpWindowImpl->maEventListeners.Call( &aEvent );
DBG_ASSERT( mpWindowImpl->maChildEventListeners.empty(), "ChildEventlistener: Who is still listening???" )
if ( !mpWindowImpl->maChildEventListeners.empty() )
mpWindowImpl->maChildEventListeners.Call( &aEvent );
}
*/
// controls should return the window that gets the
// focus by default, so keyevents can be sent to that window directly
Window* Window::GetPreferredKeyInputWindow()
{
return this;
}
sal_Bool Window::IsScrollable() const
{
// check for scrollbars
Window *pChild = mpWindowImpl->mpFirstChild;
while( pChild )
{
if( pChild->GetType() == WINDOW_SCROLLBAR )
return true;
else
pChild = pChild->mpWindowImpl->mpNext;
}
return false;
}
sal_Bool Window::IsTopWindow() const
{
if ( mpWindowImpl->mbInDtor )
return sal_False;
// topwindows must be frames or they must have a borderwindow which is a frame
if( !mpWindowImpl->mbFrame && (!mpWindowImpl->mpBorderWindow || (mpWindowImpl->mpBorderWindow && !mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame) ) )
return sal_False;
ImplGetWinData();
if( mpWindowImpl->mpWinData->mnIsTopWindow == (sal_uInt16)~0) // still uninitialized
{
// #113722#, cache result of expensive queryInterface call
Window *pThisWin = (Window*)this;
uno::Reference< XTopWindow > xTopWindow( pThisWin->GetComponentInterface(), UNO_QUERY );
pThisWin->mpWindowImpl->mpWinData->mnIsTopWindow = xTopWindow.is() ? 1 : 0;
}
return mpWindowImpl->mpWinData->mnIsTopWindow == 1 ? sal_True : sal_False;
}
void Window::ImplMirrorFramePos( Point &pt ) const
{
pt.X() = mpWindowImpl->mpFrame->maGeometry.nWidth-1-pt.X();
}
// frame based modal counter (dialogs are not modal to the whole application anymore)
sal_Bool Window::IsInModalMode() const
{
return (mpWindowImpl->mpFrameWindow->mpWindowImpl->mpFrameData->mnModalMode != 0);
}
void Window::ImplIncModalCount()
{
Window* pFrameWindow = mpWindowImpl->mpFrameWindow;
Window* pParent = pFrameWindow;
while( pFrameWindow )
{
pFrameWindow->mpWindowImpl->mpFrameData->mnModalMode++;
while( pParent && pParent->mpWindowImpl->mpFrameWindow == pFrameWindow )
{
pParent = pParent->GetParent();
}
pFrameWindow = pParent ? pParent->mpWindowImpl->mpFrameWindow : NULL;
}
}
void Window::ImplDecModalCount()
{
Window* pFrameWindow = mpWindowImpl->mpFrameWindow;
Window* pParent = pFrameWindow;
while( pFrameWindow )
{
pFrameWindow->mpWindowImpl->mpFrameData->mnModalMode--;
while( pParent && pParent->mpWindowImpl->mpFrameWindow == pFrameWindow )
{
pParent = pParent->GetParent();
}
pFrameWindow = pParent ? pParent->mpWindowImpl->mpFrameWindow : NULL;
}
}
sal_Bool Window::ImplIsInTaskPaneList()
{
return mpWindowImpl->mbIsInTaskPaneList;
}
void Window::ImplIsInTaskPaneList( sal_Bool mbIsInTaskList )
{
mpWindowImpl->mbIsInTaskPaneList = mbIsInTaskList;
}
void Window::ImplNotifyIconifiedState( sal_Bool bIconified )
{
mpWindowImpl->mpFrameWindow->ImplCallEventListeners( bIconified ? VCLEVENT_WINDOW_MINIMIZE : VCLEVENT_WINDOW_NORMALIZE );
// #109206# notify client window as well to have toolkit topwindow listeners notified
if( mpWindowImpl->mpFrameWindow->mpWindowImpl->mpClientWindow && mpWindowImpl->mpFrameWindow != mpWindowImpl->mpFrameWindow->mpWindowImpl->mpClientWindow )
mpWindowImpl->mpFrameWindow->mpWindowImpl->mpClientWindow->ImplCallEventListeners( bIconified ? VCLEVENT_WINDOW_MINIMIZE : VCLEVENT_WINDOW_NORMALIZE );
}
sal_Bool Window::HasActiveChildFrame()
{
sal_Bool bRet = sal_False;
Window *pFrameWin = ImplGetSVData()->maWinData.mpFirstFrame;
while( pFrameWin )
{
if( pFrameWin != mpWindowImpl->mpFrameWindow )
{
sal_Bool bDecorated = sal_False;
Window *pChildFrame = pFrameWin->ImplGetWindow();
// #i15285# unfortunately WB_MOVEABLE is the same as WB_TABSTOP which can
// be removed for ToolBoxes to influence the keyboard accessibility
// thus WB_MOVEABLE is no indicator for decoration anymore
// but FloatingWindows carry this information in their TitleType...
// TODO: avoid duplicate WinBits !!!
if( pChildFrame && pChildFrame->ImplIsFloatingWindow() )
bDecorated = ((FloatingWindow*) pChildFrame)->GetTitleType() != FLOATWIN_TITLE_NONE;
if( bDecorated || (pFrameWin->mpWindowImpl->mnStyle & (WB_MOVEABLE | WB_SIZEABLE) ) )
if( pChildFrame && pChildFrame->IsVisible() && pChildFrame->IsActive() )
{
if( ImplIsChild( pChildFrame, sal_True ) )
{
bRet = sal_True;
break;
}
}
}
pFrameWin = pFrameWin->mpWindowImpl->mpFrameData->mpNextFrame;
}
return bRet;
}
LanguageType Window::GetInputLanguage() const
{
return mpWindowImpl->mpFrame->GetInputLanguage();
}
void Window::EnableNativeWidget( sal_Bool bEnable )
{
static const char* pNoNWF = getenv( "SAL_NO_NWF" );
if( pNoNWF && *pNoNWF )
bEnable = sal_False;
if( bEnable != ImplGetWinData()->mbEnableNativeWidget )
{
ImplGetWinData()->mbEnableNativeWidget = bEnable;
// send datachanged event to allow for internal changes required for NWF
// like clipmode, transparency, etc.
DataChangedEvent aDCEvt( DATACHANGED_SETTINGS, &maSettings, SETTINGS_STYLE );
DataChanged( aDCEvt );
// sometimes the borderwindow is queried, so keep it in sync
if( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->ImplGetWinData()->mbEnableNativeWidget = bEnable;
}
// push down, useful for compound controls
Window *pChild = mpWindowImpl->mpFirstChild;
while( pChild )
{
pChild->EnableNativeWidget( bEnable );
pChild = pChild->mpWindowImpl->mpNext;
}
}
sal_Bool Window::IsNativeWidgetEnabled() const
{
return ImplGetWinData()->mbEnableNativeWidget;
}
#ifdef WNT // see #140456#
#include <win/salframe.h>
#endif
uno::Reference< rendering::XCanvas > Window::ImplGetCanvas( const Size& rFullscreenSize,
bool bFullscreen,
bool bSpriteCanvas ) const
{
// try to retrieve hard reference from weak member
uno::Reference< rendering::XCanvas > xCanvas( mpWindowImpl->mxCanvas );
// canvas still valid? Then we're done.
if( xCanvas.is() )
return xCanvas;
Sequence< Any > aArg(6);
// Feed any with operating system's window handle
// ==============================================
// common: first any is VCL pointer to window (for VCL canvas)
aArg[ 0 ] = makeAny( reinterpret_cast<sal_Int64>(this) );
// TODO(Q1): Make GetSystemData method virtual
// check whether we're a SysChild: have to fetch system data
// directly from SystemChildWindow, because the GetSystemData
// method is unfortunately not virtual
const SystemChildWindow* pSysChild = dynamic_cast< const SystemChildWindow* >( this );
if( pSysChild )
{
aArg[ 1 ] = pSysChild->GetSystemDataAny();
aArg[ 5 ] = pSysChild->GetSystemGfxDataAny();
}
else
{
aArg[ 1 ] = GetSystemDataAny();
aArg[ 5 ] = GetSystemGfxDataAny();
}
if( bFullscreen )
aArg[ 2 ] = makeAny( ::com::sun::star::awt::Rectangle( 0, 0,
rFullscreenSize.Width(),
rFullscreenSize.Height() ) );
else
aArg[ 2 ] = makeAny( ::com::sun::star::awt::Rectangle( mnOutOffX, mnOutOffY, mnOutWidth, mnOutHeight ) );
aArg[ 3 ] = makeAny( mpWindowImpl->mbAlwaysOnTop ? sal_True : sal_False );
aArg[ 4 ] = makeAny( uno::Reference< awt::XWindow >(
const_cast<Window*>(this)->GetComponentInterface(),
uno::UNO_QUERY ));
uno::Reference< XMultiServiceFactory > xFactory = vcl::unohelper::GetMultiServiceFactory();
// Create canvas instance with window handle
// =========================================
if ( xFactory.is() )
{
static ::vcl::DeleteUnoReferenceOnDeinit<lang::XMultiServiceFactory> xStaticCanvasFactory(
uno::Reference<lang::XMultiServiceFactory>(
xFactory->createInstance(
OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.rendering.CanvasFactory") ) ),
UNO_QUERY ));
uno::Reference<lang::XMultiServiceFactory> xCanvasFactory(xStaticCanvasFactory.get());
if(xCanvasFactory.is())
{
#ifdef WNT
// see #140456# - if we're running on a multiscreen setup,
// request special, multi-screen safe sprite canvas
// implementation (not DX5 canvas, as it cannot cope with
// surfaces spanning multiple displays). Note: canvas
// (without sprite) stays the same)
const sal_uInt32 nDisplay = static_cast< WinSalFrame* >( mpWindowImpl->mpFrame )->mnDisplay;
if( (nDisplay >= Application::GetScreenCount()) )
{
xCanvas.set( xCanvasFactory->createInstanceWithArguments(
bSpriteCanvas ?
OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.rendering.SpriteCanvas.MultiScreen" )) :
OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.rendering.Canvas.MultiScreen" )),
aArg ),
UNO_QUERY );
}
else
{
#endif
xCanvas.set( xCanvasFactory->createInstanceWithArguments(
bSpriteCanvas ?
OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.rendering.SpriteCanvas" )) :
OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.rendering.Canvas" )),
aArg ),
UNO_QUERY );
#ifdef WNT
}
#endif
mpWindowImpl->mxCanvas = xCanvas;
}
}
// no factory??? Empty reference, then.
return xCanvas;
}
uno::Reference< rendering::XCanvas > Window::GetCanvas() const
{
return ImplGetCanvas( Size(), false, false );
}
uno::Reference< rendering::XSpriteCanvas > Window::GetSpriteCanvas() const
{
uno::Reference< rendering::XSpriteCanvas > xSpriteCanvas(
ImplGetCanvas( Size(), false, true ), uno::UNO_QUERY );
return xSpriteCanvas;
}
uno::Reference< ::com::sun::star::rendering::XSpriteCanvas > Window::GetFullscreenSpriteCanvas( const Size& rFullscreenSize ) const
{
uno::Reference< rendering::XSpriteCanvas > xSpriteCanvas(
ImplGetCanvas( rFullscreenSize, true, true ), uno::UNO_QUERY );
return xSpriteCanvas;
}
void Window::ImplPaintToDevice( OutputDevice* i_pTargetOutDev, const Point& i_rPos )
{
sal_Bool bRVisible = mpWindowImpl->mbReallyVisible;
mpWindowImpl->mbReallyVisible = mpWindowImpl->mbVisible;
sal_Bool bDevOutput = mbDevOutput;
mbDevOutput = sal_True;
long nOldDPIX = ImplGetDPIX();
long nOldDPIY = ImplGetDPIY();
mnDPIX = i_pTargetOutDev->ImplGetDPIX();
mnDPIY = i_pTargetOutDev->ImplGetDPIY();
sal_Bool bOutput = IsOutputEnabled();
EnableOutput();
DBG_ASSERT( GetMapMode().GetMapUnit() == MAP_PIXEL, "MapMode must be PIXEL based" );
if ( GetMapMode().GetMapUnit() != MAP_PIXEL )
return;
// preserve graphicsstate
Push();
Region aClipRegion( GetClipRegion() );
SetClipRegion();
GDIMetaFile* pOldMtf = GetConnectMetaFile();
GDIMetaFile aMtf;
SetConnectMetaFile( &aMtf );
// put a push action to metafile
Push();
// copy graphics state to metafile
Font aCopyFont = GetFont();
if( nOldDPIX != mnDPIX || nOldDPIY != mnDPIY )
{
aCopyFont.SetHeight( aCopyFont.GetHeight() * mnDPIY / nOldDPIY );
aCopyFont.SetWidth( aCopyFont.GetWidth() * mnDPIX / nOldDPIX );
}
SetFont( aCopyFont );
SetTextColor( GetTextColor() );
if( IsLineColor() )
SetLineColor( GetLineColor() );
else
SetLineColor();
if( IsFillColor() )
SetFillColor( GetFillColor() );
else
SetFillColor();
if( IsTextLineColor() )
SetTextLineColor( GetTextLineColor() );
else
SetTextLineColor();
if( IsOverlineColor() )
SetOverlineColor( GetOverlineColor() );
else
SetOverlineColor();
if( IsTextFillColor() )
SetTextFillColor( GetTextFillColor() );
else
SetTextFillColor();
SetTextAlign( GetTextAlign() );
SetRasterOp( GetRasterOp() );
if( IsRefPoint() )
SetRefPoint( GetRefPoint() );
else
SetRefPoint();
SetLayoutMode( GetLayoutMode() );
SetDigitLanguage( GetDigitLanguage() );
Rectangle aPaintRect( Point( 0, 0 ), GetOutputSizePixel() );
aClipRegion.Intersect( aPaintRect );
SetClipRegion( aClipRegion );
// do the actual paint
// background
if( ! IsPaintTransparent() && IsBackground() && ! (GetParentClipMode() & PARENTCLIPMODE_NOCLIP ) )
Erase();
// foreground
Paint( aPaintRect );
// put a pop action to metafile
Pop();
SetConnectMetaFile( pOldMtf );
EnableOutput( bOutput );
mpWindowImpl->mbReallyVisible = bRVisible;
// paint metafile to VDev
VirtualDevice* pMaskedDevice = new VirtualDevice( *i_pTargetOutDev, 0, 0 );
pMaskedDevice->SetOutputSizePixel( GetOutputSizePixel() );
pMaskedDevice->EnableRTL( IsRTLEnabled() );
aMtf.WindStart();
aMtf.Play( pMaskedDevice );
BitmapEx aBmpEx( pMaskedDevice->GetBitmapEx( Point( 0, 0 ), pMaskedDevice->GetOutputSizePixel() ) );
i_pTargetOutDev->DrawBitmapEx( i_rPos, aBmpEx );
// get rid of virtual device now so they don't pile up during recursive calls
delete pMaskedDevice, pMaskedDevice = NULL;
for( Window* pChild = mpWindowImpl->mpFirstChild; pChild; pChild = pChild->mpWindowImpl->mpNext )
{
if( pChild->mpWindowImpl->mpFrame == mpWindowImpl->mpFrame && pChild->IsVisible() )
{
long nDeltaX = pChild->mnOutOffX - mnOutOffX;
if( ImplHasMirroredGraphics() )
nDeltaX = mnOutWidth - nDeltaX - pChild->mnOutWidth;
long nDeltaY = pChild->GetOutOffYPixel() - GetOutOffYPixel();
Point aPos( i_rPos );
Point aDelta( nDeltaX, nDeltaY );
aPos += aDelta;
pChild->ImplPaintToDevice( i_pTargetOutDev, aPos );
}
}
// restore graphics state
Pop();
EnableOutput( bOutput );
mpWindowImpl->mbReallyVisible = bRVisible;
mbDevOutput = bDevOutput;
mnDPIX = nOldDPIX;
mnDPIY = nOldDPIY;
}
void Window::PaintToDevice( OutputDevice* pDev, const Point& rPos, const Size& /*rSize*/ )
{
// FIXME: scaling: currently this is for pixel copying only
DBG_ASSERT( ! pDev->ImplHasMirroredGraphics(), "PaintToDevice to mirroring graphics" );
DBG_ASSERT( ! pDev->IsRTLEnabled(), "PaintToDevice to mirroring device" );
Point aPos = pDev->LogicToPixel( rPos );
Window* pRealParent = NULL;
if( ! mpWindowImpl->mbVisible )
{
Window* pTempParent = ImplGetDefaultWindow();
if( pTempParent )
pTempParent->EnableChildTransparentMode();
pRealParent = GetParent();
SetParent( pTempParent );
// trigger correct visibility flags for children
Show();
Hide();
}
sal_Bool bVisible = mpWindowImpl->mbVisible;
mpWindowImpl->mbVisible = sal_True;
if( mpWindowImpl->mpBorderWindow )
mpWindowImpl->mpBorderWindow->ImplPaintToDevice( pDev, rPos );
else
ImplPaintToDevice( pDev, rPos );
mpWindowImpl->mbVisible = bVisible;
if( pRealParent )
SetParent( pRealParent );
}
XubString Window::GetSurroundingText() const
{
return XubString::EmptyString();
}
Selection Window::GetSurroundingTextSelection() const
{
return Selection( 0, 0 );
}