utils/framelayout/src/barhintspl.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        No names yet.
// Purpose:     Contrib. demo
// Author:      Aleksandras Gluchovas
// Modified by:
// Created:     30/11/98 (my 22th birthday :-)
// RCS-ID:      $Id$
// Copyright:   (c) Aleksandras Gluchovas
// Licence:   	wxWindows license
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "rowlayoutpl.h"
// #pragma interface
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include "wx/utils.h"
#include "barhintspl.h"

// fixed settings

#define GROOVE_WIDTH         3  // left shade + middle line + right shade
#define GROOVE_TO_GROOVE_GAP 1
#define BOX_T_BOX_GAP        2
#define BOX_TO_GROOVE_GAP    3

#define BOXES_IN_HINT        2
#define CLOSE_BOX_IDX        0
#define COLLAPSE_BOX_IDX     1

// used interally

#define CLOSE_BOX_HITTED    1
#define COLLAPSE_BOX_HITTED 2

/***** Implementation fro class cbBarHintsPlugin *****/

IMPLEMENT_DYNAMIC_CLASS( cbBarHintsPlugin, cbPluginBase )

BEGIN_EVENT_TABLE( cbBarHintsPlugin, cbPluginBase )

	EVT_PL_SIZE_BAR_WND  ( cbBarHintsPlugin::OnSizeBarWindow )
	EVT_PL_DRAW_BAR_DECOR( cbBarHintsPlugin::OnDrawBarDecorations )

	EVT_PL_LEFT_DOWN( cbBarHintsPlugin::OnLeftDown )
	EVT_PL_LEFT_UP  ( cbBarHintsPlugin::OnLeftUp   )
	EVT_PL_MOTION	( cbBarHintsPlugin::OnMotion   )

END_EVENT_TABLE()

cbBarHintsPlugin::cbBarHintsPlugin(void)

	: mpPane( 0 ),
	  mCollapseBoxOn( TRUE ),
	  mCloseBoxOn   ( TRUE ),
	  mBtnPressed   ( FALSE ),
	  mGrooveCount  ( 2 ),
	  mHintGap      ( 4 ),
	  mXWeight      ( 2 )
{}

cbBarHintsPlugin::cbBarHintsPlugin( wxFrameLayout* pLayout, int paneMask )

	: cbPluginBase( pLayout, paneMask ),
	  mpPane( 0 ),
	  mCollapseBoxOn( TRUE ),
	  mCloseBoxOn   ( TRUE ),
	  mBtnPressed   ( FALSE ),
	  mGrooveCount  ( 2 ),
	  mHintGap      ( 5 ),
	  mXWeight      ( 2 )
{}

void cbBarHintsPlugin::SetGrooveCount( int nGrooves )
{
	mGrooveCount = nGrooves;
}

void cbBarHintsPlugin::CreateBoxes()
{
	cbCloseBox*    box1 = new cbCloseBox();
	cbCollapseBox* box2 = new cbCollapseBox();

	mBoxes[CLOSE_BOX_IDX]    = box1;
	mBoxes[COLLAPSE_BOX_IDX] = box2;

	for( int i = 0; i != BOXES_IN_HINT; ++i )
	{
		mBoxes[i]->mpLayout = mpLayout;
		mBoxes[i]->mpPlugin = this;
		mBoxes[i]->mpWnd    = NULL;
	}
}

void cbBarHintsPlugin::Draw3DBox( wxDC& dc, const wxPoint& pos, bool pressed )
{
}

void cbBarHintsPlugin::DrawCloseBox( wxDC& dc, const wxPoint& pos, bool pressed )
{
}

void cbBarHintsPlugin::DrawCollapseBox( wxDC& dc, const wxPoint& pos,
										bool atLeft, bool disabled, bool pressed )
{
}

void cbBarHintsPlugin::DrawGrooves( wxDC& dc, const wxPoint& pos, int length )
{
	int ofs = 0;

	for( int i = 0; i != mGrooveCount; ++i, ofs += ( GROOVE_WIDTH + GROOVE_TO_GROOVE_GAP ) )

		if ( mpPane->IsHorizontal() )
		{
			dc.SetPen( mpLayout->mLightPen );
			dc.DrawLine( pos.x + ofs, pos.y, pos.x + ofs, pos.y + length - 1 );
			dc.DrawPoint( pos.x + ofs + 1, pos.y );

			dc.SetPen( mpLayout->mDarkPen );
			dc.DrawLine( pos.x + ofs + 2, pos.y, pos.x + ofs + 2, pos.y + length );
			dc.DrawPoint( pos.x + ofs + 1, pos.y + length - 1 );
			dc.DrawPoint( pos.x + ofs,     pos.y + length - 1 );
		}
		else
		{
			dc.SetPen( mpLayout->mLightPen );
			dc.DrawLine( pos.x, pos.y + ofs, pos.x + length - 1, pos.y + ofs );
			dc.DrawPoint( pos.x, pos.y + ofs + 1 );

			dc.SetPen( mpLayout->mDarkPen );
			dc.DrawLine( pos.x, pos.y + ofs + 2, pos.x + length, pos.y + ofs + 2 );
			dc.DrawPoint( pos.x + length - 1, pos.y + ofs + 1 );
			dc.DrawPoint( pos.x + length - 1, pos.y + ofs );
		}
}

