xref: /aoo41x/main/vcl/source/window/brdwin.cxx (revision 9f62ea84)

/**************************************************************
 *
 * 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 <svids.hrc>
#include <svdata.hxx>
#include <brdwin.hxx>
#include <window.h>

#include <vcl/event.hxx>
#include <vcl/decoview.hxx>
#include <vcl/syswin.hxx>
#include <vcl/dockwin.hxx>
#include <vcl/floatwin.hxx>
#include <vcl/bitmap.hxx>
#include <vcl/gradient.hxx>
#include <vcl/image.hxx>
#include <vcl/virdev.hxx>
#include <vcl/help.hxx>
#include <vcl/edit.hxx>
#include <vcl/metric.hxx>

#include <tools/debug.hxx>

using namespace ::com::sun::star::uno;

// useful caption height for title bar buttons
#define MIN_CAPTION_HEIGHT 18

// =======================================================================

static void ImplGetPinImage( sal_uInt16 nStyle, sal_Bool bPinIn, Image& rImage )
{
	// ImageListe laden, wenn noch nicht vorhanden
	ImplSVData* pSVData = ImplGetSVData();
	if ( !pSVData->maCtrlData.mpPinImgList )
	{
        ResMgr* pResMgr = ImplGetResMgr();
		pSVData->maCtrlData.mpPinImgList = new ImageList();
        if( pResMgr )
		{
			Color aMaskColor( 0x00, 0x00, 0xFF );
			pSVData->maCtrlData.mpPinImgList->InsertFromHorizontalBitmap
				( ResId( SV_RESID_BITMAP_PIN, *pResMgr ), 4,
				  &aMaskColor, NULL, NULL, 0);
		}
	}

	// Image ermitteln und zurueckgeben
	sal_uInt16 nId;
	if ( nStyle & BUTTON_DRAW_PRESSED )
	{
		if ( bPinIn )
			nId = 4;
		else
			nId = 3;
	}
	else
	{
		if ( bPinIn )
			nId = 2;
		else
			nId = 1;
	}
	rImage = pSVData->maCtrlData.mpPinImgList->GetImage( nId );
}

// -----------------------------------------------------------------------

void Window::ImplCalcSymbolRect( Rectangle& rRect )
{
	// Den Rand den der Button in der nicht Default-Darstellung freilaesst,
	// dazuaddieren, da wir diesen bei kleinen Buttons mit ausnutzen wollen
	rRect.Left()--;
	rRect.Top()--;
	rRect.Right()++;
	rRect.Bottom()++;

	// Zwischen dem Symbol und dem Button-Rand lassen wir 5% Platz
	long nExtraWidth = ((rRect.GetWidth()*50)+500)/1000;
	long nExtraHeight = ((rRect.GetHeight()*50)+500)/1000;
	rRect.Left()	+= nExtraWidth;
	rRect.Right()	-= nExtraWidth;
	rRect.Top() 	+= nExtraHeight;
	rRect.Bottom()	-= nExtraHeight;
}

// -----------------------------------------------------------------------

static void ImplDrawBrdWinSymbol( OutputDevice* pDev,
								  const Rectangle& rRect, SymbolType eSymbol )
{
	// Zwischen dem Symbol und dem Button lassen wir 5% Platz
	DecorationView	aDecoView( pDev );
	Rectangle		aTempRect = rRect;
	Window::ImplCalcSymbolRect( aTempRect );
	aDecoView.DrawSymbol( aTempRect, eSymbol,
						  pDev->GetSettings().GetStyleSettings().GetButtonTextColor(), 0 );
}

// -----------------------------------------------------------------------

static void ImplDrawBrdWinSymbolButton( OutputDevice* pDev,
										const Rectangle& rRect,
										SymbolType eSymbol, sal_uInt16 nState )
{
    sal_Bool bMouseOver = (nState & BUTTON_DRAW_HIGHLIGHT) != 0;
    nState &= ~BUTTON_DRAW_HIGHLIGHT;

	Rectangle aTempRect;
    Window *pWin = dynamic_cast< Window* >(pDev);
    if( pWin )
    {
        if( bMouseOver )
        {
            // provide a bright background for selection effect
            pWin->SetFillColor( pDev->GetSettings().GetStyleSettings().GetWindowColor() );
            pWin->SetLineColor();
            pWin->DrawRect( rRect );
            pWin->DrawSelectionBackground( rRect, 2, (nState & BUTTON_DRAW_PRESSED) ? sal_True : sal_False,
                                            sal_True, sal_False );
        }
        aTempRect = rRect;
        aTempRect.nLeft+=3;
        aTempRect.nRight-=4;
        aTempRect.nTop+=3;
        aTempRect.nBottom-=4;
    }
    else
    {
	    DecorationView aDecoView( pDev );
	    aTempRect = aDecoView.DrawButton( rRect, nState|BUTTON_DRAW_FLAT );
    }
	ImplDrawBrdWinSymbol( pDev, aTempRect, eSymbol );
}


// =======================================================================

// ------------------------
// - ImplBorderWindowView -
// ------------------------

ImplBorderWindowView::~ImplBorderWindowView()
{
}

// -----------------------------------------------------------------------

sal_Bool ImplBorderWindowView::MouseMove( const MouseEvent& )
{
	return sal_False;
}

// -----------------------------------------------------------------------

sal_Bool ImplBorderWindowView::MouseButtonDown( const MouseEvent& )
{
	return sal_False;
}

// -----------------------------------------------------------------------

sal_Bool ImplBorderWindowView::Tracking( const TrackingEvent& )
{
	return sal_False;
}

// -----------------------------------------------------------------------

String ImplBorderWindowView::RequestHelp( const Point&, Rectangle& )
{
	return String();
}

// -----------------------------------------------------------------------

Rectangle ImplBorderWindowView::GetMenuRect() const
{
    return Rectangle();
}

// -----------------------------------------------------------------------

void ImplBorderWindowView::ImplInitTitle( ImplBorderFrameData* pData )
{
	ImplBorderWindow* pBorderWindow = pData->mpBorderWindow;

	if ( !(pBorderWindow->GetStyle() & WB_MOVEABLE) ||
		  (pData->mnTitleType == BORDERWINDOW_TITLE_NONE) )
	{
		pData->mnTitleType	 = BORDERWINDOW_TITLE_NONE;
		pData->mnTitleHeight = 0;
	}
	else
	{
		const StyleSettings& rStyleSettings = pData->mpOutDev->GetSettings().GetStyleSettings();
		if ( pData->mnTitleType == BORDERWINDOW_TITLE_TEAROFF )
			pData->mnTitleHeight = rStyleSettings.GetTearOffTitleHeight();
		else
		{
			if ( pData->mnTitleType == BORDERWINDOW_TITLE_SMALL )
			{
				pBorderWindow->SetPointFont( rStyleSettings.GetFloatTitleFont() );
				pData->mnTitleHeight = rStyleSettings.GetFloatTitleHeight();
			}
			else // pData->mnTitleType == BORDERWINDOW_TITLE_NORMAL
			{
				pBorderWindow->SetPointFont( rStyleSettings.GetTitleFont() );
				pData->mnTitleHeight = rStyleSettings.GetTitleHeight();
			}
			long nTextHeight = pBorderWindow->GetTextHeight();
			if ( nTextHeight > pData->mnTitleHeight )
				pData->mnTitleHeight = nTextHeight;
		}
	}
}

// -----------------------------------------------------------------------

sal_uInt16 ImplBorderWindowView::ImplHitTest( ImplBorderFrameData* pData, const Point& rPos )
{
	ImplBorderWindow* pBorderWindow = pData->mpBorderWindow;

	if ( pData->maTitleRect.IsInside( rPos ) )
	{
		if ( pData->maCloseRect.IsInside( rPos ) )
			return BORDERWINDOW_HITTEST_CLOSE;
		else if ( pData->maRollRect.IsInside( rPos ) )
			return BORDERWINDOW_HITTEST_ROLL;
		else if ( pData->maMenuRect.IsInside( rPos ) )
			return BORDERWINDOW_HITTEST_MENU;
		else if ( pData->maDockRect.IsInside( rPos ) )
			return BORDERWINDOW_HITTEST_DOCK;
		else if ( pData->maHideRect.IsInside( rPos ) )
			return BORDERWINDOW_HITTEST_HIDE;
		else if ( pData->maHelpRect.IsInside( rPos ) )
			return BORDERWINDOW_HITTEST_HELP;
		else if ( pData->maPinRect.IsInside( rPos ) )
			return BORDERWINDOW_HITTEST_PIN;
		else
			return BORDERWINDOW_HITTEST_TITLE;
	}

	if ( (pBorderWindow->GetStyle() & WB_SIZEABLE) &&
		 !pBorderWindow->mbRollUp )
	{
		long nSizeWidth = pData->mnNoTitleTop+pData->mnTitleHeight;
		if ( nSizeWidth < 16 )
			nSizeWidth = 16;

        // no corner resize for floating toolbars, which would lead to jumps while formatting
        // setting nSizeWidth = 0 will only return pure left,top,right,bottom
        if( pBorderWindow->GetStyle() & WB_OWNERDRAWDECORATION )
            nSizeWidth = 0;

        if ( rPos.X() < pData->mnLeftBorder )
		{
			if ( rPos.Y() < nSizeWidth )
				return BORDERWINDOW_HITTEST_TOPLEFT;
			else if ( rPos.Y() >= pData->mnHeight-nSizeWidth )
				return BORDERWINDOW_HITTEST_BOTTOMLEFT;
			else
				return BORDERWINDOW_HITTEST_LEFT;
		}
		else if ( rPos.X() >= pData->mnWidth-pData->mnRightBorder )
		{
			if ( rPos.Y() < nSizeWidth )
				return BORDERWINDOW_HITTEST_TOPRIGHT;
			else if ( rPos.Y() >= pData->mnHeight-nSizeWidth )
				return BORDERWINDOW_HITTEST_BOTTOMRIGHT;
			else
				return BORDERWINDOW_HITTEST_RIGHT;
		}
		else if ( rPos.Y() < pData->mnNoTitleTop )
		{
			if ( rPos.X() < nSizeWidth )
				return BORDERWINDOW_HITTEST_TOPLEFT;
			else if ( rPos.X() >= pData->mnWidth-nSizeWidth )
				return BORDERWINDOW_HITTEST_TOPRIGHT;
			else
				return BORDERWINDOW_HITTEST_TOP;
		}
		else if ( rPos.Y() >= pData->mnHeight-pData->mnBottomBorder )
		{
			if ( rPos.X() < nSizeWidth )
				return BORDERWINDOW_HITTEST_BOTTOMLEFT;
			else if ( rPos.X() >= pData->mnWidth-nSizeWidth )
				return BORDERWINDOW_HITTEST_BOTTOMRIGHT;
			else
				return BORDERWINDOW_HITTEST_BOTTOM;
		}
	}

	return 0;
}

// -----------------------------------------------------------------------

sal_Bool ImplBorderWindowView::ImplMouseMove( ImplBorderFrameData* pData, const MouseEvent& rMEvt )
{
    sal_uInt16 oldCloseState = pData->mnCloseState;
    sal_uInt16 oldMenuState = pData->mnMenuState;
    pData->mnCloseState &= ~BUTTON_DRAW_HIGHLIGHT;
    pData->mnMenuState &= ~BUTTON_DRAW_HIGHLIGHT;

	Point aMousePos = rMEvt.GetPosPixel();
	sal_uInt16 nHitTest = ImplHitTest( pData, aMousePos );
	PointerStyle ePtrStyle = POINTER_ARROW;
	if ( nHitTest & BORDERWINDOW_HITTEST_LEFT )
		ePtrStyle = POINTER_WINDOW_WSIZE;
	else if ( nHitTest & BORDERWINDOW_HITTEST_RIGHT )
		ePtrStyle = POINTER_WINDOW_ESIZE;
	else if ( nHitTest & BORDERWINDOW_HITTEST_TOP )
		ePtrStyle = POINTER_WINDOW_NSIZE;
	else if ( nHitTest & BORDERWINDOW_HITTEST_BOTTOM )
		ePtrStyle = POINTER_WINDOW_SSIZE;
	else if ( nHitTest & BORDERWINDOW_HITTEST_TOPLEFT )
		ePtrStyle = POINTER_WINDOW_NWSIZE;
	else if ( nHitTest & BORDERWINDOW_HITTEST_BOTTOMRIGHT )
		ePtrStyle = POINTER_WINDOW_SESIZE;
	else if ( nHitTest & BORDERWINDOW_HITTEST_TOPRIGHT )
		ePtrStyle = POINTER_WINDOW_NESIZE;
	else if ( nHitTest & BORDERWINDOW_HITTEST_BOTTOMLEFT )
		ePtrStyle = POINTER_WINDOW_SWSIZE;
	else if ( nHitTest & BORDERWINDOW_HITTEST_CLOSE )
		pData->mnCloseState |= BUTTON_DRAW_HIGHLIGHT;
	else if ( nHitTest & BORDERWINDOW_HITTEST_MENU )
		pData->mnMenuState |= BUTTON_DRAW_HIGHLIGHT;
	pData->mpBorderWindow->SetPointer( Pointer( ePtrStyle ) );

    if( pData->mnCloseState != oldCloseState )
        pData->mpBorderWindow->Invalidate( pData->maCloseRect );
    if( pData->mnMenuState != oldMenuState )
        pData->mpBorderWindow->Invalidate( pData->maMenuRect );

	return sal_True;
}

// -----------------------------------------------------------------------

sal_Bool ImplBorderWindowView::ImplMouseButtonDown( ImplBorderFrameData* pData, const MouseEvent& rMEvt )
{
	ImplBorderWindow* pBorderWindow = pData->mpBorderWindow;

	if ( rMEvt.IsLeft() || rMEvt.IsRight() )
	{
		pData->maMouseOff = rMEvt.GetPosPixel();
		pData->mnHitTest = ImplHitTest( pData, pData->maMouseOff );
		sal_uInt16 nDragFullTest = 0;
		if ( pData->mnHitTest )
		{
			sal_Bool bTracking = sal_True;
			sal_Bool bHitTest = sal_True;

			if ( pData->mnHitTest & BORDERWINDOW_HITTEST_CLOSE )
			{
				pData->mnCloseState |= BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_CLOSE );
			}
			else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_ROLL )
			{
				pData->mnRollState |= BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_ROLL );
			}
			else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_DOCK )
			{
				pData->mnDockState |= BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_DOCK );
			}
			else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_MENU )
			{
				pData->mnMenuState |= BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_MENU );

                // call handler already on mouse down
				if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
				{
					SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow());
					pClientWindow->TitleButtonClick( TITLE_BUTTON_MENU );
				}
			}
			else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_HIDE )
			{
				pData->mnHideState |= BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_HIDE );
			}
			else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_HELP )
			{
				pData->mnHelpState |= BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_HELP );
			}
			else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_PIN )
			{
				pData->mnPinState |= BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_PIN );
			}
			else
			{
				if ( rMEvt.GetClicks() == 1 )
				{
					if ( bTracking )
					{
						Point	aPos		 = pBorderWindow->GetPosPixel();
						Size	aSize		 = pBorderWindow->GetOutputSizePixel();
						pData->mnTrackX 	 = aPos.X();
						pData->mnTrackY 	 = aPos.Y();
						pData->mnTrackWidth  = aSize.Width();
						pData->mnTrackHeight = aSize.Height();

						if ( pData->mnHitTest & BORDERWINDOW_HITTEST_TITLE )
							nDragFullTest = DRAGFULL_OPTION_WINDOWMOVE;
						else
							nDragFullTest = DRAGFULL_OPTION_WINDOWSIZE;
					}
				}
				else
				{
					bTracking = sal_False;

					if ( (pData->mnHitTest & BORDERWINDOW_DRAW_TITLE) &&
						 ((rMEvt.GetClicks() % 2) == 0) )
					{
						pData->mnHitTest = 0;
						bHitTest = sal_False;

						if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
						{
							SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow());
							if ( sal_True /*pBorderWindow->mbDockBtn*/ )   // always perform docking on double click, no button required
								pClientWindow->TitleButtonClick( TITLE_BUTTON_DOCKING );
							else if ( pBorderWindow->GetStyle() & WB_ROLLABLE )
							{
								if ( pClientWindow->IsRollUp() )
									pClientWindow->RollDown();
								else
									pClientWindow->RollUp();
								pClientWindow->Roll();
							}
						}
					}
				}
			}

			if ( bTracking )
			{
				pData->mbDragFull = sal_False;
				if ( nDragFullTest )
                    pData->mbDragFull = sal_True;   // always fulldrag for proper docking, ignore system settings
				pBorderWindow->StartTracking();
			}
			else if ( bHitTest )
				pData->mnHitTest = 0;
		}
	}

	return sal_True;
}

