[wxWidgets.git] / 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
bd9396d5 HH	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	}