void cbBarHintsPlugin::ExcludeHints( wxRect& rect, cbBarInfo& info )
{
	int boxHeight = BTN_BOX_HEIGHT;

	// collapse and close box are not placed on fixed bars

	if ( info.IsFixed() || ( !mCloseBoxOn && !mCollapseBoxOn ) )

		boxHeight = 0;

	int height = wxMax( mGrooveCount*(GROOVE_WIDTH + GROOVE_TO_GROOVE_GAP)
		                - GROOVE_TO_GROOVE_GAP,
						boxHeight
				      );

	if ( mpPane->IsHorizontal() )
	{
		rect.x     += ( mHintGap*2 + height );
		rect.width -= (height + 2*mHintGap);

		rect.x     -= info.mDimInfo.mHorizGap + 2;
		rect.width += info.mDimInfo.mHorizGap + 2;
	}
	else
	{
		rect.y      += (mHintGap*2 + height);
		rect.height -= (height + 2*mHintGap);

		rect.y      -= info.mDimInfo.mVertGap + 2;
		rect.height += info.mDimInfo.mVertGap + 2;
	}
}

void cbBarHintsPlugin::DoDrawHint( wxDC& dc, wxRect& rect,
								   int pos, int boxOfs, int grooveOfs,
								   bool isFixed )
{
	if ( !isFixed )
	{
		if ( mpPane->IsHorizontal() )
		{
			if ( mCloseBoxOn )

				mBoxes[CLOSE_BOX_IDX]->Draw( dc );

			if ( mCollapseBoxOn )

				mBoxes[COLLAPSE_BOX_IDX]->Draw( dc );
		}
		else
		{
			if ( mCloseBoxOn )

				mBoxes[CLOSE_BOX_IDX]->Draw( dc );

			if ( mCollapseBoxOn )

				mBoxes[COLLAPSE_BOX_IDX]->Draw( dc );
		}
	}

	if ( mpPane->IsHorizontal() )

		DrawGrooves( dc, wxPoint( rect.x + mHintGap + grooveOfs, pos ),
					 rect.height - (pos - rect.y) - mHintGap );
	else
		DrawGrooves( dc, wxPoint( rect.x + mHintGap, rect.y + mHintGap + grooveOfs ),
					 (pos - rect.x) - mHintGap );
}

void cbBarHintsPlugin::GetHintsLayout( wxRect& rect, cbBarInfo& info,
									   int& boxOfs, int& grooveOfs, int& pos )
{
	int boxHeight = BTN_BOX_HEIGHT;
	int boxWidth  = BTN_BOX_WIDTH + BOX_TO_GROOVE_GAP + BTN_BOX_WIDTH;

	// collapse and close box are not placed on fixed bars

	if ( info.IsFixed() || ( !mCloseBoxOn && !mCollapseBoxOn ) )
	{
		boxHeight = 0;
		boxWidth = 0;
	}
	else
	if ( !mCloseBoxOn || !mCollapseBoxOn )

		boxWidth = BTN_BOX_WIDTH;

	int grooveHeight = mGrooveCount*(GROOVE_WIDTH + GROOVE_TO_GROOVE_GAP)
		               - GROOVE_TO_GROOVE_GAP;

	int height = wxMax( grooveHeight, boxHeight );

	// center boxs and groves with respect to each other

	boxOfs    = ( height - boxHeight    ) / 2;
	grooveOfs = ( height - grooveHeight ) / 2;

	pos = ( mpPane->IsHorizontal() ) ? rect.y + mHintGap
									 : rect.x + rect.width - mHintGap;

	// setup positions for boxes

	if ( !info.IsFixed() )
	{
		// what direction "collapse-triangle" should look at?

		bool& isAtLeft = ((cbCollapseBox*)(mBoxes[COLLAPSE_BOX_IDX]))->mIsAtLeft;

		isAtLeft= info.mBounds.x <= mpPane->mPaneWidth - ( info.mBounds.x + info.mBounds.width );

		if ( info.IsExpanded() )
		{
			isAtLeft = FALSE;

			cbBarInfo* pCur = info.mpPrev;

			while( pCur )
			{
				if ( !pCur->IsFixed() )
				{
					isAtLeft = TRUE; break;
				}

				pCur = pCur->mpPrev;
			}
		}

		// collapse/expand works only when more not-fixed bars are present in the same row

		mBoxes[COLLAPSE_BOX_IDX]->Enable( info.mpRow->mNotFixedBarsCnt > 1 );

		for( int i = 0; i != BOXES_IN_HINT; ++i )

			mBoxes[i]->mpPane = mpPane;


		if ( mpPane->IsHorizontal() )
		{
			if ( mCloseBoxOn )
			{
				mBoxes[CLOSE_BOX_IDX]->mPos = wxPoint( rect.x + mHintGap + boxOfs, pos );

				pos += BTN_BOX_HEIGHT;
			}

			if ( mCollapseBoxOn )
			{
				if ( mCloseBoxOn ) pos += BOX_T_BOX_GAP;

				mBoxes[COLLAPSE_BOX_IDX]->mPos = wxPoint( rect.x + mHintGap + boxOfs, pos );

				pos += BTN_BOX_HEIGHT;

				pos += BOX_TO_GROOVE_GAP;
			}
		}
		else
		{
			if ( mCloseBoxOn )
			{
				pos -= BTN_BOX_WIDTH;

				mBoxes[CLOSE_BOX_IDX]->mPos = wxPoint( pos , rect.y + mHintGap + boxOfs );
			}

			if ( mCollapseBoxOn )
			{
				if ( mCloseBoxOn ) pos -= BOX_T_BOX_GAP;

				pos -= BTN_BOX_WIDTH;

				mBoxes[COLLAPSE_BOX_IDX]->mPos = wxPoint( pos, rect.y + mHintGap + boxOfs );

				pos -= BOX_TO_GROOVE_GAP;
			}
		}
	}
}