// -----------------------------------------------------------------------

sal_Bool ImplBorderWindowView::ImplTracking( ImplBorderFrameData* pData, const TrackingEvent& rTEvt )
{
	ImplBorderWindow* pBorderWindow = pData->mpBorderWindow;

	if ( rTEvt.IsTrackingEnded() )
	{
		sal_uInt16 nHitTest = pData->mnHitTest;
		pData->mnHitTest = 0;

		if ( nHitTest & BORDERWINDOW_HITTEST_CLOSE )
		{
			if ( pData->mnCloseState & BUTTON_DRAW_PRESSED )
			{
				pData->mnCloseState &= ~BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_CLOSE );

				// Bei Abbruch kein Click-Handler rufen
				if ( !rTEvt.IsTrackingCanceled() )
				{
                    // dispatch to correct window type (why is Close() not virtual ??? )
                    // TODO: make Close() virtual
                    Window *pWin = pBorderWindow->ImplGetClientWindow()->ImplGetWindow();
                    SystemWindow  *pSysWin  = dynamic_cast<SystemWindow* >(pWin);
                    DockingWindow *pDockWin = dynamic_cast<DockingWindow*>(pWin);
					if ( pSysWin )
                        pSysWin->Close();
					else if ( pDockWin )
                        pDockWin->Close();
				}
			}
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_ROLL )
		{
			if ( pData->mnRollState & BUTTON_DRAW_PRESSED )
			{
				pData->mnRollState &= ~BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_ROLL );

				// Bei Abbruch kein Click-Handler rufen
				if ( !rTEvt.IsTrackingCanceled() )
				{
					if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
					{
						SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow());
						if ( pClientWindow->IsRollUp() )
							pClientWindow->RollDown();
						else
							pClientWindow->RollUp();
						pClientWindow->Roll();
					}
				}
			}
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_DOCK )
		{
			if ( pData->mnDockState & BUTTON_DRAW_PRESSED )
			{
				pData->mnDockState &= ~BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_DOCK );

				// Bei Abbruch kein Click-Handler rufen
				if ( !rTEvt.IsTrackingCanceled() )
				{
					if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
					{
						SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow());
						pClientWindow->TitleButtonClick( TITLE_BUTTON_DOCKING );
					}
				}
			}
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_MENU )
		{
			if ( pData->mnMenuState & BUTTON_DRAW_PRESSED )
			{
				pData->mnMenuState &= ~BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_MENU );

                // handler already called on mouse down
			}
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_HIDE )
		{
			if ( pData->mnHideState & BUTTON_DRAW_PRESSED )
			{
				pData->mnHideState &= ~BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_HIDE );

				// Bei Abbruch kein Click-Handler rufen
				if ( !rTEvt.IsTrackingCanceled() )
				{
					if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
					{
						SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow());
						pClientWindow->TitleButtonClick( TITLE_BUTTON_HIDE );
					}
				}
			}
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_HELP )
		{
			if ( pData->mnHelpState & BUTTON_DRAW_PRESSED )
			{
				pData->mnHelpState &= ~BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_HELP );

				// Bei Abbruch kein Click-Handler rufen
				if ( !rTEvt.IsTrackingCanceled() )
				{
				}
			}
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_PIN )
		{
			if ( pData->mnPinState & BUTTON_DRAW_PRESSED )
			{
				pData->mnPinState &= ~BUTTON_DRAW_PRESSED;
				DrawWindow( BORDERWINDOW_DRAW_PIN );

				// Bei Abbruch kein Click-Handler rufen
				if ( !rTEvt.IsTrackingCanceled() )
				{
					if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
					{
						SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow());
						pClientWindow->SetPin( !pClientWindow->IsPined() );
						pClientWindow->Pin();
					}
				}
			}
		}
		else
		{
			if ( pData->mbDragFull )
			{
				// Bei Abbruch alten Zustand wieder herstellen
				if ( rTEvt.IsTrackingCanceled() )
					pBorderWindow->SetPosSizePixel( Point( pData->mnTrackX, pData->mnTrackY ), Size( pData->mnTrackWidth, pData->mnTrackHeight ) );
			}
			else
			{
				pBorderWindow->HideTracking();
				if ( !rTEvt.IsTrackingCanceled() )
					pBorderWindow->SetPosSizePixel( Point( pData->mnTrackX, pData->mnTrackY ), Size( pData->mnTrackWidth, pData->mnTrackHeight ) );
			}

			if ( !rTEvt.IsTrackingCanceled() )
			{
				if ( pBorderWindow->ImplGetClientWindow()->ImplIsFloatingWindow() )
				{
					if ( ((FloatingWindow*)pBorderWindow->ImplGetClientWindow())->IsInPopupMode() )
						((FloatingWindow*)pBorderWindow->ImplGetClientWindow())->EndPopupMode( FLOATWIN_POPUPMODEEND_TEAROFF );
				}
			}
		}
	}
	else if ( !rTEvt.GetMouseEvent().IsSynthetic() )
	{
		Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();

		if ( pData->mnHitTest & BORDERWINDOW_HITTEST_CLOSE )
		{
			if ( pData->maCloseRect.IsInside( aMousePos ) )
			{
				if ( !(pData->mnCloseState & BUTTON_DRAW_PRESSED) )
				{
					pData->mnCloseState |= BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_CLOSE );
				}
			}
			else
			{
				if ( pData->mnCloseState & BUTTON_DRAW_PRESSED )
				{
					pData->mnCloseState &= ~BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_CLOSE );
				}
			}
		}
		else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_ROLL )
		{
			if ( pData->maRollRect.IsInside( aMousePos ) )
			{
				if ( !(pData->mnRollState & BUTTON_DRAW_PRESSED) )
				{
					pData->mnRollState |= BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_ROLL );
				}
			}
			else
			{
				if ( pData->mnRollState & BUTTON_DRAW_PRESSED )
				{
					pData->mnRollState &= ~BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_ROLL );
				}
			}
		}
		else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_DOCK )
		{
			if ( pData->maDockRect.IsInside( aMousePos ) )
			{
				if ( !(pData->mnDockState & BUTTON_DRAW_PRESSED) )
				{
					pData->mnDockState |= BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_DOCK );
				}
			}
			else
			{
				if ( pData->mnDockState & BUTTON_DRAW_PRESSED )
				{
					pData->mnDockState &= ~BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_DOCK );
				}
			}
		}
		else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_MENU )
		{
			if ( pData->maMenuRect.IsInside( aMousePos ) )
			{
				if ( !(pData->mnMenuState & BUTTON_DRAW_PRESSED) )
				{
					pData->mnMenuState |= BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_MENU );

				}
			}
			else
			{
				if ( pData->mnMenuState & BUTTON_DRAW_PRESSED )
				{
					pData->mnMenuState &= ~BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_MENU );
				}
			}
		}
		else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_HIDE )
		{
			if ( pData->maHideRect.IsInside( aMousePos ) )
			{
				if ( !(pData->mnHideState & BUTTON_DRAW_PRESSED) )
				{
					pData->mnHideState |= BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_HIDE );
				}
			}
			else
			{
				if ( pData->mnHideState & BUTTON_DRAW_PRESSED )
				{
					pData->mnHideState &= ~BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_HIDE );
				}
			}
		}
		else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_HELP )
		{
			if ( pData->maHelpRect.IsInside( aMousePos ) )
			{
				if ( !(pData->mnHelpState & BUTTON_DRAW_PRESSED) )
				{
					pData->mnHelpState |= BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_HELP );
				}
			}
			else
			{
				if ( pData->mnHelpState & BUTTON_DRAW_PRESSED )
				{
					pData->mnHelpState &= ~BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_HELP );
				}
			}
		}
		else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_PIN )
		{
			if ( pData->maPinRect.IsInside( aMousePos ) )
			{
				if ( !(pData->mnPinState & BUTTON_DRAW_PRESSED) )
				{
					pData->mnPinState |= BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_PIN );
				}
			}
			else
			{
				if ( pData->mnPinState & BUTTON_DRAW_PRESSED )
				{
					pData->mnPinState &= ~BUTTON_DRAW_PRESSED;
					DrawWindow( BORDERWINDOW_DRAW_PIN );
				}
			}
		}
		else
		{
            /*
            // adjusting mousepos not required, we allow the whole screen (no desktop anymore...)
			Point	aFrameMousePos = pBorderWindow->ImplOutputToFrame( aMousePos );
			Size	aFrameSize = pBorderWindow->ImplGetFrameWindow()->GetOutputSizePixel();
			if ( aFrameMousePos.X() < 0 )
				aFrameMousePos.X() = 0;
			if ( aFrameMousePos.Y() < 0 )
				aFrameMousePos.Y() = 0;
			if ( aFrameMousePos.X() > aFrameSize.Width()-1 )
				aFrameMousePos.X() = aFrameSize.Width()-1;
			if ( aFrameMousePos.Y() > aFrameSize.Height()-1 )
				aFrameMousePos.Y() = aFrameSize.Height()-1;
			aMousePos = pBorderWindow->ImplFrameToOutput( aFrameMousePos );
            */

			aMousePos.X()	 -= pData->maMouseOff.X();
			aMousePos.Y()	 -= pData->maMouseOff.Y();

			if ( pData->mnHitTest & BORDERWINDOW_HITTEST_TITLE )
			{
	            pData->mpBorderWindow->SetPointer( Pointer( POINTER_MOVE ) );

				Point aPos = pBorderWindow->GetPosPixel();
				aPos.X() += aMousePos.X();
				aPos.Y() += aMousePos.Y();
				if ( pData->mbDragFull )
				{
					pBorderWindow->SetPosPixel( aPos );
					pBorderWindow->ImplUpdateAll();
					pBorderWindow->ImplGetFrameWindow()->ImplUpdateAll();
				}
				else
				{
					pData->mnTrackX = aPos.X();
					pData->mnTrackY = aPos.Y();
					pBorderWindow->ShowTracking( Rectangle( pBorderWindow->ScreenToOutputPixel( aPos ), pBorderWindow->GetOutputSizePixel() ), SHOWTRACK_BIG );
				}
			}
			else
			{
				Point		aOldPos			= pBorderWindow->GetPosPixel();
				Size		aSize			= pBorderWindow->GetSizePixel();
				Rectangle	aNewRect( aOldPos, aSize );
				long		nOldWidth		= aSize.Width();
				long		nOldHeight		= aSize.Height();
				long		nBorderWidth	= pData->mnLeftBorder+pData->mnRightBorder;
				long		nBorderHeight	= pData->mnTopBorder+pData->mnBottomBorder;
				long		nMinWidth		= pBorderWindow->mnMinWidth+nBorderWidth;
				long		nMinHeight		= pBorderWindow->mnMinHeight+nBorderHeight;
				long		nMinWidth2		= nBorderWidth;
				long		nMaxWidth		= pBorderWindow->mnMaxWidth+nBorderWidth;
				long		nMaxHeight		= pBorderWindow->mnMaxHeight+nBorderHeight;

				if ( pData->mnTitleHeight )
				{
					nMinWidth2 += 4;

					if ( pBorderWindow->GetStyle() & WB_CLOSEABLE )
						nMinWidth2 += pData->maCloseRect.GetWidth();
				}
				if ( nMinWidth2 > nMinWidth )
					nMinWidth = nMinWidth2;
				if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_LEFT | BORDERWINDOW_HITTEST_TOPLEFT | BORDERWINDOW_HITTEST_BOTTOMLEFT) )
				{
					aNewRect.Left() += aMousePos.X();
					if ( aNewRect.GetWidth() < nMinWidth )
						aNewRect.Left() = aNewRect.Right()-nMinWidth+1;
					else if ( aNewRect.GetWidth() > nMaxWidth )
						aNewRect.Left() = aNewRect.Right()-nMaxWidth+1;
				}
				else if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_RIGHT | BORDERWINDOW_HITTEST_TOPRIGHT | BORDERWINDOW_HITTEST_BOTTOMRIGHT) )
				{
					aNewRect.Right() += aMousePos.X();
					if ( aNewRect.GetWidth() < nMinWidth )
						aNewRect.Right() = aNewRect.Left()+nMinWidth+1;
					else if ( aNewRect.GetWidth() > nMaxWidth )
						aNewRect.Right() = aNewRect.Left()+nMaxWidth+1;
				}
				if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_TOP | BORDERWINDOW_HITTEST_TOPLEFT | BORDERWINDOW_HITTEST_TOPRIGHT) )
				{
					aNewRect.Top() += aMousePos.Y();
					if ( aNewRect.GetHeight() < nMinHeight )
						aNewRect.Top() = aNewRect.Bottom()-nMinHeight+1;
					else if ( aNewRect.GetHeight() > nMaxHeight )
						aNewRect.Top() = aNewRect.Bottom()-nMaxHeight+1;
				}
				else if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_BOTTOM | BORDERWINDOW_HITTEST_BOTTOMLEFT | BORDERWINDOW_HITTEST_BOTTOMRIGHT) )
				{
					aNewRect.Bottom() += aMousePos.Y();
					if ( aNewRect.GetHeight() < nMinHeight )
						aNewRect.Bottom() = aNewRect.Top()+nMinHeight+1;
					else if ( aNewRect.GetHeight() > nMaxHeight )
						aNewRect.Bottom() = aNewRect.Top()+nMaxHeight+1;
				}

				// call Resizing-Handler for SystemWindows
				if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
				{
					// adjust size for Resizing-call
					aSize = aNewRect.GetSize();
					aSize.Width()	-= nBorderWidth;
					aSize.Height()	-= nBorderHeight;
					((SystemWindow*)pBorderWindow->ImplGetClientWindow())->Resizing( aSize );
					aSize.Width()	+= nBorderWidth;
					aSize.Height()	+= nBorderHeight;
					if ( aSize.Width() < nMinWidth )
						aSize.Width() = nMinWidth;
					if ( aSize.Height() < nMinHeight )
						aSize.Height() = nMinHeight;
					if ( aSize.Width() > nMaxWidth )
						aSize.Width() = nMaxWidth;
					if ( aSize.Height() > nMaxHeight )
						aSize.Height() = nMaxHeight;
					if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_LEFT | BORDERWINDOW_HITTEST_TOPLEFT | BORDERWINDOW_HITTEST_BOTTOMLEFT) )
						aNewRect.Left() = aNewRect.Right()-aSize.Width()+1;
					else
						aNewRect.Right() = aNewRect.Left()+aSize.Width()-1;
					if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_TOP | BORDERWINDOW_HITTEST_TOPLEFT | BORDERWINDOW_HITTEST_TOPRIGHT) )
						aNewRect.Top() = aNewRect.Bottom()-aSize.Height()+1;
					else
						aNewRect.Bottom() = aNewRect.Top()+aSize.Height()-1;
				}

				if ( pData->mbDragFull )
				{
                    // no move (only resize) if position did not change
                    if( aOldPos != aNewRect.TopLeft() )
					    pBorderWindow->SetPosSizePixel( aNewRect.Left(), aNewRect.Top(),
													aNewRect.GetWidth(), aNewRect.GetHeight(), WINDOW_POSSIZE_POSSIZE );
                    else
					    pBorderWindow->SetPosSizePixel( aNewRect.Left(), aNewRect.Top(),
													aNewRect.GetWidth(), aNewRect.GetHeight(), WINDOW_POSSIZE_SIZE );

					pBorderWindow->ImplUpdateAll();
					pBorderWindow->ImplGetFrameWindow()->ImplUpdateAll();
					if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_RIGHT | BORDERWINDOW_HITTEST_TOPRIGHT | BORDERWINDOW_HITTEST_BOTTOMRIGHT) )
						pData->maMouseOff.X() += aNewRect.GetWidth()-nOldWidth;
					if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_BOTTOM | BORDERWINDOW_HITTEST_BOTTOMLEFT | BORDERWINDOW_HITTEST_BOTTOMRIGHT) )
						pData->maMouseOff.Y() += aNewRect.GetHeight()-nOldHeight;
				}
				else
				{
					pData->mnTrackX 	   = aNewRect.Left();
					pData->mnTrackY 	   = aNewRect.Top();
					pData->mnTrackWidth    = aNewRect.GetWidth();
					pData->mnTrackHeight   = aNewRect.GetHeight();
					pBorderWindow->ShowTracking( Rectangle( pBorderWindow->ScreenToOutputPixel( aNewRect.TopLeft() ), aNewRect.GetSize() ), SHOWTRACK_BIG );
				}
			}
		}
	}

	return sal_True;
}

