contrib/src/fl/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 "barhintspl.h"
#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 "wx/fl/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 ),
	  mBtnPressed   ( FALSE ),
	  mCloseBoxOn   ( TRUE ),
	  mCollapseBoxOn( TRUE ),
	  mGrooveCount  ( 2 ),
	  mHintGap      ( 4 ),
	  mXWeight      ( 2 )
{
	mBoxes[CLOSE_BOX_IDX]    = NULL;
	mBoxes[COLLAPSE_BOX_IDX] = NULL;
}

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

	: cbPluginBase( pLayout, paneMask ),
	  mpPane( 0 ),
	  mBtnPressed   ( FALSE ),
	  mCloseBoxOn   ( TRUE ),
	  mCollapseBoxOn( TRUE ),
	  mGrooveCount  ( 2 ),
	  mHintGap      ( 5 ),
	  mXWeight      ( 2 )
{
	mBoxes[CLOSE_BOX_IDX]    = NULL;
	mBoxes[COLLAPSE_BOX_IDX] = NULL;
}


cbBarHintsPlugin::~cbBarHintsPlugin()
{
    if (mBoxes[CLOSE_BOX_IDX])
        delete mBoxes[CLOSE_BOX_IDX];

	if (mBoxes[COLLAPSE_BOX_IDX])
        delete mBoxes[COLLAPSE_BOX_IDX];
}  // cbBarHintsPlugin destructor


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;

   int i;
	for( 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;

   int i;
	for( 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 );

      int i;
		for( 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() )
      {
         int i;
			for( 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 );

        int i;
		for( 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;

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

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

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

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

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