AOO410/main/svtools/source/control/taskbar.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * 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_svtools.hxx"

 #define _TASKBAR_CXX

 #include <tools/list.hxx>
 #include <tools/debug.hxx>
 #include <vcl/floatwin.hxx>

 #include <svtools/taskbar.hxx>

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

 class ImplTaskBarFloat : public FloatingWindow
 {
 public:
 	TaskBar*			mpTaskBar;

 public:
 						ImplTaskBarFloat( TaskBar* pTaskBar );
 };

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

 ImplTaskBarFloat::ImplTaskBarFloat( TaskBar* pTaskBar ) :
 	FloatingWindow( pTaskBar, 0 )
 {
 	mpTaskBar	= pTaskBar;
 }

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

 #define TASKBAR_BORDER				2
 #define TASKBAR_OFFSIZE 			3
 #define TASKBAR_OFFX				2
 #define TASKBAR_OFFY				1
 #define TASKBAR_BUTTONOFF			5
 #define TASKBAR_AUTOHIDE_HEIGHT 	2

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

 TaskBar::TaskBar( Window* pParent, WinBits nWinStyle ) :
 	Window( pParent, WB_3DLOOK )
 {
 	mpButtonBar 		= NULL;
 	mpTaskToolBox		= NULL;
 	mpStatusBar 		= NULL;
 	mnStatusWidth		= 0;
 	mnOldStatusWidth	= 0;
 	mnLines 			= 1;
 	mnWinBits			= nWinStyle;
 	mbStatusText		= sal_False;
 	mbShowItems 		= sal_False;
 	mbAutoHide			= sal_False;

 	ImplInitSettings();
 }

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

 TaskBar::~TaskBar()
 {
 	if ( mpButtonBar )
 		delete mpButtonBar;
 	if ( mpTaskToolBox )
 		delete mpTaskToolBox;
 	if ( mpStatusBar )
 		delete mpStatusBar;
 }

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

 void TaskBar::ImplInitSettings()
 {
 	const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();

 	Color aColor;
 	if ( IsControlBackground() )
 		aColor = GetControlBackground();
 	else if ( Window::GetStyle() & WB_3DLOOK )
 		aColor = rStyleSettings.GetFaceColor();
 	else
 		aColor = rStyleSettings.GetWindowColor();
 	SetBackground( aColor );
 }

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

 void TaskBar::ImplNewHeight( long nNewHeight )
 {
 	long nOldHeight = GetSizePixel().Height();
 	if ( nNewHeight != nOldHeight )
 	{
 		long nY = GetPosPixel().Y()-(nNewHeight-nOldHeight);
 		SetPosSizePixel( 0, nY, 0, nNewHeight,
 						 WINDOW_POSSIZE_Y | WINDOW_POSSIZE_HEIGHT );
 		TaskResize();
 	}
 }

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

 void TaskBar::TaskResize()
 {
 	maTaskResizeHdl.Call( this );
 }

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

 TaskButtonBar* TaskBar::CreateButtonBar()
 {
 	return new TaskButtonBar( this );
 }

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

 TaskToolBox* TaskBar::CreateTaskToolBox()
 {
 	return new TaskToolBox( this );
 }

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

 TaskStatusBar* TaskBar::CreateTaskStatusBar()
 {
 	return new TaskStatusBar( this );
 }

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

 void TaskBar::MouseMove( const MouseEvent& rMEvt )
 {
 	if ( mnWinBits & WB_SIZEABLE )
 	{
 		TaskToolBox*	pTempTaskToolBox = GetTaskToolBox();
 		TaskStatusBar*	pTempStatusBar = GetStatusBar();

 		if ( pTempTaskToolBox && pTempStatusBar )
 		{
 			long			nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
 			long			nMouseX = rMEvt.GetPosPixel().X();
 			PointerStyle	ePtrStyle;
 			if ( (nMouseX >= nStatusX-1) && (nMouseX <= nStatusX+3) )
 				ePtrStyle = POINTER_HSIZEBAR;
 			else
 				ePtrStyle = POINTER_ARROW;
 			Pointer aPtr( ePtrStyle );
 			SetPointer( aPtr );
 		}
 	}
 }

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

 void TaskBar::MouseButtonDown( const MouseEvent& rMEvt )
 {
 	if ( rMEvt.IsLeft() && (mnWinBits & WB_SIZEABLE) )
 	{
 		TaskToolBox*	pTempTaskToolBox = GetTaskToolBox();
 		TaskStatusBar*	pTempStatusBar = GetStatusBar();

 		if ( pTempTaskToolBox && pTempStatusBar )
 		{
 			long	nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
 			long	nMouseX = rMEvt.GetPosPixel().X();
 			if ( (nMouseX >= nStatusX-1) && (nMouseX <= nStatusX+3) )
 			{
 				if ( rMEvt.GetClicks() == 2 )
 				{
 					if ( mnStatusWidth )
 					{
 						mnStatusWidth = 0;
 						Resize();
 					}
 				}
 				else
 				{
 					StartTracking();
 					mnOldStatusWidth = mnStatusWidth;
 					mnMouseOff = nMouseX-nStatusX;
 				}
 			}
 		}
 	}
 }

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

 void TaskBar::Tracking( const TrackingEvent& rTEvt )
 {
 	if ( rTEvt.IsTrackingEnded() )
 	{
 		if ( rTEvt.IsTrackingCanceled() )
 		{
 			mnStatusWidth = mnOldStatusWidth;
 			Resize();
 			Update();
 		}
 	}
 	else
 	{
 		Size aSize = GetOutputSizePixel();

 		long nMouseX = rTEvt.GetMouseEvent().GetPosPixel().X()-mnMouseOff;
 		if ( nMouseX < 0 )
 			nMouseX = 0;
 		long nMaxX = aSize.Width()-TASKBAR_OFFX-TASKBAR_OFFSIZE-1;
 		if ( nMouseX > nMaxX )
 			nMouseX = nMaxX;
 		mnStatusWidth = aSize.Width()-nMouseX-TASKBAR_OFFX-TASKBAR_OFFSIZE;
 		Resize();
 		Update();
 	}
 }

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

 void TaskBar::Paint( const Rectangle& rRect )
 {
 	if ( mnWinBits & (WB_BORDER | WB_SIZEABLE) )
 	{
 		const StyleSettings&	rStyleSettings = GetSettings().GetStyleSettings();
 		Size					aSize = GetOutputSizePixel();
 		long	nY = 0;

 		if ( mnWinBits & WB_BORDER )
 		{
 			SetLineColor( rStyleSettings.GetShadowColor() );
 			DrawLine( Point( 0, 0 ), Point( aSize.Width()-1, 0 ) );
 			SetLineColor( rStyleSettings.GetLightColor() );
 			DrawLine( Point( 0, 1 ), Point( aSize.Width()-1, 1 ) );
 			nY += 2;
 		}

 		if ( (mnWinBits & WB_SIZEABLE) )
 		{
 			//TaskButtonBar*	pTempButtonBar = GetButtonBar();
 			TaskToolBox*	pTempTaskToolBox = GetTaskToolBox();
 			TaskStatusBar*	pTempStatusBar = GetStatusBar();

 			if ( pTempTaskToolBox && pTempStatusBar )
 			{
 				long nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
 				if ( nStatusX > 0 )
 				{
 					SetLineColor( rStyleSettings.GetShadowColor() );
 					DrawLine( Point( nStatusX, nY ), Point( nStatusX, aSize.Height()-1 ) );
 					nStatusX++;
 					SetLineColor( rStyleSettings.GetLightColor() );
 					DrawLine( Point( nStatusX, nY ), Point( nStatusX, aSize.Height()-1 ) );
 				}
 			}
 		}
 	}

 	Window::Paint( rRect );
 }

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

 void TaskBar::Resize()
 {
 	if ( !IsReallyShown() )
 		return;

 	TaskButtonBar*	pTempButtonBar = GetButtonBar();
 	TaskToolBox*	pTempTaskToolBox = GetTaskToolBox();
 	TaskStatusBar*	pTempStatusBar = GetStatusBar();
 	Point			aToolPos( TASKBAR_OFFX, 0 );
 	Size			aSize = GetOutputSizePixel();
 	Size			aStatusSize;
 	Size			aToolSize( aSize.Width()-(TASKBAR_OFFX*2), 0 );
 	long			nOldStatusX = -1;
 	long			nNewStatusX = -1;
 	long			nTaskHeight = aSize.Height() - (TASKBAR_OFFY*2);

 	if ( mnWinBits & WB_BORDER )
 	{
 		nTaskHeight -= TASKBAR_BORDER;
 		aToolPos.Y() += TASKBAR_BORDER;
 	}

 	if ( pTempButtonBar )
 	{
 		sal_uInt16	i = 0;
 		sal_Bool	bVisibleItems = sal_False;
 		while ( i < pTempButtonBar->GetItemCount() )
 		{
 			if ( pTempButtonBar->IsItemVisible( pTempButtonBar->GetItemId( i ) ) )
 			{
 				bVisibleItems = sal_True;
 				break;
 			}
 			i++;
 		}
 		if ( mbStatusText || !bVisibleItems )
 			pTempButtonBar->Hide();
 		else
 		{
 			Size aButtonBarSize = pTempButtonBar->CalcWindowSizePixel();
 			if ( pTempButtonBar->GetItemCount() )
 				nTaskHeight = aButtonBarSize.Height();
 			else
 				aButtonBarSize.Height() = nTaskHeight;
 			Point aTempPos = aToolPos;
 			aTempPos.Y() += (aSize.Height()-aButtonBarSize.Height()-aTempPos.Y())/2;
 			pTempButtonBar->SetPosSizePixel( aTempPos, aButtonBarSize );
 			pTempButtonBar->Show();
 			aToolPos.X() += aButtonBarSize.Width()+TASKBAR_BUTTONOFF;
 		}
 	}

 	if ( pTempStatusBar )
 	{
 		aStatusSize = pTempStatusBar->CalcWindowSizePixel();
 		if ( mnStatusWidth )
 			aStatusSize.Width() = mnStatusWidth;
 		if ( !pTempTaskToolBox || mbStatusText )
 			aStatusSize.Width() = aSize.Width();
 		long nMaxHeight = aSize.Height()-(TASKBAR_OFFY*2);
 		if ( mnWinBits & WB_BORDER )
 			nMaxHeight -= TASKBAR_BORDER;
 		if ( nMaxHeight+2 > aStatusSize.Height() )
 			aStatusSize.Height() = nMaxHeight;
 		Point aPos( aSize.Width()-aStatusSize.Width(), 0 );
 		if ( pTempTaskToolBox && (mnWinBits & WB_SIZEABLE) && !mbStatusText )
 		{
 			long nMinToolWidth = aToolPos.X()+50;
 			if ( aPos.X() < nMinToolWidth )
 			{
 				aStatusSize.Width() -= nMinToolWidth-aPos.X();
 				aPos.X() = nMinToolWidth;
 			}
 		}
 		if ( aPos.X() < 0 )
 		{
 			aStatusSize.Width() = aSize.Width();
 			aPos.X() = 0;
 		}
 		if ( mnWinBits & WB_BORDER )
 			aPos.Y() += TASKBAR_BORDER;
 		aPos.Y() += (aSize.Height()-aStatusSize.Height()-aPos.Y())/2;
 		if ( mnWinBits & WB_SIZEABLE )
 		{
 			if ( pTempTaskToolBox )
 			{
 				nOldStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
 				nNewStatusX = aPos.X()-TASKBAR_OFFSIZE-2;
 			}
 		}
 		pTempStatusBar->SetPosSizePixel( aPos, aStatusSize );
 		pTempStatusBar->Show();
 		aToolSize.Width() = aPos.X()-aToolPos.X()-TASKBAR_OFFX;
 		if ( mnWinBits & WB_SIZEABLE )
 			aToolSize.Width() -= (TASKBAR_OFFSIZE*2)-2;
 	}

 	if ( pTempTaskToolBox )
 	{
 		if ( aToolSize.Width() <= 24 )
 			pTempTaskToolBox->Hide();
 		else
 		{
 			aToolSize.Height() = pTempTaskToolBox->CalcWindowSizePixel().Height();
 			if ( pTempTaskToolBox->GetItemCount() )
 				nTaskHeight = aToolSize.Height();
 			else
 				aToolSize.Height() = nTaskHeight;
 			aToolPos.Y() += (aSize.Height()-aToolSize.Height()-aToolPos.Y())/2;
 			pTempTaskToolBox->SetPosSizePixel( aToolPos, aToolSize );
 			pTempTaskToolBox->Show();
 		}
 	}

 	if ( nOldStatusX != nNewStatusX )
 	{
 		if ( nOldStatusX > 0 )
 		{
 			Rectangle aRect( nOldStatusX, 0, nOldStatusX+2, aSize.Height()-1 );
 			Invalidate( aRect );
 		}
 		if ( nNewStatusX > 0 )
 		{
 			Rectangle aRect( nNewStatusX, 0, nNewStatusX+2, aSize.Height()-1 );
 			Invalidate( aRect );
 		}
 	}
 }

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

 void TaskBar::StateChanged( StateChangedType nType )
 {
 	Window::StateChanged( nType );

 	if ( nType == STATE_CHANGE_INITSHOW )
 		Format();
 	else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 	{
 		ImplInitSettings();
 		Invalidate();
 	}
 	else if ( nType == STATE_CHANGE_FORMAT )
 	{
 		ImplInitSettings();
 		ImplNewHeight( CalcWindowSizePixel().Height() );
 		Format();
 		Invalidate();
 	}
 }

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

 void TaskBar::DataChanged( const DataChangedEvent& rDCEvt )
 {
 	Window::DataChanged( rDCEvt );

 	if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
 		 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
 		 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 		  (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
 	{
 		// Asyncronen StateChanged ausloesen, damit sich die
 		// TaskBar an die neuen Groessen der Child-Fenster
 		// orientieren kann
 		PostStateChanged( STATE_CHANGE_FORMAT );
 	}
 }

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

 void TaskBar::Format()
 {
 	ImplNewHeight( CalcWindowSizePixel().Height() );
 	Resize();
 }

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

 void TaskBar::SetLines( sal_uInt16 nLines )
 {
 	mnLines = nLines;
 }

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

 void TaskBar::EnableAutoHide( sal_Bool bAutoHide )
 {
 	mbAutoHide = bAutoHide;

 	if ( mbAutoHide )
 	{
 		ImplNewHeight( TASKBAR_AUTOHIDE_HEIGHT );
 	}
 	else
 	{
 		ImplNewHeight( CalcWindowSizePixel().Height() );
 	}
 }

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

 void TaskBar::ShowStatusText( const String& rText )
 {
 	if ( mpStatusBar )
 	{
 		if ( !mbStatusText )
 		{
 			mbStatusText = sal_True;
 			if ( mpStatusBar->AreItemsVisible() )
 			{
 				mbShowItems = sal_True;
 				mpStatusBar->HideItems();
 			}
 			else
 				mbShowItems = sal_True;
 			maOldText = mpStatusBar->GetText();
 			Resize();
 			mpStatusBar->SetText( rText );
 			Update();
 			mpStatusBar->Update();
 		}
 		else
 			mpStatusBar->SetText( rText );
 	}
 }

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

 void TaskBar::HideStatusText()
 {
 	if ( mbStatusText && mpStatusBar )
 	{
 		mbStatusText = sal_False;
 		mpStatusBar->SetText( maOldText );
 		Resize();
 		if ( mbShowItems )
 			mpStatusBar->ShowItems();
 	}
 }

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

 Size TaskBar::CalcWindowSizePixel() const
 {
 	TaskButtonBar*	pTempButtonBar = GetButtonBar();
 	TaskToolBox*	pTempTaskToolBox = GetTaskToolBox();
 	TaskStatusBar*	pTempStatusBar = GetStatusBar();
 	Size			aSize;
 	long			nTempHeight;

 	if ( pTempButtonBar && pTempButtonBar->GetItemCount() )
 		aSize.Height() = pTempButtonBar->CalcWindowSizePixel().Height()+(TASKBAR_OFFY*2);
 	if ( pTempTaskToolBox && pTempTaskToolBox->GetItemCount() )
 	{
 		nTempHeight = pTempTaskToolBox->CalcWindowSizePixel().Height()+(TASKBAR_OFFY*2);
 		if ( nTempHeight > aSize.Height() )
 			 aSize.Height() = nTempHeight;
 	}
 	if ( pTempStatusBar )
 	{
 		nTempHeight = pTempStatusBar->GetSizePixel().Height();
 		if ( nTempHeight > aSize.Height() )
 			 aSize.Height() = nTempHeight;
 	}

 	if ( mnWinBits & WB_BORDER )
 		aSize.Height() += TASKBAR_BORDER;

 	return aSize;
 }

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

 TaskButtonBar* TaskBar::GetButtonBar() const
 {
 	if ( !mpButtonBar )
 		((TaskBar*)this)->mpButtonBar = ((TaskBar*)this)->CreateButtonBar();
 	return mpButtonBar;
 }

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

 TaskToolBox* TaskBar::GetTaskToolBox() const
 {
 	if ( !mpTaskToolBox )
 		((TaskBar*)this)->mpTaskToolBox = ((TaskBar*)this)->CreateTaskToolBox();
 	return mpTaskToolBox;
 }

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

 TaskStatusBar* TaskBar::GetStatusBar() const
 {
 	if ( !mpStatusBar )
 	{
 		((TaskBar*)this)->mpStatusBar = ((TaskBar*)this)->CreateTaskStatusBar();
 		if ( mpStatusBar )
 			mpStatusBar->mpNotifyTaskBar = (TaskBar*)this;
 	}
 	return mpStatusBar;
 }
	/**************************************************************
	*
	* 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_svtools.hxx"

	#define _TASKBAR_CXX

	#include <tools/list.hxx>
	#include <tools/debug.hxx>
	#include <vcl/floatwin.hxx>

	#include <svtools/taskbar.hxx>

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

	class ImplTaskBarFloat : public FloatingWindow
	{
	public:
	TaskBar* mpTaskBar;

	public:
	ImplTaskBarFloat( TaskBar* pTaskBar );
	};

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

	ImplTaskBarFloat::ImplTaskBarFloat( TaskBar* pTaskBar ) :
	FloatingWindow( pTaskBar, 0 )
	{
	mpTaskBar = pTaskBar;
	}

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

	#define TASKBAR_BORDER 2
	#define TASKBAR_OFFSIZE 3
	#define TASKBAR_OFFX 2
	#define TASKBAR_OFFY 1
	#define TASKBAR_BUTTONOFF 5
	#define TASKBAR_AUTOHIDE_HEIGHT 2

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

	TaskBar::TaskBar( Window* pParent, WinBits nWinStyle ) :
	Window( pParent, WB_3DLOOK )
	{
	mpButtonBar = NULL;
	mpTaskToolBox = NULL;
	mpStatusBar = NULL;
	mnStatusWidth = 0;
	mnOldStatusWidth = 0;
	mnLines = 1;
	mnWinBits = nWinStyle;
	mbStatusText = sal_False;
	mbShowItems = sal_False;
	mbAutoHide = sal_False;

	ImplInitSettings();
	}

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

	TaskBar::~TaskBar()
	{
	if ( mpButtonBar )
	delete mpButtonBar;
	if ( mpTaskToolBox )
	delete mpTaskToolBox;
	if ( mpStatusBar )
	delete mpStatusBar;
	}

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

	void TaskBar::ImplInitSettings()
	{
	const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();

	Color aColor;
	if ( IsControlBackground() )
	aColor = GetControlBackground();
	else if ( Window::GetStyle() & WB_3DLOOK )
	aColor = rStyleSettings.GetFaceColor();
	else
	aColor = rStyleSettings.GetWindowColor();
	SetBackground( aColor );
	}

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

	void TaskBar::ImplNewHeight( long nNewHeight )
	{
	long nOldHeight = GetSizePixel().Height();
	if ( nNewHeight != nOldHeight )
	{
	long nY = GetPosPixel().Y()-(nNewHeight-nOldHeight);
	SetPosSizePixel( 0, nY, 0, nNewHeight,
	WINDOW_POSSIZE_Y \| WINDOW_POSSIZE_HEIGHT );
	TaskResize();
	}
	}

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

	void TaskBar::TaskResize()
	{
	maTaskResizeHdl.Call( this );
	}

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

	TaskButtonBar* TaskBar::CreateButtonBar()
	{
	return new TaskButtonBar( this );
	}

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

	TaskToolBox* TaskBar::CreateTaskToolBox()
	{
	return new TaskToolBox( this );
	}

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

	TaskStatusBar* TaskBar::CreateTaskStatusBar()
	{
	return new TaskStatusBar( this );
	}

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

	void TaskBar::MouseMove( const MouseEvent& rMEvt )
	{
	if ( mnWinBits & WB_SIZEABLE )
	{
	TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
	TaskStatusBar* pTempStatusBar = GetStatusBar();

	if ( pTempTaskToolBox && pTempStatusBar )
	{
	long nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
	long nMouseX = rMEvt.GetPosPixel().X();
	PointerStyle ePtrStyle;
	if ( (nMouseX >= nStatusX-1) && (nMouseX <= nStatusX+3) )
	ePtrStyle = POINTER_HSIZEBAR;
	else
	ePtrStyle = POINTER_ARROW;
	Pointer aPtr( ePtrStyle );
	SetPointer( aPtr );
	}
	}
	}

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

	void TaskBar::MouseButtonDown( const MouseEvent& rMEvt )
	{
	if ( rMEvt.IsLeft() && (mnWinBits & WB_SIZEABLE) )
	{
	TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
	TaskStatusBar* pTempStatusBar = GetStatusBar();

	if ( pTempTaskToolBox && pTempStatusBar )
	{
	long nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
	long nMouseX = rMEvt.GetPosPixel().X();
	if ( (nMouseX >= nStatusX-1) && (nMouseX <= nStatusX+3) )
	{
	if ( rMEvt.GetClicks() == 2 )
	{
	if ( mnStatusWidth )
	{
	mnStatusWidth = 0;
	Resize();
	}
	}
	else
	{
	StartTracking();
	mnOldStatusWidth = mnStatusWidth;
	mnMouseOff = nMouseX-nStatusX;
	}
	}
	}
	}
	}

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

	void TaskBar::Tracking( const TrackingEvent& rTEvt )
	{
	if ( rTEvt.IsTrackingEnded() )
	{
	if ( rTEvt.IsTrackingCanceled() )
	{
	mnStatusWidth = mnOldStatusWidth;
	Resize();
	Update();
	}
	}
	else
	{
	Size aSize = GetOutputSizePixel();

	long nMouseX = rTEvt.GetMouseEvent().GetPosPixel().X()-mnMouseOff;
	if ( nMouseX < 0 )
	nMouseX = 0;
	long nMaxX = aSize.Width()-TASKBAR_OFFX-TASKBAR_OFFSIZE-1;
	if ( nMouseX > nMaxX )
	nMouseX = nMaxX;
	mnStatusWidth = aSize.Width()-nMouseX-TASKBAR_OFFX-TASKBAR_OFFSIZE;
	Resize();
	Update();
	}
	}

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

	void TaskBar::Paint( const Rectangle& rRect )
	{
	if ( mnWinBits & (WB_BORDER \| WB_SIZEABLE) )
	{
	const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
	Size aSize = GetOutputSizePixel();
	long nY = 0;

	if ( mnWinBits & WB_BORDER )
	{
	SetLineColor( rStyleSettings.GetShadowColor() );
	DrawLine( Point( 0, 0 ), Point( aSize.Width()-1, 0 ) );
	SetLineColor( rStyleSettings.GetLightColor() );
	DrawLine( Point( 0, 1 ), Point( aSize.Width()-1, 1 ) );
	nY += 2;
	}

	if ( (mnWinBits & WB_SIZEABLE) )
	{
	//TaskButtonBar* pTempButtonBar = GetButtonBar();
	TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
	TaskStatusBar* pTempStatusBar = GetStatusBar();

	if ( pTempTaskToolBox && pTempStatusBar )
	{
	long nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
	if ( nStatusX > 0 )
	{
	SetLineColor( rStyleSettings.GetShadowColor() );
	DrawLine( Point( nStatusX, nY ), Point( nStatusX, aSize.Height()-1 ) );
	nStatusX++;
	SetLineColor( rStyleSettings.GetLightColor() );
	DrawLine( Point( nStatusX, nY ), Point( nStatusX, aSize.Height()-1 ) );
	}
	}
	}
	}

	Window::Paint( rRect );
	}

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

	void TaskBar::Resize()
	{
	if ( !IsReallyShown() )
	return;

	TaskButtonBar* pTempButtonBar = GetButtonBar();
	TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
	TaskStatusBar* pTempStatusBar = GetStatusBar();
	Point aToolPos( TASKBAR_OFFX, 0 );
	Size aSize = GetOutputSizePixel();
	Size aStatusSize;
	Size aToolSize( aSize.Width()-(TASKBAR_OFFX*2), 0 );
	long nOldStatusX = -1;
	long nNewStatusX = -1;
	long nTaskHeight = aSize.Height() - (TASKBAR_OFFY*2);

	if ( mnWinBits & WB_BORDER )
	{
	nTaskHeight -= TASKBAR_BORDER;
	aToolPos.Y() += TASKBAR_BORDER;
	}

	if ( pTempButtonBar )
	{
	sal_uInt16 i = 0;
	sal_Bool bVisibleItems = sal_False;
	while ( i < pTempButtonBar->GetItemCount() )
	{
	if ( pTempButtonBar->IsItemVisible( pTempButtonBar->GetItemId( i ) ) )
	{
	bVisibleItems = sal_True;
	break;
	}
	i++;
	}
	if ( mbStatusText \|\| !bVisibleItems )
	pTempButtonBar->Hide();
	else
	{
	Size aButtonBarSize = pTempButtonBar->CalcWindowSizePixel();
	if ( pTempButtonBar->GetItemCount() )
	nTaskHeight = aButtonBarSize.Height();
	else
	aButtonBarSize.Height() = nTaskHeight;
	Point aTempPos = aToolPos;
	aTempPos.Y() += (aSize.Height()-aButtonBarSize.Height()-aTempPos.Y())/2;
	pTempButtonBar->SetPosSizePixel( aTempPos, aButtonBarSize );
	pTempButtonBar->Show();
	aToolPos.X() += aButtonBarSize.Width()+TASKBAR_BUTTONOFF;
	}
	}

	if ( pTempStatusBar )
	{
	aStatusSize = pTempStatusBar->CalcWindowSizePixel();
	if ( mnStatusWidth )
	aStatusSize.Width() = mnStatusWidth;
	if ( !pTempTaskToolBox \|\| mbStatusText )
	aStatusSize.Width() = aSize.Width();
	long nMaxHeight = aSize.Height()-(TASKBAR_OFFY*2);
	if ( mnWinBits & WB_BORDER )
	nMaxHeight -= TASKBAR_BORDER;
	if ( nMaxHeight+2 > aStatusSize.Height() )
	aStatusSize.Height() = nMaxHeight;
	Point aPos( aSize.Width()-aStatusSize.Width(), 0 );
	if ( pTempTaskToolBox && (mnWinBits & WB_SIZEABLE) && !mbStatusText )
	{
	long nMinToolWidth = aToolPos.X()+50;
	if ( aPos.X() < nMinToolWidth )
	{
	aStatusSize.Width() -= nMinToolWidth-aPos.X();
	aPos.X() = nMinToolWidth;
	}
	}
	if ( aPos.X() < 0 )
	{
	aStatusSize.Width() = aSize.Width();
	aPos.X() = 0;
	}
	if ( mnWinBits & WB_BORDER )
	aPos.Y() += TASKBAR_BORDER;
	aPos.Y() += (aSize.Height()-aStatusSize.Height()-aPos.Y())/2;
	if ( mnWinBits & WB_SIZEABLE )
	{
	if ( pTempTaskToolBox )
	{
	nOldStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
	nNewStatusX = aPos.X()-TASKBAR_OFFSIZE-2;
	}
	}
	pTempStatusBar->SetPosSizePixel( aPos, aStatusSize );
	pTempStatusBar->Show();
	aToolSize.Width() = aPos.X()-aToolPos.X()-TASKBAR_OFFX;
	if ( mnWinBits & WB_SIZEABLE )
	aToolSize.Width() -= (TASKBAR_OFFSIZE*2)-2;
	}

	if ( pTempTaskToolBox )
	{
	if ( aToolSize.Width() <= 24 )
	pTempTaskToolBox->Hide();
	else
	{
	aToolSize.Height() = pTempTaskToolBox->CalcWindowSizePixel().Height();
	if ( pTempTaskToolBox->GetItemCount() )
	nTaskHeight = aToolSize.Height();
	else
	aToolSize.Height() = nTaskHeight;
	aToolPos.Y() += (aSize.Height()-aToolSize.Height()-aToolPos.Y())/2;
	pTempTaskToolBox->SetPosSizePixel( aToolPos, aToolSize );
	pTempTaskToolBox->Show();
	}
	}

	if ( nOldStatusX != nNewStatusX )
	{
	if ( nOldStatusX > 0 )
	{
	Rectangle aRect( nOldStatusX, 0, nOldStatusX+2, aSize.Height()-1 );
	Invalidate( aRect );
	}
	if ( nNewStatusX > 0 )
	{
	Rectangle aRect( nNewStatusX, 0, nNewStatusX+2, aSize.Height()-1 );
	Invalidate( aRect );
	}
	}
	}

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

	void TaskBar::StateChanged( StateChangedType nType )
	{
	Window::StateChanged( nType );

	if ( nType == STATE_CHANGE_INITSHOW )
	Format();
	else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
	{
	ImplInitSettings();
	Invalidate();
	}
	else if ( nType == STATE_CHANGE_FORMAT )
	{
	ImplInitSettings();
	ImplNewHeight( CalcWindowSizePixel().Height() );
	Format();
	Invalidate();
	}
	}

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

	void TaskBar::DataChanged( const DataChangedEvent& rDCEvt )
	{
	Window::DataChanged( rDCEvt );

	if ( (rDCEvt.GetType() == DATACHANGED_FONTS) \|\|
	(rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) \|\|
	((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
	(rDCEvt.GetFlags() & SETTINGS_STYLE)) )
	{
	// Asyncronen StateChanged ausloesen, damit sich die
	// TaskBar an die neuen Groessen der Child-Fenster
	// orientieren kann
	PostStateChanged( STATE_CHANGE_FORMAT );
	}
	}

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

	void TaskBar::Format()
	{
	ImplNewHeight( CalcWindowSizePixel().Height() );
	Resize();
	}

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

	void TaskBar::SetLines( sal_uInt16 nLines )
	{
	mnLines = nLines;
	}

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

	void TaskBar::EnableAutoHide( sal_Bool bAutoHide )
	{
	mbAutoHide = bAutoHide;

	if ( mbAutoHide )
	{
	ImplNewHeight( TASKBAR_AUTOHIDE_HEIGHT );
	}
	else
	{
	ImplNewHeight( CalcWindowSizePixel().Height() );
	}
	}

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

	void TaskBar::ShowStatusText( const String& rText )
	{
	if ( mpStatusBar )
	{
	if ( !mbStatusText )
	{
	mbStatusText = sal_True;
	if ( mpStatusBar->AreItemsVisible() )
	{
	mbShowItems = sal_True;
	mpStatusBar->HideItems();
	}
	else
	mbShowItems = sal_True;
	maOldText = mpStatusBar->GetText();
	Resize();
	mpStatusBar->SetText( rText );
	Update();
	mpStatusBar->Update();
	}
	else
	mpStatusBar->SetText( rText );
	}
	}

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

	void TaskBar::HideStatusText()
	{
	if ( mbStatusText && mpStatusBar )
	{
	mbStatusText = sal_False;
	mpStatusBar->SetText( maOldText );
	Resize();
	if ( mbShowItems )
	mpStatusBar->ShowItems();
	}
	}

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

	Size TaskBar::CalcWindowSizePixel() const
	{
	TaskButtonBar* pTempButtonBar = GetButtonBar();
	TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
	TaskStatusBar* pTempStatusBar = GetStatusBar();
	Size aSize;
	long nTempHeight;

	if ( pTempButtonBar && pTempButtonBar->GetItemCount() )
	aSize.Height() = pTempButtonBar->CalcWindowSizePixel().Height()+(TASKBAR_OFFY*2);
	if ( pTempTaskToolBox && pTempTaskToolBox->GetItemCount() )
	{
	nTempHeight = pTempTaskToolBox->CalcWindowSizePixel().Height()+(TASKBAR_OFFY*2);
	if ( nTempHeight > aSize.Height() )
	aSize.Height() = nTempHeight;
	}
	if ( pTempStatusBar )
	{
	nTempHeight = pTempStatusBar->GetSizePixel().Height();
	if ( nTempHeight > aSize.Height() )
	aSize.Height() = nTempHeight;
	}

	if ( mnWinBits & WB_BORDER )
	aSize.Height() += TASKBAR_BORDER;

	return aSize;
	}

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

	TaskButtonBar* TaskBar::GetButtonBar() const
	{
	if ( !mpButtonBar )
	((TaskBar)this)->mpButtonBar = ((TaskBar)this)->CreateButtonBar();
	return mpButtonBar;
	}

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

	TaskToolBox* TaskBar::GetTaskToolBox() const
	{
	if ( !mpTaskToolBox )
	((TaskBar)this)->mpTaskToolBox = ((TaskBar)this)->CreateTaskToolBox();
	return mpTaskToolBox;
	}

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

	TaskStatusBar* TaskBar::GetStatusBar() const
	{
	if ( !mpStatusBar )
	{
	((TaskBar)this)->mpStatusBar = ((TaskBar)this)->CreateTaskStatusBar();
	if ( mpStatusBar )
	mpStatusBar->mpNotifyTaskBar = (TaskBar*)this;
	}
	return mpStatusBar;
	}