// -----------------------------------------------------------------------

String ImplBorderWindowView::ImplRequestHelp( ImplBorderFrameData* pData,
											  const Point& rPos,
											  Rectangle& rHelpRect )
{
	sal_uInt16 nHelpId = 0;
    String aHelpStr;
	sal_uInt16 nHitTest = ImplHitTest( pData, rPos );
	if ( nHitTest )
	{
		if ( nHitTest & BORDERWINDOW_HITTEST_CLOSE )
		{
			nHelpId 	= SV_HELPTEXT_CLOSE;
			rHelpRect	= pData->maCloseRect;
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_ROLL )
		{
			if ( pData->mpBorderWindow->mbRollUp )
				nHelpId = SV_HELPTEXT_ROLLDOWN;
			else
				nHelpId = SV_HELPTEXT_ROLLUP;
			rHelpRect	= pData->maRollRect;
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_DOCK )
		{
			nHelpId 	= SV_HELPTEXT_MAXIMIZE;
			rHelpRect	= pData->maDockRect;
		}
        /* no help string available
		else if ( nHitTest & BORDERWINDOW_HITTEST_MENU )
		{
			nHelpId 	= SV_HELPTEXT_MENU;
			rHelpRect	= pData->maMenuRect;
		}*/
		else if ( nHitTest & BORDERWINDOW_HITTEST_HIDE )
		{
			nHelpId 	= SV_HELPTEXT_MINIMIZE;
			rHelpRect	= pData->maHideRect;
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_HELP )
		{
			nHelpId 	= SV_HELPTEXT_HELP;
			rHelpRect	= pData->maHelpRect;
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_PIN )
		{
			nHelpId 	= SV_HELPTEXT_ALWAYSVISIBLE;
			rHelpRect	= pData->maPinRect;
		}
		else if ( nHitTest & BORDERWINDOW_HITTEST_TITLE )
        {
            if( !pData->maTitleRect.IsEmpty() )
            {
                // tooltip only if title truncated
                if( pData->mbTitleClipped )
                {
			        rHelpRect	= pData->maTitleRect;
                    // no help id, use window title as help string
                    aHelpStr    = pData->mpBorderWindow->GetText();
                }
            }
        }
	}

    if( nHelpId && ImplGetResMgr() )
	    aHelpStr = String( ResId( nHelpId, *ImplGetResMgr() ) );

    return aHelpStr;
}