static inline bool is_in_box( const wxPoint& rectPos, const wxPoint& mousePos )
{
	return ( mousePos.x >= rectPos.x &&
			 mousePos.y >= rectPos.y &&
			 mousePos.x < rectPos.x + BTN_BOX_WIDTH &&
			 mousePos.y < rectPos.y + BTN_BOX_HEIGHT );
}

int cbBarHintsPlugin::HitTestHints( cbBarInfo& info, const wxPoint& pos )
{
	wxPoint inPane = pos;
	mpPane->PaneToFrame( &inPane.x, &inPane.y );

	wxRect& rect = info.mBoundsInParent;

	if ( info.IsFixed() ) return FALSE;

	int boxOfs, grooveOfs, coord;

	GetHintsLayout( rect, info, boxOfs, grooveOfs, coord );

	if ( mpPane->IsHorizontal() )
	{
		if ( mCloseBoxOn )
		{
			if ( is_in_box( wxPoint( rect.x + mHintGap + boxOfs, coord ), inPane ) )

				return CLOSE_BOX_HITTED;

			coord += BTN_BOX_HEIGHT;
		}

		if ( mCollapseBoxOn )
		{
			if ( mCloseBoxOn ) coord += BOX_T_BOX_GAP;

			if ( is_in_box( wxPoint( rect.x + mHintGap + boxOfs, coord ), inPane ) )

				return COLLAPSE_BOX_HITTED;

			coord += BTN_BOX_HEIGHT;
		}
	}
	else
	{
		if ( mCloseBoxOn )
		{
			coord -= BTN_BOX_WIDTH;

			if ( is_in_box( wxPoint( coord , rect.y + mHintGap + boxOfs ), inPane ) )

				return CLOSE_BOX_HITTED;
		}

		if ( mCollapseBoxOn )
		{
			if ( mCloseBoxOn ) coord -= BOX_T_BOX_GAP;
			coord -= BTN_BOX_WIDTH;

			if ( is_in_box( wxPoint( coord, rect.y + mHintGap + boxOfs ), inPane ) )

				return COLLAPSE_BOX_HITTED;
		}
	}

	return FALSE;
}

// handlers for plugin-events

void cbBarHintsPlugin::OnSizeBarWindow( cbSizeBarWndEvent& event )
{
	wxRect& rect     = event.mBoundsInParent;
	mpPane           = event.mpPane;

	ExcludeHints( rect, *event.mpBar );

	event.Skip(); // pass event to the next plugin in the chain
}

void cbBarHintsPlugin::OnDrawBarDecorations( cbDrawBarDecorEvent& event )
{
	wxRect& rect     = event.mBoundsInParent;
	mpPane           = event.mpPane;

	int boxOfs, grooveOfs, pos;

	GetHintsLayout( rect, *event.mpBar, boxOfs, grooveOfs, pos );

	DoDrawHint( *event.mpDc, rect, pos, boxOfs, grooveOfs, event.mpBar->IsFixed() );

	// let other plugins add on their decorations

	event.Skip();
}