// -----------------------------------------------------------------------

long ImplBorderWindowView::ImplCalcTitleWidth( const ImplBorderFrameData* pData ) const
{
	// kein sichtbarer Title, dann auch keine Breite
	if ( !pData->mnTitleHeight )
		return 0;

	ImplBorderWindow* pBorderWindow = pData->mpBorderWindow;
	long nTitleWidth = pBorderWindow->GetTextWidth( pBorderWindow->GetText() )+6;
	nTitleWidth += pData->maPinRect.GetWidth();
	nTitleWidth += pData->maCloseRect.GetWidth();
	nTitleWidth += pData->maRollRect.GetWidth();
	nTitleWidth += pData->maDockRect.GetWidth();
	nTitleWidth += pData->maMenuRect.GetWidth();
	nTitleWidth += pData->maHideRect.GetWidth();
	nTitleWidth += pData->maHelpRect.GetWidth();
	nTitleWidth += pData->mnLeftBorder+pData->mnRightBorder;
	return nTitleWidth;
}

// =======================================================================

// --------------------------
// - ImplNoBorderWindowView -
// --------------------------

ImplNoBorderWindowView::ImplNoBorderWindowView( ImplBorderWindow* )
{
}

// -----------------------------------------------------------------------

void ImplNoBorderWindowView::Init( OutputDevice*, long, long )
{
}

// -----------------------------------------------------------------------

void ImplNoBorderWindowView::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
										sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
{
	rLeftBorder 	= 0;
	rTopBorder		= 0;
	rRightBorder	= 0;
	rBottomBorder	= 0;
}

// -----------------------------------------------------------------------

long ImplNoBorderWindowView::CalcTitleWidth() const
{
	return 0;
}

// -----------------------------------------------------------------------

void ImplNoBorderWindowView::DrawWindow( sal_uInt16, OutputDevice*, const Point* )
{
}

// =======================================================================

// -----------------------------
// - ImplSmallBorderWindowView -
// -----------------------------

// =======================================================================

ImplSmallBorderWindowView::ImplSmallBorderWindowView( ImplBorderWindow* pBorderWindow )
{
	mpBorderWindow = pBorderWindow;
}

// -----------------------------------------------------------------------

void ImplSmallBorderWindowView::Init( OutputDevice* pDev, long nWidth, long nHeight )
{
	mpOutDev	= pDev;
	mnWidth 	= nWidth;
	mnHeight	= nHeight;
    mbNWFBorder = false;

	sal_uInt16 nBorderStyle = mpBorderWindow->GetBorderStyle();
	if ( nBorderStyle & WINDOW_BORDER_NOBORDER )
	{
		mnLeftBorder	= 0;
		mnTopBorder 	= 0;
		mnRightBorder	= 0;
		mnBottomBorder	= 0;
	}
	else
	{
        // FIXME: this is currently only on aqua, check with other
        // platforms
        if( ImplGetSVData()->maNWFData.mbNoFocusRects )
        {
            // for native widget drawing we must find out what
            // control this border belongs to
            Window *pWin = NULL, *pCtrl = NULL;
            if( mpOutDev->GetOutDevType() == OUTDEV_WINDOW )
                pWin = (Window*) mpOutDev;

            ControlType aCtrlType = 0;
            if( pWin && (pCtrl = mpBorderWindow->GetWindow( WINDOW_CLIENT )) != NULL )
            {
                switch( pCtrl->GetType() )
                {
                    case WINDOW_LISTBOX:
                        if( pCtrl->GetStyle() & WB_DROPDOWN )
                        {
                            aCtrlType = CTRL_LISTBOX;
                            mbNWFBorder = true;
                        }
                        break;
                    case WINDOW_COMBOBOX:
                        if( pCtrl->GetStyle() & WB_DROPDOWN )
                        {
                            aCtrlType = CTRL_COMBOBOX;
                            mbNWFBorder = true;
                        }
                        break;
                    case WINDOW_MULTILINEEDIT:
                        aCtrlType = CTRL_MULTILINE_EDITBOX;
                        mbNWFBorder = true;
                        break;
                    case WINDOW_EDIT:
                    case WINDOW_PATTERNFIELD:
                    case WINDOW_METRICFIELD:
                    case WINDOW_CURRENCYFIELD:
                    case WINDOW_DATEFIELD:
                    case WINDOW_TIMEFIELD:
                    case WINDOW_LONGCURRENCYFIELD:
                    case WINDOW_NUMERICFIELD:
                    case WINDOW_SPINFIELD:
                        mbNWFBorder = true;
                        aCtrlType = (pCtrl->GetStyle() & WB_SPIN) ? CTRL_SPINBOX : CTRL_EDITBOX;
                        break;
                    default:
                        break;
                }
            }
            if( mbNWFBorder )
            {
                ImplControlValue aControlValue;
                Rectangle aCtrlRegion( (const Point&)Point(), Size( mnWidth < 10 ? 10 : mnWidth, mnHeight < 10 ? 10 : mnHeight ) );
                Rectangle aBounds( aCtrlRegion );
                Rectangle aContent( aCtrlRegion );
                if( pWin->GetNativeControlRegion( aCtrlType, PART_ENTIRE_CONTROL, aCtrlRegion,
                                                  CTRL_STATE_ENABLED, aControlValue, rtl::OUString(),
                                                  aBounds, aContent ) )
                {
                    mnLeftBorder    = aContent.Left() - aBounds.Left();
                    mnRightBorder   = aBounds.Right() - aContent.Right();
                    mnTopBorder     = aContent.Top() - aBounds.Top();
                    mnBottomBorder  = aBounds.Bottom() - aContent.Bottom();
                    if( mnWidth && mnHeight )
                    {

                        mpBorderWindow->SetPaintTransparent( sal_True );
                        mpBorderWindow->SetBackground();
                        pCtrl->SetPaintTransparent( sal_True );

                        Window* pCompoundParent = NULL;
                        if( pWin->GetParent() && pWin->GetParent()->IsCompoundControl() )
                            pCompoundParent = pWin->GetParent();

                        if( pCompoundParent )
                            pCompoundParent->SetPaintTransparent( sal_True );

                        if( mnWidth < aBounds.GetWidth() || mnHeight < aBounds.GetHeight() )
                        {
                            if( ! pCompoundParent ) // compound controls have to fix themselves
                            {
                                Point aPos( mpBorderWindow->GetPosPixel() );
                                if( mnWidth < aBounds.GetWidth() )
                                    aPos.X() -= (aBounds.GetWidth() - mnWidth) / 2;
                                if( mnHeight < aBounds.GetHeight() )
                                    aPos.Y() -= (aBounds.GetHeight() - mnHeight) / 2;
                                mpBorderWindow->SetPosSizePixel( aPos, aBounds.GetSize() );
                            }
                        }
                    }
                }
                else
                    mbNWFBorder = false;
            }
        }

        if( ! mbNWFBorder )
        {
            sal_uInt16 nStyle = FRAME_DRAW_NODRAW;
            // Wenn Border umgesetzt wurde oder BorderWindow ein Frame-Fenster
            // ist, dann Border nach aussen
            if ( (nBorderStyle & WINDOW_BORDER_DOUBLEOUT) || mpBorderWindow->mbSmallOutBorder )
                nStyle |= FRAME_DRAW_DOUBLEOUT;
            else
                nStyle |= FRAME_DRAW_DOUBLEIN;
            if ( nBorderStyle & WINDOW_BORDER_MONO )
                nStyle |= FRAME_DRAW_MONO;

            DecorationView	aDecoView( mpOutDev );
            Rectangle		aRect( 0, 0, 10, 10 );
            Rectangle		aCalcRect = aDecoView.DrawFrame( aRect, nStyle );
            mnLeftBorder	= aCalcRect.Left();
            mnTopBorder 	= aCalcRect.Top();
            mnRightBorder	= aRect.Right()-aCalcRect.Right();
            mnBottomBorder	= aRect.Bottom()-aCalcRect.Bottom();
        }
	}
}

// -----------------------------------------------------------------------

void ImplSmallBorderWindowView::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
										   sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
{
	rLeftBorder 	= mnLeftBorder;
	rTopBorder		= mnTopBorder;
	rRightBorder	= mnRightBorder;
	rBottomBorder	= mnBottomBorder;
}

// -----------------------------------------------------------------------

long ImplSmallBorderWindowView::CalcTitleWidth() const
{
	return 0;
}

// -----------------------------------------------------------------------

void ImplSmallBorderWindowView::DrawWindow( sal_uInt16 nDrawFlags, OutputDevice*, const Point* )
{
	sal_uInt16 nBorderStyle = mpBorderWindow->GetBorderStyle();
	if ( nBorderStyle & WINDOW_BORDER_NOBORDER )
		return;

    sal_Bool bNativeOK = sal_False;
    // for native widget drawing we must find out what
    // control this border belongs to
    Window *pWin = NULL, *pCtrl = NULL;
    if( mpOutDev->GetOutDevType() == OUTDEV_WINDOW )
        pWin = (Window*) mpOutDev;

    ControlType aCtrlType = 0;
    ControlPart aCtrlPart = PART_ENTIRE_CONTROL;

    if( pWin && (pCtrl = mpBorderWindow->GetWindow( WINDOW_CLIENT )) != NULL )
    {
        switch( pCtrl->GetType() )
        {
            case WINDOW_MULTILINEEDIT:
                aCtrlType = CTRL_MULTILINE_EDITBOX;
                break;
            case WINDOW_EDIT:
            case WINDOW_PATTERNFIELD:
            case WINDOW_METRICFIELD:
            case WINDOW_CURRENCYFIELD:
            case WINDOW_DATEFIELD:
            case WINDOW_TIMEFIELD:
            case WINDOW_LONGCURRENCYFIELD:
            case WINDOW_NUMERICFIELD:
            case WINDOW_SPINFIELD:
                if( pCtrl->GetStyle() & WB_SPIN )
                    aCtrlType = CTRL_SPINBOX;
                else
                    aCtrlType = CTRL_EDITBOX;
                break;

            case WINDOW_LISTBOX:
            case WINDOW_MULTILISTBOX:
            case WINDOW_TREELISTBOX:
                aCtrlType = CTRL_LISTBOX;
                if( pCtrl->GetStyle() & WB_DROPDOWN )
                    aCtrlPart = PART_ENTIRE_CONTROL;
                else
                    aCtrlPart = PART_WINDOW;
                break;

            case WINDOW_LISTBOXWINDOW:
                aCtrlType = CTRL_LISTBOX;
                aCtrlPart = PART_WINDOW;
                break;

            case WINDOW_COMBOBOX:
            case WINDOW_PATTERNBOX:
            case WINDOW_NUMERICBOX:
            case WINDOW_METRICBOX:
            case WINDOW_CURRENCYBOX:
            case WINDOW_DATEBOX:
            case WINDOW_TIMEBOX:
            case WINDOW_LONGCURRENCYBOX:
                if( pCtrl->GetStyle() & WB_DROPDOWN )
                {
                    aCtrlType = CTRL_COMBOBOX;
                    aCtrlPart = PART_ENTIRE_CONTROL;
                }
                else
                {
                    aCtrlType = CTRL_LISTBOX;
                    aCtrlPart = PART_WINDOW;
                }
                break;

            default:
                break;
        }
    }

    if ( aCtrlType && pCtrl->IsNativeControlSupported(aCtrlType, aCtrlPart) )
    {
        ImplControlValue aControlValue;
        ControlState     nState = CTRL_STATE_ENABLED;

        if ( !pWin->IsEnabled() )
            nState &= ~CTRL_STATE_ENABLED;
        if ( pWin->HasFocus() )
            nState |= CTRL_STATE_FOCUSED;
        else if( mbNWFBorder )
        {
            // FIXME: this is curently only on aqua, see if other platforms can profit

            // FIXME: for aqua focus rings all controls need to support GetNativeControlRegion
            // for the dropdown style
            if( pCtrl->HasFocus() || pCtrl->HasChildPathFocus() )
                nState |= CTRL_STATE_FOCUSED;
        }

        sal_Bool bMouseOver = sal_False;
        Window *pCtrlChild = pCtrl->GetWindow( WINDOW_FIRSTCHILD );
        while( pCtrlChild && (bMouseOver = pCtrlChild->IsMouseOver()) == sal_False )
            pCtrlChild = pCtrlChild->GetWindow( WINDOW_NEXT );

        if( bMouseOver )
            nState |= CTRL_STATE_ROLLOVER;

        Point aPoint;
        Rectangle aCtrlRegion( aPoint, Size( mnWidth, mnHeight ) );

        Rectangle aBoundingRgn( aPoint, Size( mnWidth, mnHeight ) );
        Rectangle aContentRgn( aCtrlRegion );
        if( ! ImplGetSVData()->maNWFData.mbCanDrawWidgetAnySize &&
            pWin->GetNativeControlRegion( aCtrlType, aCtrlPart, aCtrlRegion,
                                          nState, aControlValue, rtl::OUString(),
                                          aBoundingRgn, aContentRgn ))
        {
            aCtrlRegion=aContentRgn;
        }

        bNativeOK = pWin->DrawNativeControl( aCtrlType, aCtrlPart, aCtrlRegion, nState,
                aControlValue, rtl::OUString() );

        // if the native theme draws the spinbuttons in one call, make sure the proper settings
        // are passed, this might force a redraw though.... (TODO: improve)
        if ( (aCtrlType == CTRL_SPINBOX) && !pCtrl->IsNativeControlSupported( CTRL_SPINBOX, PART_BUTTON_UP ) )
        {
            Edit *pEdit = ((Edit*) pCtrl)->GetSubEdit();
            if ( pEdit )
                pCtrl->Paint( Rectangle() );  // make sure the buttons are also drawn as they might overwrite the border
        }
    }

    if( bNativeOK )
        return;

	if ( nDrawFlags & BORDERWINDOW_DRAW_FRAME )
	{
		if ( nBorderStyle & WINDOW_BORDER_ACTIVE )
		{
			Color aColor = mpOutDev->GetSettings().GetStyleSettings().GetHighlightColor();
			mpOutDev->SetLineColor();
			mpOutDev->SetFillColor( aColor );
			mpOutDev->DrawRect( Rectangle( 0, 0, mnWidth-1, mnTopBorder ) );
			mpOutDev->DrawRect( Rectangle( 0, mnHeight-mnBottomBorder, mnWidth-1, mnHeight-1 ) );
			mpOutDev->DrawRect( Rectangle( 0, 0, mnLeftBorder, mnHeight-1 ) );
			mpOutDev->DrawRect( Rectangle( mnWidth-mnRightBorder, 0, mnWidth-1, mnHeight-1 ) );
		}
		else
		{
			sal_uInt16 nStyle = 0;
			// Wenn Border umgesetzt wurde oder BorderWindow ein Frame-Fenster
			// ist, dann Border nach aussen
			if ( (nBorderStyle & WINDOW_BORDER_DOUBLEOUT) || mpBorderWindow->mbSmallOutBorder )
				nStyle |= FRAME_DRAW_DOUBLEOUT;
			else
				nStyle |= FRAME_DRAW_DOUBLEIN;
			if ( nBorderStyle & WINDOW_BORDER_MONO )
				nStyle |= FRAME_DRAW_MONO;
			if ( nBorderStyle & WINDOW_BORDER_MENU )
				nStyle |= FRAME_DRAW_MENU;
            // tell DrawFrame that we're drawing a window border of a frame window to avoid round corners
            if( pWin && pWin == pWin->ImplGetFrameWindow() )
                nStyle |= FRAME_DRAW_WINDOWBORDER;

            DecorationView	aDecoView( mpOutDev );
			Point			aTmpPoint;
			Rectangle		aInRect( aTmpPoint, Size( mnWidth, mnHeight ) );
			aDecoView.DrawFrame( aInRect, nStyle );
		}
	}
}

// =======================================================================

// ---------------------------
// - ImplStdBorderWindowView -
// ---------------------------

ImplStdBorderWindowView::ImplStdBorderWindowView( ImplBorderWindow* pBorderWindow )
{
	maFrameData.mpBorderWindow	= pBorderWindow;
	maFrameData.mbDragFull		= sal_False;
	maFrameData.mnHitTest		= 0;
	maFrameData.mnPinState		= 0;
	maFrameData.mnCloseState	= 0;
	maFrameData.mnRollState 	= 0;
	maFrameData.mnDockState 	= 0;
	maFrameData.mnMenuState 	= 0;
	maFrameData.mnHideState 	= 0;
	maFrameData.mnHelpState 	= 0;
	maFrameData.mbTitleClipped 	= 0;

	mpATitleVirDev				= NULL;
	mpDTitleVirDev				= NULL;
}

// -----------------------------------------------------------------------

ImplStdBorderWindowView::~ImplStdBorderWindowView()
{
	if ( mpATitleVirDev )
		delete mpATitleVirDev;
	if ( mpDTitleVirDev )
		delete mpDTitleVirDev;
}

// -----------------------------------------------------------------------

sal_Bool ImplStdBorderWindowView::MouseMove( const MouseEvent& rMEvt )
{
	return ImplMouseMove( &maFrameData, rMEvt );
}

// -----------------------------------------------------------------------

sal_Bool ImplStdBorderWindowView::MouseButtonDown( const MouseEvent& rMEvt )
{
	return ImplMouseButtonDown( &maFrameData, rMEvt );
}

// -----------------------------------------------------------------------

sal_Bool ImplStdBorderWindowView::Tracking( const TrackingEvent& rTEvt )
{
	return ImplTracking( &maFrameData, rTEvt );
}

// -----------------------------------------------------------------------

String ImplStdBorderWindowView::RequestHelp( const Point& rPos, Rectangle& rHelpRect )
{
	return ImplRequestHelp( &maFrameData, rPos, rHelpRect );
}

// -----------------------------------------------------------------------

Rectangle ImplStdBorderWindowView::GetMenuRect() const
{
    return maFrameData.maMenuRect;
}

// -----------------------------------------------------------------------