void cbBarHintsPlugin::OnLeftDown( cbLeftDownEvent& event )
{
	mpPane           = event.mpPane;

	wxPoint inFrame = event.mPos;
	mpPane->PaneToFrame( &inFrame.x, &inFrame.y );

	wxBarIterator iter( mpPane->GetRowList() );

	mpClickedBar = NULL;

	while ( iter.Next() )
	{
		cbBarInfo& bar = iter.BarInfo();

		int boxOfs, grooveOfs, pos;

		GetHintsLayout( bar.mBoundsInParent, bar, boxOfs, grooveOfs, pos );

		if ( !bar.IsFixed() )

			for( int i = 0; i != BOXES_IN_HINT; ++i )
			{
				mBoxes[i]->OnLeftDown( inFrame );

				if ( mBoxes[i]->mPressed )
				{
					mBtnPressed = TRUE;
					mpClickedBar = &bar;

					return; // event handled
				}
			}
	}

	event.Skip();
}

void cbBarHintsPlugin::OnLeftUp( cbLeftUpEvent&   event )
{
	if ( mBtnPressed )
	{
		wxPoint inFrame = event.mPos;
		mpPane->PaneToFrame( &inFrame.x, &inFrame.y );

		int boxOfs, grooveOfs, pos;

		GetHintsLayout( mpClickedBar->mBoundsInParent, *mpClickedBar, boxOfs, grooveOfs, pos );

		int result = HitTestHints( *mpClickedBar, event.mPos );

		for( int i = 0; i != BOXES_IN_HINT; ++i )
		{
			mBoxes[i]->OnLeftUp( inFrame );

			if ( mBoxes[i]->WasClicked() )
			{
				if ( i == 0 )

					mpLayout->SetBarState( mpClickedBar, wxCBAR_HIDDEN, TRUE );
				else
				{
					if ( mpClickedBar->IsExpanded() )

						mpPane->ContractBar( mpClickedBar );
					else
						mpPane->ExpandBar( mpClickedBar );
				}
			}
		}

		mBtnPressed = FALSE;
		return;
	}
	else
		event.Skip();
}

void cbBarHintsPlugin::OnMotion( cbMotionEvent&   event )
{
	if ( mBtnPressed )
	{
		wxPoint inFrame = event.mPos;
		mpPane->PaneToFrame( &inFrame.x, &inFrame.y );

		mpPane = event.mpPane;

		for( int i = 0; i != BOXES_IN_HINT; ++i )

			mBoxes[i]->OnMotion( inFrame );
	}
	else
		event.Skip();
}

void cbBarHintsPlugin::OnInitPlugin()
{
	cbPluginBase::OnInitPlugin();

	cbDockPane** panes = mpLayout->GetPanesArray();

	for( int i = 0; i != MAX_PANES; ++i )

		if ( panes[i]->MatchesMask( mPaneMask ) )
		{
			panes[i]->mProps.mMinCBarDim.x = 25;
			panes[i]->mProps.mMinCBarDim.y = 16;
		}

	CreateBoxes();
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: No names yet.
	3	// Purpose: Contrib. demo
	4	// Author: Aleksandras Gluchovas
	5	// Modified by:
	6	// Created: 30/11/98 (my 22th birthday :-)
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Aleksandras Gluchovas
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "rowlayoutpl.h"
	14	// #pragma interface
	15	#endif
	16
	17	// For compilers that support precompilation, includes "wx.h".
	18	#include "wx/wxprec.h"
	19
	20	#ifdef __BORLANDC__
	21	#pragma hdrstop
	22	#endif
	23
	24	#ifndef WX_PRECOMP
	25	#include "wx/wx.h"
	26	#endif
	27
	28	#include "wx/utils.h"
	29	#include "barhintspl.h"
	30
	31	// fixed settings
	32
	33	#define GROOVE_WIDTH 3 // left shade + middle line + right shade
	34	#define GROOVE_TO_GROOVE_GAP 1
	35	#define BOX_T_BOX_GAP 2
	36	#define BOX_TO_GROOVE_GAP 3
	37
	38	#define BOXES_IN_HINT 2
	39	#define CLOSE_BOX_IDX 0
	40	#define COLLAPSE_BOX_IDX 1
	41
	42	// used interally
	43
	44	#define CLOSE_BOX_HITTED 1
	45	#define COLLAPSE_BOX_HITTED 2
	46
	47	/*** Implementation fro class cbBarHintsPlugin ***/
	48
	49	IMPLEMENT_DYNAMIC_CLASS( cbBarHintsPlugin, cbPluginBase )
	50
	51	BEGIN_EVENT_TABLE( cbBarHintsPlugin, cbPluginBase )
	52
	53	EVT_PL_SIZE_BAR_WND ( cbBarHintsPlugin::OnSizeBarWindow )
	54	EVT_PL_DRAW_BAR_DECOR( cbBarHintsPlugin::OnDrawBarDecorations )
	55
	56	EVT_PL_LEFT_DOWN( cbBarHintsPlugin::OnLeftDown )
	57	EVT_PL_LEFT_UP ( cbBarHintsPlugin::OnLeftUp )
	58	EVT_PL_MOTION ( cbBarHintsPlugin::OnMotion )
	59
	60	END_EVENT_TABLE()
	61
	62	cbBarHintsPlugin::cbBarHintsPlugin(void)
	63
	64	: mpPane( 0 ),
	65	mCollapseBoxOn( TRUE ),
	66	mCloseBoxOn ( TRUE ),
	67	mBtnPressed ( FALSE ),
	68	mGrooveCount ( 2 ),
	69	mHintGap ( 4 ),
	70	mXWeight ( 2 )
	71	{}
	72
	73	cbBarHintsPlugin::cbBarHintsPlugin( wxFrameLayout* pLayout, int paneMask )
	74
	75	: cbPluginBase( pLayout, paneMask ),
	76	mpPane( 0 ),
	77	mCollapseBoxOn( TRUE ),
	78	mCloseBoxOn ( TRUE ),
	79	mBtnPressed ( FALSE ),
	80	mGrooveCount ( 2 ),
	81	mHintGap ( 5 ),
	82	mXWeight ( 2 )
	83	{}
	84
	85	void cbBarHintsPlugin::SetGrooveCount( int nGrooves )
	86	{
	87	mGrooveCount = nGrooves;
	88	}
	89
	90	void cbBarHintsPlugin::CreateBoxes()
	91	{
	92	cbCloseBox* box1 = new cbCloseBox();
	93	cbCollapseBox* box2 = new cbCollapseBox();
	94
	95	mBoxes[CLOSE_BOX_IDX] = box1;
	96	mBoxes[COLLAPSE_BOX_IDX] = box2;
	97
	98	for( int i = 0; i != BOXES_IN_HINT; ++i )
	99	{
	100	mBoxes[i]->mpLayout = mpLayout;
	101	mBoxes[i]->mpPlugin = this;
	102	mBoxes[i]->mpWnd = NULL;
	103	}
	104	}
	105
	106	void cbBarHintsPlugin::Draw3DBox( wxDC& dc, const wxPoint& pos, bool pressed )
	107	{
	108	}
	109
	110	void cbBarHintsPlugin::DrawCloseBox( wxDC& dc, const wxPoint& pos, bool pressed )
	111	{
	112	}
	113
	114	void cbBarHintsPlugin::DrawCollapseBox( wxDC& dc, const wxPoint& pos,
	115	bool atLeft, bool disabled, bool pressed )
	116	{
	117	}
	118
	119	void cbBarHintsPlugin::DrawGrooves( wxDC& dc, const wxPoint& pos, int length )
	120	{
	121	int ofs = 0;
	122
	123	for( int i = 0; i != mGrooveCount; ++i, ofs += ( GROOVE_WIDTH + GROOVE_TO_GROOVE_GAP ) )
	124
	125	if ( mpPane->IsHorizontal() )
	126	{
	127	dc.SetPen( mpLayout->mLightPen );
	128	dc.DrawLine( pos.x + ofs, pos.y, pos.x + ofs, pos.y + length - 1 );
	129	dc.DrawPoint( pos.x + ofs + 1, pos.y );
	130
	131	dc.SetPen( mpLayout->mDarkPen );
	132	dc.DrawLine( pos.x + ofs + 2, pos.y, pos.x + ofs + 2, pos.y + length );
	133	dc.DrawPoint( pos.x + ofs + 1, pos.y + length - 1 );
	134	dc.DrawPoint( pos.x + ofs, pos.y + length - 1 );
	135	}
	136	else
	137	{
	138	dc.SetPen( mpLayout->mLightPen );
	139	dc.DrawLine( pos.x, pos.y + ofs, pos.x + length - 1, pos.y + ofs );
	140	dc.DrawPoint( pos.x, pos.y + ofs + 1 );
	141
	142	dc.SetPen( mpLayout->mDarkPen );
	143	dc.DrawLine( pos.x, pos.y + ofs + 2, pos.x + length, pos.y + ofs + 2 );
	144	dc.DrawPoint( pos.x + length - 1, pos.y + ofs + 1 );
	145	dc.DrawPoint( pos.x + length - 1, pos.y + ofs );
	146	}
	147	}
	148
	149	void cbBarHintsPlugin::ExcludeHints( wxRect& rect, cbBarInfo& info )
	150	{
	151	int boxHeight = BTN_BOX_HEIGHT;
	152
	153	// collapse and close box are not placed on fixed bars
	154
	155	if ( info.IsFixed() \|\| ( !mCloseBoxOn && !mCollapseBoxOn ) )
	156
	157	boxHeight = 0;
	158
	159	int height = wxMax( mGrooveCount*(GROOVE_WIDTH + GROOVE_TO_GROOVE_GAP)
	160	- GROOVE_TO_GROOVE_GAP,
	161	boxHeight
	162	);
	163
	164	if ( mpPane->IsHorizontal() )
	165	{
	166	rect.x += ( mHintGap*2 + height );
	167	rect.width -= (height + 2*mHintGap);
	168
	169	rect.x -= info.mDimInfo.mHorizGap + 2;
	170	rect.width += info.mDimInfo.mHorizGap + 2;
	171	}
	172	else
	173	{
	174	rect.y += (mHintGap*2 + height);
	175	rect.height -= (height + 2*mHintGap);
	176
	177	rect.y -= info.mDimInfo.mVertGap + 2;
	178	rect.height += info.mDimInfo.mVertGap + 2;
	179	}
	180	}
	181
	182	void cbBarHintsPlugin::DoDrawHint( wxDC& dc, wxRect& rect,
	183	int pos, int boxOfs, int grooveOfs,
	184	bool isFixed )
	185	{
	186	if ( !isFixed )
	187	{
	188	if ( mpPane->IsHorizontal() )
	189	{
	190	if ( mCloseBoxOn )
	191
	192	mBoxes[CLOSE_BOX_IDX]->Draw( dc );
	193
	194	if ( mCollapseBoxOn )
	195
	196	mBoxes[COLLAPSE_BOX_IDX]->Draw( dc );
	197	}
	198	else
	199	{
	200	if ( mCloseBoxOn )
	201
	202	mBoxes[CLOSE_BOX_IDX]->Draw( dc );
	203
	204	if ( mCollapseBoxOn )
	205
	206	mBoxes[COLLAPSE_BOX_IDX]->Draw( dc );
	207	}
	208	}
	209
	210	if ( mpPane->IsHorizontal() )
	211
	212	DrawGrooves( dc, wxPoint( rect.x + mHintGap + grooveOfs, pos ),
	213	rect.height - (pos - rect.y) - mHintGap );
	214	else
	215	DrawGrooves( dc, wxPoint( rect.x + mHintGap, rect.y + mHintGap + grooveOfs ),
	216	(pos - rect.x) - mHintGap );
	217	}
	218
	219	void cbBarHintsPlugin::GetHintsLayout( wxRect& rect, cbBarInfo& info,
	220	int& boxOfs, int& grooveOfs, int& pos )
	221	{
	222	int boxHeight = BTN_BOX_HEIGHT;
	223	int boxWidth = BTN_BOX_WIDTH + BOX_TO_GROOVE_GAP + BTN_BOX_WIDTH;
	224
	225	// collapse and close box are not placed on fixed bars
	226
	227	if ( info.IsFixed() \|\| ( !mCloseBoxOn && !mCollapseBoxOn ) )
	228	{
	229	boxHeight = 0;
	230	boxWidth = 0;
	231	}
	232	else
	233	if ( !mCloseBoxOn \|\| !mCollapseBoxOn )
	234
	235	boxWidth = BTN_BOX_WIDTH;
	236
	237	int grooveHeight = mGrooveCount*(GROOVE_WIDTH + GROOVE_TO_GROOVE_GAP)
	238	- GROOVE_TO_GROOVE_GAP;
	239
	240	int height = wxMax( grooveHeight, boxHeight );
	241
	242	// center boxs and groves with respect to each other
	243
	244	boxOfs = ( height - boxHeight ) / 2;
	245	grooveOfs = ( height - grooveHeight ) / 2;
	246
	247	pos = ( mpPane->IsHorizontal() ) ? rect.y + mHintGap
	248	: rect.x + rect.width - mHintGap;
	249
	250	// setup positions for boxes
	251
	252	if ( !info.IsFixed() )
	253	{
	254	// what direction "collapse-triangle" should look at?
	255
	256	bool& isAtLeft = ((cbCollapseBox*)(mBoxes[COLLAPSE_BOX_IDX]))->mIsAtLeft;
	257
	258	isAtLeft= info.mBounds.x <= mpPane->mPaneWidth - ( info.mBounds.x + info.mBounds.width );
	259
	260	if ( info.IsExpanded() )
	261	{
	262	isAtLeft = FALSE;
	263
	264	cbBarInfo* pCur = info.mpPrev;
	265
	266	while( pCur )
	267	{
	268	if ( !pCur->IsFixed() )
	269	{
	270	isAtLeft = TRUE; break;
	271	}
	272
	273	pCur = pCur->mpPrev;
	274	}
	275	}
	276
	277	// collapse/expand works only when more not-fixed bars are present in the same row
	278
	279	mBoxes[COLLAPSE_BOX_IDX]->Enable( info.mpRow->mNotFixedBarsCnt > 1 );
	280
	281	for( int i = 0; i != BOXES_IN_HINT; ++i )
	282
	283	mBoxes[i]->mpPane = mpPane;
	284
	285
	286	if ( mpPane->IsHorizontal() )
	287	{
	288	if ( mCloseBoxOn )
	289	{
	290	mBoxes[CLOSE_BOX_IDX]->mPos = wxPoint( rect.x + mHintGap + boxOfs, pos );
	291
	292	pos += BTN_BOX_HEIGHT;
	293	}
	294
	295	if ( mCollapseBoxOn )
	296	{
	297	if ( mCloseBoxOn ) pos += BOX_T_BOX_GAP;
	298
	299	mBoxes[COLLAPSE_BOX_IDX]->mPos = wxPoint( rect.x + mHintGap + boxOfs, pos );
	300
	301	pos += BTN_BOX_HEIGHT;
	302
	303	pos += BOX_TO_GROOVE_GAP;
	304	}
	305	}
	306	else
	307	{
	308	if ( mCloseBoxOn )
	309	{
	310	pos -= BTN_BOX_WIDTH;
	311
	312	mBoxes[CLOSE_BOX_IDX]->mPos = wxPoint( pos , rect.y + mHintGap + boxOfs );
	313	}
	314
	315	if ( mCollapseBoxOn )
	316	{
	317	if ( mCloseBoxOn ) pos -= BOX_T_BOX_GAP;
	318
	319	pos -= BTN_BOX_WIDTH;
	320
	321	mBoxes[COLLAPSE_BOX_IDX]->mPos = wxPoint( pos, rect.y + mHintGap + boxOfs );
	322
	323	pos -= BOX_TO_GROOVE_GAP;
	324	}
	325	}
	326	}
	327	}
	328
	329	static inline bool is_in_box( const wxPoint& rectPos, const wxPoint& mousePos )
	330	{
	331	return ( mousePos.x >= rectPos.x &&
	332	mousePos.y >= rectPos.y &&
	333	mousePos.x < rectPos.x + BTN_BOX_WIDTH &&
	334	mousePos.y < rectPos.y + BTN_BOX_HEIGHT );
	335	}
	336
	337	int cbBarHintsPlugin::HitTestHints( cbBarInfo& info, const wxPoint& pos )
	338	{
	339	wxPoint inPane = pos;
	340	mpPane->PaneToFrame( &inPane.x, &inPane.y );
	341
	342	wxRect& rect = info.mBoundsInParent;
	343
	344	if ( info.IsFixed() ) return FALSE;
	345
	346	int boxOfs, grooveOfs, coord;
	347
	348	GetHintsLayout( rect, info, boxOfs, grooveOfs, coord );
	349
	350	if ( mpPane->IsHorizontal() )
	351	{
	352	if ( mCloseBoxOn )
	353	{
	354	if ( is_in_box( wxPoint( rect.x + mHintGap + boxOfs, coord ), inPane ) )
	355
	356	return CLOSE_BOX_HITTED;
	357
	358	coord += BTN_BOX_HEIGHT;
	359	}
	360
	361	if ( mCollapseBoxOn )
	362	{
	363	if ( mCloseBoxOn ) coord += BOX_T_BOX_GAP;
	364
	365	if ( is_in_box( wxPoint( rect.x + mHintGap + boxOfs, coord ), inPane ) )
	366
	367	return COLLAPSE_BOX_HITTED;
	368
	369	coord += BTN_BOX_HEIGHT;
	370	}
	371	}
	372	else
	373	{
	374	if ( mCloseBoxOn )
	375	{
	376	coord -= BTN_BOX_WIDTH;
	377
	378	if ( is_in_box( wxPoint( coord , rect.y + mHintGap + boxOfs ), inPane ) )
	379
	380	return CLOSE_BOX_HITTED;
	381	}
	382
	383	if ( mCollapseBoxOn )
	384	{
	385	if ( mCloseBoxOn ) coord -= BOX_T_BOX_GAP;
	386	coord -= BTN_BOX_WIDTH;
	387
	388	if ( is_in_box( wxPoint( coord, rect.y + mHintGap + boxOfs ), inPane ) )
	389
	390	return COLLAPSE_BOX_HITTED;
	391	}
	392	}
	393
	394	return FALSE;
	395	}
	396
	397	// handlers for plugin-events
	398
	399	void cbBarHintsPlugin::OnSizeBarWindow( cbSizeBarWndEvent& event )
	400	{
	401	wxRect& rect = event.mBoundsInParent;
	402	mpPane = event.mpPane;
	403
	404	ExcludeHints( rect, *event.mpBar );
	405
	406	event.Skip(); // pass event to the next plugin in the chain
	407	}
	408
	409	void cbBarHintsPlugin::OnDrawBarDecorations( cbDrawBarDecorEvent& event )
	410	{
	411	wxRect& rect = event.mBoundsInParent;
	412	mpPane = event.mpPane;
	413
	414	int boxOfs, grooveOfs, pos;
	415
	416	GetHintsLayout( rect, *event.mpBar, boxOfs, grooveOfs, pos );
	417
	418	DoDrawHint( *event.mpDc, rect, pos, boxOfs, grooveOfs, event.mpBar->IsFixed() );
	419
	420	// let other plugins add on their decorations
	421
	422	event.Skip();
	423	}
	424
	425	void cbBarHintsPlugin::OnLeftDown( cbLeftDownEvent& event )
	426	{
	427	mpPane = event.mpPane;
	428
	429	wxPoint inFrame = event.mPos;
	430	mpPane->PaneToFrame( &inFrame.x, &inFrame.y );
	431
	432	wxBarIterator iter( mpPane->GetRowList() );
	433
	434	mpClickedBar = NULL;
	435
	436	while ( iter.Next() )
	437	{
	438	cbBarInfo& bar = iter.BarInfo();
	439
	440	int boxOfs, grooveOfs, pos;
	441
	442	GetHintsLayout( bar.mBoundsInParent, bar, boxOfs, grooveOfs, pos );
	443
	444	if ( !bar.IsFixed() )
	445
	446	for( int i = 0; i != BOXES_IN_HINT; ++i )
	447	{
	448	mBoxes[i]->OnLeftDown( inFrame );
	449
	450	if ( mBoxes[i]->mPressed )
	451	{
	452	mBtnPressed = TRUE;
	453	mpClickedBar = &bar;
	454
	455	return; // event handled
	456	}
	457	}
	458	}
	459
	460	event.Skip();
	461	}
	462
	463	void cbBarHintsPlugin::OnLeftUp( cbLeftUpEvent& event )
	464	{
	465	if ( mBtnPressed )
	466	{
	467	wxPoint inFrame = event.mPos;
	468	mpPane->PaneToFrame( &inFrame.x, &inFrame.y );
	469
	470	int boxOfs, grooveOfs, pos;
	471
	472	GetHintsLayout( mpClickedBar->mBoundsInParent, *mpClickedBar, boxOfs, grooveOfs, pos );
	473
	474	int result = HitTestHints( *mpClickedBar, event.mPos );
	475
	476	for( int i = 0; i != BOXES_IN_HINT; ++i )
	477	{
	478	mBoxes[i]->OnLeftUp( inFrame );
	479
	480	if ( mBoxes[i]->WasClicked() )
	481	{
	482	if ( i == 0 )
	483
	484	mpLayout->SetBarState( mpClickedBar, wxCBAR_HIDDEN, TRUE );
	485	else
	486	{
	487	if ( mpClickedBar->IsExpanded() )
	488
	489	mpPane->ContractBar( mpClickedBar );
	490	else
	491	mpPane->ExpandBar( mpClickedBar );
	492	}
	493	}
	494	}
	495
	496	mBtnPressed = FALSE;
	497	return;
	498	}
	499	else
	500	event.Skip();
	501	}
	502
	503	void cbBarHintsPlugin::OnMotion( cbMotionEvent& event )
	504	{
	505	if ( mBtnPressed )
	506	{
	507	wxPoint inFrame = event.mPos;
	508	mpPane->PaneToFrame( &inFrame.x, &inFrame.y );
	509
	510	mpPane = event.mpPane;
	511
	512	for( int i = 0; i != BOXES_IN_HINT; ++i )
	513
	514	mBoxes[i]->OnMotion( inFrame );
	515	}
	516	else
	517	event.Skip();
	518	}
	519
	520	void cbBarHintsPlugin::OnInitPlugin()
	521	{
	522	cbPluginBase::OnInitPlugin();
	523
	524	cbDockPane** panes = mpLayout->GetPanesArray();
	525
	526	for( int i = 0; i != MAX_PANES; ++i )
	527
	528	if ( panes[i]->MatchesMask( mPaneMask ) )
	529	{
	530	panes[i]->mProps.mMinCBarDim.x = 25;
	531	panes[i]->mProps.mMinCBarDim.y = 16;
	532	}
	533
	534	CreateBoxes();
	535	}