void ImplStdBorderWindowView::Init( OutputDevice* pDev, long nWidth, long nHeight )
{
	ImplBorderFrameData*	pData = &maFrameData;
	ImplBorderWindow*		pBorderWindow = maFrameData.mpBorderWindow;
	const StyleSettings&	rStyleSettings = pDev->GetSettings().GetStyleSettings();
	DecorationView			aDecoView( pDev );
	Rectangle				aRect( 0, 0, 10, 10 );
	Rectangle				aCalcRect = aDecoView.DrawFrame( aRect, FRAME_DRAW_DOUBLEOUT | FRAME_DRAW_NODRAW );

	pData->mpOutDev 		= pDev;
	pData->mnWidth			= nWidth;
	pData->mnHeight 		= nHeight;

	pData->mnTitleType		= pBorderWindow->mnTitleType;
	pData->mbFloatWindow	= pBorderWindow->mbFloatWindow;

	if ( !(pBorderWindow->GetStyle() & WB_MOVEABLE) || (pData->mnTitleType == BORDERWINDOW_TITLE_NONE) )
		pData->mnBorderSize = 0;
	else if ( pData->mnTitleType == BORDERWINDOW_TITLE_TEAROFF )
		pData->mnBorderSize = 0;
	else
		pData->mnBorderSize = rStyleSettings.GetBorderSize();
	pData->mnLeftBorder 	= aCalcRect.Left();
	pData->mnTopBorder		= aCalcRect.Top();
	pData->mnRightBorder	= aRect.Right()-aCalcRect.Right();
	pData->mnBottomBorder	= aRect.Bottom()-aCalcRect.Bottom();
	pData->mnLeftBorder    += pData->mnBorderSize;
	pData->mnTopBorder	   += pData->mnBorderSize;
	pData->mnRightBorder   += pData->mnBorderSize;
	pData->mnBottomBorder  += pData->mnBorderSize;
	pData->mnNoTitleTop 	= pData->mnTopBorder;

	ImplInitTitle( &maFrameData );
	if ( pData->mnTitleHeight )
	{
        // to improve symbol display force a minum title height
        if( pData->mnTitleHeight < MIN_CAPTION_HEIGHT )
            pData->mnTitleHeight = MIN_CAPTION_HEIGHT;

        // set a proper background for drawing
        // highlighted buttons in the title
        pBorderWindow->SetBackground( rStyleSettings.GetWindowColor() );

		pData->maTitleRect.Left()	 = pData->mnLeftBorder;
		pData->maTitleRect.Right()	 = nWidth-pData->mnRightBorder-1;
		pData->maTitleRect.Top()	 = pData->mnTopBorder;
		pData->maTitleRect.Bottom()  = pData->maTitleRect.Top()+pData->mnTitleHeight-1;

		if ( pData->mnTitleType & (BORDERWINDOW_TITLE_NORMAL | BORDERWINDOW_TITLE_SMALL) )
		{
			long nLeft			= pData->maTitleRect.Left();
			long nRight 		= pData->maTitleRect.Right();
			long nItemTop		= pData->maTitleRect.Top();
			long nItemBottom	= pData->maTitleRect.Bottom();
			nLeft			   += 1;
			nRight			   -= 3;
			nItemTop		   += 2;
			nItemBottom 	   -= 2;

			if ( pBorderWindow->GetStyle() & WB_PINABLE )
			{
				Image aImage;
				ImplGetPinImage( 0, 0, aImage );
				pData->maPinRect.Top()	  = nItemTop;
				pData->maPinRect.Bottom() = nItemBottom;
				pData->maPinRect.Left()   = nLeft;
				pData->maPinRect.Right()  = pData->maPinRect.Left()+aImage.GetSizePixel().Width();
				nLeft += pData->maPinRect.GetWidth()+3;
			}

			if ( pBorderWindow->GetStyle() & WB_CLOSEABLE )
			{
				pData->maCloseRect.Top()	= nItemTop;
				pData->maCloseRect.Bottom() = nItemBottom;
				pData->maCloseRect.Right()	= nRight;
				pData->maCloseRect.Left()	= pData->maCloseRect.Right()-pData->maCloseRect.GetHeight()+1;
				nRight -= pData->maCloseRect.GetWidth()+3;
			}

			if ( pBorderWindow->mbMenuBtn )
			{
				pData->maMenuRect.Top()    = nItemTop;
				pData->maMenuRect.Bottom() = nItemBottom;
				pData->maMenuRect.Right()  = nRight;
				pData->maMenuRect.Left()   = pData->maMenuRect.Right()-pData->maMenuRect.GetHeight()+1;
				nRight -= pData->maMenuRect.GetWidth();
			}

			if ( pBorderWindow->mbDockBtn )
			{
				pData->maDockRect.Top()    = nItemTop;
				pData->maDockRect.Bottom() = nItemBottom;
				pData->maDockRect.Right()  = nRight;
				pData->maDockRect.Left()   = pData->maDockRect.Right()-pData->maDockRect.GetHeight()+1;
				nRight -= pData->maDockRect.GetWidth();
				if ( !pBorderWindow->mbHideBtn &&
					 !(pBorderWindow->GetStyle() & WB_ROLLABLE) )
					nRight -= 3;
			}

			if ( pBorderWindow->mbHideBtn )
			{
				pData->maHideRect.Top()    = nItemTop;
				pData->maHideRect.Bottom() = nItemBottom;
				pData->maHideRect.Right()  = nRight;
				pData->maHideRect.Left()   = pData->maHideRect.Right()-pData->maHideRect.GetHeight()+1;
				nRight -= pData->maHideRect.GetWidth();
				if ( !(pBorderWindow->GetStyle() & WB_ROLLABLE) )
					nRight -= 3;
			}

			if ( pBorderWindow->GetStyle() & WB_ROLLABLE )
			{
				pData->maRollRect.Top()    = nItemTop;
				pData->maRollRect.Bottom() = nItemBottom;
				pData->maRollRect.Right()  = nRight;
				pData->maRollRect.Left()   = pData->maRollRect.Right()-pData->maRollRect.GetHeight()+1;
				nRight -= pData->maRollRect.GetWidth();
			}

			if ( pBorderWindow->mbHelpBtn )
			{
				pData->maHelpRect.Top()    = nItemTop;
				pData->maHelpRect.Bottom() = nItemBottom;
				pData->maHelpRect.Right()  = nRight;
				pData->maHelpRect.Left()   = pData->maHelpRect.Right()-pData->maHelpRect.GetHeight()+1;
				nRight -= pData->maHelpRect.GetWidth()+3;
			}
		}
		else
		{
			pData->maPinRect.SetEmpty();
			pData->maCloseRect.SetEmpty();
			pData->maDockRect.SetEmpty();
			pData->maMenuRect.SetEmpty();
			pData->maHideRect.SetEmpty();
			pData->maRollRect.SetEmpty();
			pData->maHelpRect.SetEmpty();
		}

		pData->mnTopBorder	+= pData->mnTitleHeight;
	}
	else
	{
		pData->maTitleRect.SetEmpty();
		pData->maPinRect.SetEmpty();
		pData->maCloseRect.SetEmpty();
		pData->maDockRect.SetEmpty();
		pData->maMenuRect.SetEmpty();
		pData->maHideRect.SetEmpty();
		pData->maRollRect.SetEmpty();
		pData->maHelpRect.SetEmpty();
	}
}

// -----------------------------------------------------------------------

void ImplStdBorderWindowView::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
										 sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
{
	rLeftBorder 	= maFrameData.mnLeftBorder;
	rTopBorder		= maFrameData.mnTopBorder;
	rRightBorder	= maFrameData.mnRightBorder;
	rBottomBorder	= maFrameData.mnBottomBorder;
}

// -----------------------------------------------------------------------

long ImplStdBorderWindowView::CalcTitleWidth() const
{
	return ImplCalcTitleWidth( &maFrameData );
}

// -----------------------------------------------------------------------

void ImplStdBorderWindowView::DrawWindow( sal_uInt16 nDrawFlags, OutputDevice* pOutDev, const Point* pOffset )
{
	ImplBorderFrameData*	pData = &maFrameData;
	OutputDevice*			pDev = pOutDev ? pOutDev : pData->mpOutDev;
	ImplBorderWindow*		pBorderWindow = pData->mpBorderWindow;
	Point					aTmpPoint = pOffset ? Point(*pOffset) : Point();
	Rectangle				aInRect( aTmpPoint, Size( pData->mnWidth, pData->mnHeight ) );
	const StyleSettings&	rStyleSettings = pData->mpOutDev->GetSettings().GetStyleSettings();
	DecorationView			aDecoView( pDev );
    Color                   aFrameColor( rStyleSettings.GetFaceColor() );

    aFrameColor.DecreaseContrast( (sal_uInt8) (0.50 * 255));

	// Draw Frame
	if ( nDrawFlags & BORDERWINDOW_DRAW_FRAME )
    {
        // single line frame
	    pDev->SetLineColor( aFrameColor );
        pDev->SetFillColor();
        pDev->DrawRect( aInRect );
        aInRect.nLeft++; aInRect.nRight--;
        aInRect.nTop++; aInRect.nBottom--;
    }
	else
	    aInRect = aDecoView.DrawFrame( aInRect, FRAME_DRAW_DOUBLEOUT | FRAME_DRAW_NODRAW);

	// Draw Border
	pDev->SetLineColor();
	long nBorderSize = pData->mnBorderSize;
	if ( (nDrawFlags & BORDERWINDOW_DRAW_BORDER) && nBorderSize )
	{
		pDev->SetFillColor( rStyleSettings.GetFaceColor() );
		pDev->DrawRect( Rectangle( Point( aInRect.Left(), aInRect.Top() ),
								   Size( aInRect.GetWidth(), nBorderSize ) ) );
		pDev->DrawRect( Rectangle( Point( aInRect.Left(), aInRect.Top()+nBorderSize ),
								   Size( nBorderSize, aInRect.GetHeight()-nBorderSize ) ) );
		pDev->DrawRect( Rectangle( Point( aInRect.Left(), aInRect.Bottom()-nBorderSize+1 ),
								   Size( aInRect.GetWidth(), nBorderSize ) ) );
		pDev->DrawRect( Rectangle( Point( aInRect.Right()-nBorderSize+1, aInRect.Top()+nBorderSize ),
								   Size( nBorderSize, aInRect.GetHeight()-nBorderSize ) ) );
	}

	// Draw Title
	if ( (nDrawFlags & BORDERWINDOW_DRAW_TITLE) && !pData->maTitleRect.IsEmpty() )
	{
		aInRect = pData->maTitleRect;

        // use no gradient anymore, just a static titlecolor
		pDev->SetFillColor( aFrameColor );
		pDev->SetTextColor( rStyleSettings.GetButtonTextColor() );
        Rectangle aTitleRect( pData->maTitleRect );
        if( pOffset )
            aTitleRect.Move( pOffset->X(), pOffset->Y() );
        pDev->DrawRect( aTitleRect );


		if ( pData->mnTitleType != BORDERWINDOW_TITLE_TEAROFF )
		{
			aInRect.Left()	+= 2;
			aInRect.Right() -= 2;

			if ( !pData->maPinRect.IsEmpty() )
				aInRect.Left() = pData->maPinRect.Right()+2;

			if ( !pData->maHelpRect.IsEmpty() )
				aInRect.Right() = pData->maHelpRect.Left()-2;
			else if ( !pData->maRollRect.IsEmpty() )
				aInRect.Right() = pData->maRollRect.Left()-2;
			else if ( !pData->maHideRect.IsEmpty() )
				aInRect.Right() = pData->maHideRect.Left()-2;
			else if ( !pData->maDockRect.IsEmpty() )
				aInRect.Right() = pData->maDockRect.Left()-2;
			else if ( !pData->maMenuRect.IsEmpty() )
				aInRect.Right() = pData->maMenuRect.Left()-2;
			else if ( !pData->maCloseRect.IsEmpty() )
				aInRect.Right() = pData->maCloseRect.Left()-2;

			if ( pOffset )
				aInRect.Move( pOffset->X(), pOffset->Y() );

            sal_uInt16 nTextStyle = TEXT_DRAW_LEFT | TEXT_DRAW_VCENTER | TEXT_DRAW_ENDELLIPSIS | TEXT_DRAW_CLIP;

            // must show tooltip ?
            TextRectInfo aInfo;
			pDev->GetTextRect( aInRect, pBorderWindow->GetText(), nTextStyle, &aInfo );
            pData->mbTitleClipped = aInfo.IsEllipses();

			pDev->DrawText( aInRect, pBorderWindow->GetText(), nTextStyle );
		}
	}

	if ( ((nDrawFlags & BORDERWINDOW_DRAW_CLOSE) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) &&
		 !pData->maCloseRect.IsEmpty() )
	{
		Rectangle aSymbolRect( pData->maCloseRect );
		if ( pOffset )
			aSymbolRect.Move( pOffset->X(), pOffset->Y() );
		ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_CLOSE, pData->mnCloseState );
	}
	if ( ((nDrawFlags & BORDERWINDOW_DRAW_DOCK) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) &&
		 !pData->maDockRect.IsEmpty() )
	{
		Rectangle aSymbolRect( pData->maDockRect );
		if ( pOffset )
			aSymbolRect.Move( pOffset->X(), pOffset->Y() );
		ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_DOCK, pData->mnDockState );
	}
	if ( ((nDrawFlags & BORDERWINDOW_DRAW_MENU) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) &&
		 !pData->maMenuRect.IsEmpty() )
	{
		Rectangle aSymbolRect( pData->maMenuRect );
		if ( pOffset )
			aSymbolRect.Move( pOffset->X(), pOffset->Y() );
		ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_MENU, pData->mnMenuState );
	}
	if ( ((nDrawFlags & BORDERWINDOW_DRAW_HIDE) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) &&
		 !pData->maHideRect.IsEmpty() )
	{
		Rectangle aSymbolRect( pData->maHideRect );
		if ( pOffset )
			aSymbolRect.Move( pOffset->X(), pOffset->Y() );
		ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_HIDE, pData->mnHideState );
	}
	if ( ((nDrawFlags & BORDERWINDOW_DRAW_ROLL) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) &&
		 !pData->maRollRect.IsEmpty() )
	{
		SymbolType eType;
		if ( pBorderWindow->mbRollUp )
			eType = SYMBOL_ROLLDOWN;
		else
			eType = SYMBOL_ROLLUP;
		Rectangle aSymbolRect( pData->maRollRect );
		if ( pOffset )
			aSymbolRect.Move( pOffset->X(), pOffset->Y() );
		ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, eType, pData->mnRollState );
	}

	if ( ((nDrawFlags & BORDERWINDOW_DRAW_HELP) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) &&
		 !pData->maHelpRect.IsEmpty() )
	{
		Rectangle aSymbolRect( pData->maHelpRect );
		if ( pOffset )
			aSymbolRect.Move( pOffset->X(), pOffset->Y() );
		ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_HELP, pData->mnHelpState );
	}
	if ( ((nDrawFlags & BORDERWINDOW_DRAW_PIN) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) &&
		 !pData->maPinRect.IsEmpty() )
	{
		Image aImage;
		ImplGetPinImage( pData->mnPinState, pBorderWindow->mbPined, aImage );
		Size  aImageSize = aImage.GetSizePixel();
		long  nRectHeight = pData->maPinRect.GetHeight();
		Point aPos( pData->maPinRect.TopLeft() );
		if ( pOffset )
			aPos.Move( pOffset->X(), pOffset->Y() );
		if ( nRectHeight < aImageSize.Height() )
		{
			pDev->DrawImage( aPos, Size( aImageSize.Width(), nRectHeight ), aImage );
		}
		else
		{
			aPos.Y() += (nRectHeight-aImageSize.Height())/2;
			pDev->DrawImage( aPos, aImage );
		}
	}
}


// =======================================================================
void ImplBorderWindow::ImplInit( Window* pParent,
								 WinBits nStyle, sal_uInt16 nTypeStyle,
								 const ::com::sun::star::uno::Any& )
{
	ImplInit( pParent, nStyle, nTypeStyle, NULL );
}

void ImplBorderWindow::ImplInit( Window* pParent,
								 WinBits nStyle, sal_uInt16 nTypeStyle,
								 SystemParentData* pSystemParentData
								 )
{
	// Alle WindowBits entfernen, die wir nicht haben wollen
	WinBits nOrgStyle = nStyle;
	WinBits nTestStyle = (WB_MOVEABLE | WB_SIZEABLE | WB_ROLLABLE | WB_PINABLE | WB_CLOSEABLE | WB_STANDALONE | WB_DIALOGCONTROL | WB_NODIALOGCONTROL | WB_SYSTEMFLOATWIN | WB_INTROWIN | WB_DEFAULTWIN | WB_TOOLTIPWIN | WB_NOSHADOW | WB_OWNERDRAWDECORATION | WB_SYSTEMCHILDWINDOW  | WB_NEEDSFOCUS);
	if ( nTypeStyle & BORDERWINDOW_STYLE_APP )
		nTestStyle |= WB_APP;
	nStyle &= nTestStyle;

	mpWindowImpl->mbBorderWin 		= sal_True;
	mbSmallOutBorder	= sal_False;
	if ( nTypeStyle & BORDERWINDOW_STYLE_FRAME )
	{
        if( (nStyle & WB_SYSTEMCHILDWINDOW) )
        {
            mpWindowImpl->mbOverlapWin  = sal_True;
            mpWindowImpl->mbFrame       = sal_True;
            mbFrameBorder               = sal_False;
        }
        else if( (nStyle & WB_OWNERDRAWDECORATION) )
        {
		    mpWindowImpl->mbOverlapWin	= sal_True;
		    mpWindowImpl->mbFrame 		= sal_True;
		    mbFrameBorder	= (nOrgStyle & WB_NOBORDER) ? sal_False : sal_True;
        }
        else
        {
		    mpWindowImpl->mbOverlapWin	= sal_True;
		    mpWindowImpl->mbFrame 		= sal_True;
		    mbFrameBorder	= sal_False;
            // closeable windows may have a border as well, eg. system floating windows without caption
		    if ( (nOrgStyle & (WB_BORDER | WB_NOBORDER | WB_MOVEABLE | WB_SIZEABLE/* | WB_CLOSEABLE*/)) == WB_BORDER )
			    mbSmallOutBorder = sal_True;
        }
	}
	else if ( nTypeStyle & BORDERWINDOW_STYLE_OVERLAP )
	{
		mpWindowImpl->mbOverlapWin	= sal_True;
		mbFrameBorder	= sal_True;
	}
	else
		mbFrameBorder	= sal_False;

	if ( nTypeStyle & BORDERWINDOW_STYLE_FLOAT )
		mbFloatWindow = sal_True;
	else
		mbFloatWindow = sal_False;

	Window::ImplInit( pParent, nStyle, pSystemParentData );
	SetBackground();
	SetTextFillColor();

	mpMenuBarWindow = NULL;
	mnMinWidth		= 0;
	mnMinHeight 	= 0;
	mnMaxWidth		= SHRT_MAX;
	mnMaxHeight 	= SHRT_MAX;
	mnRollHeight	= 0;
	mnOrgMenuHeight = 0;
	mbPined 		= sal_False;
	mbRollUp		= sal_False;
	mbMenuHide		= sal_False;
	mbDockBtn		= sal_False;
	mbMenuBtn		= sal_False;
	mbHideBtn		= sal_False;
	mbHelpBtn		= sal_False;
	mbDisplayActive = IsActive();

	if ( nTypeStyle & BORDERWINDOW_STYLE_FLOAT )
		mnTitleType = BORDERWINDOW_TITLE_SMALL;
	else
		mnTitleType = BORDERWINDOW_TITLE_NORMAL;
	mnBorderStyle	= WINDOW_BORDER_NORMAL;
	InitView();
}

// =======================================================================

ImplBorderWindow::ImplBorderWindow( Window* pParent,
									SystemParentData* pSystemParentData,
									WinBits nStyle, sal_uInt16 nTypeStyle
									) :	Window( WINDOW_BORDERWINDOW )
{
	ImplInit( pParent, nStyle, nTypeStyle, pSystemParentData );
}

// -----------------------------------------------------------------------

ImplBorderWindow::ImplBorderWindow( Window* pParent, WinBits nStyle ,
									sal_uInt16 nTypeStyle ) :
	Window( WINDOW_BORDERWINDOW )
{
	ImplInit( pParent, nStyle, nTypeStyle, ::com::sun::star::uno::Any() );
}

ImplBorderWindow::ImplBorderWindow( Window* pParent,
									WinBits nStyle, sal_uInt16 nTypeStyle,
									const ::com::sun::star::uno::Any& aSystemToken ) :
	Window( WINDOW_BORDERWINDOW )
{
	ImplInit( pParent, nStyle, nTypeStyle, aSystemToken );
}

// -----------------------------------------------------------------------

ImplBorderWindow::~ImplBorderWindow()
{
	delete mpBorderView;
}

// -----------------------------------------------------------------------

void ImplBorderWindow::MouseMove( const MouseEvent& rMEvt )
{
	mpBorderView->MouseMove( rMEvt );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::MouseButtonDown( const MouseEvent& rMEvt )
{
	mpBorderView->MouseButtonDown( rMEvt );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::Tracking( const TrackingEvent& rTEvt )
{
	mpBorderView->Tracking( rTEvt );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::Paint( const Rectangle& )
{
	mpBorderView->DrawWindow( BORDERWINDOW_DRAW_ALL );
}

void ImplBorderWindow::Draw( const Rectangle&, OutputDevice* pOutDev, const Point& rPos )
{
	mpBorderView->DrawWindow( BORDERWINDOW_DRAW_ALL, pOutDev, &rPos );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::Activate()
{
	SetDisplayActive( sal_True );
	Window::Activate();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::Deactivate()
{
	// Fenster die immer Active sind, nehmen wir von dieser Regel aus,
	// genauso, wenn ein Menu aktiv wird, ignorieren wir das Deactivate
	if ( GetActivateMode() && !ImplGetSVData()->maWinData.mbNoDeactivate )
		SetDisplayActive( sal_False );
	Window::Deactivate();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::RequestHelp( const HelpEvent& rHEvt )
{
	// no keyboard help for border win
	if ( rHEvt.GetMode() & (HELPMODE_BALLOON | HELPMODE_QUICK) && !rHEvt.KeyboardActivated() )
	{
		Point		aMousePosPixel = ScreenToOutputPixel( rHEvt.GetMousePosPixel() );
		Rectangle	aHelpRect;
		String      aHelpStr( mpBorderView->RequestHelp( aMousePosPixel, aHelpRect ) );

		// Rechteck ermitteln
		if ( aHelpStr.Len() )
		{
            aHelpRect.SetPos( OutputToScreenPixel( aHelpRect.TopLeft() ) );
			if ( rHEvt.GetMode() & HELPMODE_BALLOON )
				Help::ShowBalloon( this, aHelpRect.Center(), aHelpRect, aHelpStr );
			else
				Help::ShowQuickHelp( this, aHelpRect, aHelpStr );
			return;
		}
	}

	Window::RequestHelp( rHEvt );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::Resize()
{
	Size aSize = GetOutputSizePixel();

	if ( !mbRollUp )
	{
		Window* pClientWindow = ImplGetClientWindow();

		if ( mpMenuBarWindow )
		{
			sal_Int32 nLeftBorder;
			sal_Int32 nTopBorder;
			sal_Int32 nRightBorder;
			sal_Int32 nBottomBorder;
			long nMenuHeight = mpMenuBarWindow->GetSizePixel().Height();
			if ( mbMenuHide )
			{
				if ( nMenuHeight )
					mnOrgMenuHeight = nMenuHeight;
				nMenuHeight = 0;
			}
			else
			{
				if ( !nMenuHeight )
					nMenuHeight = mnOrgMenuHeight;
			}
			mpBorderView->GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder );
			mpMenuBarWindow->SetPosSizePixel( nLeftBorder,
											  nTopBorder,
											  aSize.Width()-nLeftBorder-nRightBorder,
											  nMenuHeight,
											  WINDOW_POSSIZE_POS |
											  WINDOW_POSSIZE_WIDTH | WINDOW_POSSIZE_HEIGHT );
		}

		GetBorder( pClientWindow->mpWindowImpl->mnLeftBorder, pClientWindow->mpWindowImpl->mnTopBorder,
				   pClientWindow->mpWindowImpl->mnRightBorder, pClientWindow->mpWindowImpl->mnBottomBorder );
		pClientWindow->ImplPosSizeWindow( pClientWindow->mpWindowImpl->mnLeftBorder,
										  pClientWindow->mpWindowImpl->mnTopBorder,
										  aSize.Width()-pClientWindow->mpWindowImpl->mnLeftBorder-pClientWindow->mpWindowImpl->mnRightBorder,
										  aSize.Height()-pClientWindow->mpWindowImpl->mnTopBorder-pClientWindow->mpWindowImpl->mnBottomBorder,
										  WINDOW_POSSIZE_X | WINDOW_POSSIZE_Y |
										  WINDOW_POSSIZE_WIDTH | WINDOW_POSSIZE_HEIGHT );
	}

	// UpdateView
	mpBorderView->Init( this, aSize.Width(), aSize.Height() );
	InvalidateBorder();

	Window::Resize();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::StateChanged( StateChangedType nType )
{
	if ( (nType == STATE_CHANGE_TEXT) ||
		 (nType == STATE_CHANGE_IMAGE) ||
		 (nType == STATE_CHANGE_DATA) )
	{
		if ( IsReallyVisible() && mbFrameBorder )
		{
			if ( HasPaintEvent() )
				InvalidateBorder();
			else
				mpBorderView->DrawWindow( BORDERWINDOW_DRAW_TITLE );
		}
	}

	Window::StateChanged( nType );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::DataChanged( const DataChangedEvent& rDCEvt )
{
	if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
		 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
		 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
		  (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
	{
		if ( !mpWindowImpl->mbFrame || (GetStyle() & WB_OWNERDRAWDECORATION) )
			UpdateView( sal_True, ImplGetWindow()->GetOutputSizePixel() );
	}

	Window::DataChanged( rDCEvt );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::InitView()
{
	if ( mbSmallOutBorder )
		mpBorderView = new ImplSmallBorderWindowView( this );
	else if ( mpWindowImpl->mbFrame )
    {
        if( mbFrameBorder )
		    mpBorderView = new ImplStdBorderWindowView( this );
        else
		    mpBorderView = new ImplNoBorderWindowView( this );
    }
	else if ( !mbFrameBorder )
		mpBorderView = new ImplSmallBorderWindowView( this );
	else
		mpBorderView = new ImplStdBorderWindowView( this );
	Size aSize = GetOutputSizePixel();
	mpBorderView->Init( this, aSize.Width(), aSize.Height() );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::UpdateView( sal_Bool bNewView, const Size& rNewOutSize )
{
	sal_Int32 nLeftBorder;
	sal_Int32 nTopBorder;
	sal_Int32 nRightBorder;
	sal_Int32 nBottomBorder;
	Size aOldSize = GetSizePixel();
	Size aOutputSize = rNewOutSize;

	if ( bNewView )
	{
		delete mpBorderView;
		InitView();
	}
	else
	{
		Size aSize = aOutputSize;
		mpBorderView->GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder );
		aSize.Width()  += nLeftBorder+nRightBorder;
		aSize.Height() += nTopBorder+nBottomBorder;
		mpBorderView->Init( this, aSize.Width(), aSize.Height() );
	}

	Window* pClientWindow = ImplGetClientWindow();
	if ( pClientWindow )
	{
		GetBorder( pClientWindow->mpWindowImpl->mnLeftBorder, pClientWindow->mpWindowImpl->mnTopBorder,
				   pClientWindow->mpWindowImpl->mnRightBorder, pClientWindow->mpWindowImpl->mnBottomBorder );
	}
	GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder );
	if ( aOldSize.Width() || aOldSize.Height() )
	{
		aOutputSize.Width() 	+= nLeftBorder+nRightBorder;
		aOutputSize.Height()	+= nTopBorder+nBottomBorder;
		if ( aOutputSize == GetSizePixel() )
			InvalidateBorder();
		else
			SetSizePixel( aOutputSize );
	}
}

// -----------------------------------------------------------------------

void ImplBorderWindow::InvalidateBorder()
{
	if ( IsReallyVisible() )
	{
		// Nur wenn wir einen Border haben, muessen wir auch invalidieren
		sal_Int32 nLeftBorder;
		sal_Int32 nTopBorder;
		sal_Int32 nRightBorder;
		sal_Int32 nBottomBorder;
		mpBorderView->GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder );
		if ( nLeftBorder || nTopBorder || nRightBorder || nBottomBorder )
		{
			Rectangle	aWinRect( Point( 0, 0 ), GetOutputSizePixel() );
			Region		aRegion( aWinRect );
			aWinRect.Left()   += nLeftBorder;
			aWinRect.Top()	  += nTopBorder;
			aWinRect.Right()  -= nRightBorder;
			aWinRect.Bottom() -= nBottomBorder;
			// kein Output-Bereich mehr, dann alles invalidieren
			if ( (aWinRect.Right() < aWinRect.Left()) ||
				 (aWinRect.Bottom() < aWinRect.Top()) )
				Invalidate( INVALIDATE_NOCHILDREN );
			else
			{
				aRegion.Exclude( aWinRect );
				Invalidate( aRegion, INVALIDATE_NOCHILDREN );
			}
		}
	}
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetDisplayActive( sal_Bool bActive )
{
	if ( mbDisplayActive != bActive )
	{
		mbDisplayActive = bActive;
		if ( mbFrameBorder )
			InvalidateBorder();
	}
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetTitleType( sal_uInt16 nTitleType, const Size& rSize )
{
	mnTitleType = nTitleType;
	UpdateView( sal_False, rSize );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetBorderStyle( sal_uInt16 nStyle )
{
	if ( !mbFrameBorder && (mnBorderStyle != nStyle) )
	{
		mnBorderStyle = nStyle;
		UpdateView( sal_False, ImplGetWindow()->GetOutputSizePixel() );
	}
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetPin( sal_Bool bPin )
{
	mbPined = bPin;
	InvalidateBorder();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetRollUp( sal_Bool bRollUp, const Size& rSize )
{
	mbRollUp = bRollUp;
	mnRollHeight = rSize.Height();
	UpdateView( sal_False, rSize );
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetCloser()
{
	SetStyle( GetStyle() | WB_CLOSEABLE );
	Size aSize = GetOutputSizePixel();
	mpBorderView->Init( this, aSize.Width(), aSize.Height() );
	InvalidateBorder();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetDockButton( sal_Bool bDockButton )
{
	mbDockBtn = bDockButton;
	Size aSize = GetOutputSizePixel();
	mpBorderView->Init( this, aSize.Width(), aSize.Height() );
	InvalidateBorder();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetHideButton( sal_Bool bHideButton )
{
	mbHideBtn = bHideButton;
	Size aSize = GetOutputSizePixel();
	mpBorderView->Init( this, aSize.Width(), aSize.Height() );
	InvalidateBorder();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetHelpButton( sal_Bool bHelpButton )
{
	mbHelpBtn = bHelpButton;
	Size aSize = GetOutputSizePixel();
	mpBorderView->Init( this, aSize.Width(), aSize.Height() );
	InvalidateBorder();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetMenuButton( sal_Bool bMenuButton )
{
	mbMenuBtn = bMenuButton;
	Size aSize = GetOutputSizePixel();
	mpBorderView->Init( this, aSize.Width(), aSize.Height() );
	InvalidateBorder();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::UpdateMenuHeight()
{
	Resize();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetMenuBarWindow( Window* pWindow )
{
	mpMenuBarWindow = pWindow;
	UpdateMenuHeight();
	if ( pWindow )
		pWindow->Show();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::SetMenuBarMode( sal_Bool bHide )
{
	mbMenuHide = bHide;
	UpdateMenuHeight();
}

// -----------------------------------------------------------------------

void ImplBorderWindow::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
								  sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
{
	mpBorderView->GetBorder( rLeftBorder, rTopBorder, rRightBorder, rBottomBorder );
	if ( mpMenuBarWindow && !mbMenuHide )
		rTopBorder += mpMenuBarWindow->GetSizePixel().Height();
}

// -----------------------------------------------------------------------

long ImplBorderWindow::CalcTitleWidth() const
{
	return mpBorderView->CalcTitleWidth();
}

Rectangle ImplBorderWindow::GetMenuRect() const
{
	return mpBorderView->GetMenuRect();
}