cheng/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
99b1023fd8
wxWidgets/demos/dbbrowse/tabpgwin.cpp
Julian Smart 74de91cc97 Applied [ 880011 ] Several fixes to DbBrowse demo 
ABX


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@25611 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2004-02-08 11:53:48 +00:00

1199 lines
34 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////
// Name: tabpgwin.cpp
// Purpose: Contrib. demo
// Author: Aleksandras Gluchovas
// Modified by: 19990908 : mj
// - rename to tabpgwin
// - restruction of Variable declaration
// - to prevent Warnings under MingW32
// Modified by: 19990909 : mj
// - mNoVertScroll TRUE = no / FALSE = Original Code
// the Original Code Paints a Vertical Scroll in wxPagedWindow
// which is not needed in this Version. Use TRUE for this.
// Created: 07/09/98
// RCS-ID: $Id$
// Copyright: (c) Aleksandras Gluchovas
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation
//#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 <math.h>
#include <stdlib.h>
#include "wx/string.h"
#include "wx/utils.h" // import wxMin/wxMax macros and wxFileExist(..)
#include "tabpgwin.h"
//---------------------------------------------------------------------------
// Implementation for class twTabInfo
//---------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS( twTabInfo, wxObject )
//---------------------------------------------------------------------------
twTabInfo::twTabInfo()
: mpContent( 0 )
{}
//---------------------------------------------------------------------------
twTabInfo::~twTabInfo()
{
// FOR NOW:: nothing
}
//---------------------------------------------------------------------------
int twTabInfo::ImgWidth()
{
if ( mBitMap.Ok() ) return mBitMap.GetWidth();
else return 0;
}
//---------------------------------------------------------------------------
int twTabInfo::ImgHeight()
{
if ( mBitMap.Ok() )
return mBitMap.GetHeight();
else
return 0;
}
//---------------------------------------------------------------------------
int twTabInfo::ImageToTxtGap( int prefGap )
{
if ( mBitMap.Ok() )
return prefGap;
else
return 0;
}
//---------------------------------------------------------------------------
bool twTabInfo::HasImg()
{
return mBitMap.Ok();
}
//---------------------------------------------------------------------------
// bool twTabInfo::HasText();
unsigned int twTabInfo::HasText()
{
return mText.Length();
}
//---------------------------------------------------------------------------
wxBitmap& twTabInfo::GetImg()
{
return mBitMap;
}
//---------------------------------------------------------------------------
wxString& twTabInfo::GetText()
{
return mText;
}
//---------------------------------------------------------------------------
wxWindow& twTabInfo::GetContent()
{
return *mpContent;
}
//---------------------------------------------------------------------------
// Implementation for class wxTabbedWindow
//---------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS( wxTabbedWindow, wxPanel )
//---------------------------------------------------------------------------
BEGIN_EVENT_TABLE( wxTabbedWindow, wxPanel )
EVT_SIZE ( wxTabbedWindow::OnSize )
EVT_PAINT( wxTabbedWindow::OnPaint )
EVT_LEFT_DOWN( wxTabbedWindow::OnLButtonDown )
// TDB:: filciker reduction
// EVT_ERASE_BACKGROUND( wxTabbedWindow::OnBkErase )
END_EVENT_TABLE()
//---------------------------------------------------------------------------
wxTabbedWindow::wxTabbedWindow()
: mpTabScroll ( NULL ),
mpHorizScroll( NULL ),
mpVertScroll ( NULL ),
mVertGap ( 0 ),
mHorizGap( 0 ),
mTitleVertGap ( 3 ),
mTitleHorizGap( 4 ),
mImageTextGap ( 2 ),
mFirstTitleGap( 11 ),
mBorderOnlyWidth( 8 ),
mWhitePen( wxColour(255,255,255), 1, wxSOLID ),
mGrayPen ( wxColour(192,192,192), 1, wxSOLID ),
mDarkPen ( wxColour(128,128,128), 1, wxSOLID ),
mBlackPen( wxColour( 0, 0, 0), 1, wxSOLID ),
// state variables
mActiveTab ( 0 ),
mTitleHeight( 0 ),
mLayoutType( wxTITLE_IMG_AND_TEXT )
{}
//---------------------------------------------------------------------------
wxTabbedWindow::~wxTabbedWindow()
{
wxNode* pTab = mTabs.GetFirst();
while( pTab )
{
delete ((twTabInfo*)pTab->GetData());
pTab = pTab->GetNext();
}
}
//---------------------------------------------------------------------------
void wxTabbedWindow::SizeTabs(int x,int y, int width, int height, bool WXUNUSED(repant))
{
wxNode* pTabNode = mTabs.GetFirst();
size_t n = 0;
while( pTabNode )
{
twTabInfo& info = *((twTabInfo*)pTabNode->GetData());
if ( n == mActiveTab )
{
//wxSizeEvent evt;
//info.mpContent->GetEventHandler()->ProcessEvent( evt );
info.mpContent->SetSize( x, y, width, height, 0 );
info.mpContent->Show(TRUE);
info.mpContent->Refresh();
}
else
{
info.mpContent->Show(FALSE);
}
pTabNode = pTabNode->GetNext();
++n;
}
}
//---------------------------------------------------------------------------
void wxTabbedWindow::AddTab( wxWindow* pContent,
wxString tabText,
wxString imageFileName,
wxBitmapType imageType )
{
twTabInfo* pTab = new twTabInfo();
pTab->mpContent = pContent;
pTab->mText = tabText;
if ( wxFileExists( imageFileName ) &&
pTab->mBitMap.LoadFile( imageFileName, imageType ) )
{
pTab->mImageFile = imageFileName;
pTab->mImageType = imageType;
}
if ( pContent->GetParent() == NULL )
pContent->Create( this, -1 );
mTabs.Append( (wxObject*)pTab );
RecalcLayout(TRUE);
OnTabAdded( pTab );
}
//---------------------------------------------------------------------------
void wxTabbedWindow::AddTab( wxWindow* pContent,
wxString tabText, wxBitmap* pImage )
{
twTabInfo* pTab = new twTabInfo();
pTab->mpContent = pContent;
pTab->mText = tabText;
if ( pImage )
pTab->mBitMap = *pImage;
if ( pContent->GetParent() == NULL )
pContent->Create( this, -1 );
mTabs.Append( (wxObject*)pTab );
RecalcLayout(TRUE);
OnTabAdded( pTab );
}
//---------------------------------------------------------------------------
void wxTabbedWindow::RemoveTab( int tabNo )
{
twTabInfo* pTab = ((twTabInfo*)(mTabs.Item( tabNo )->GetData()));
pTab->mpContent->Destroy();
delete pTab;
mTabs.DeleteNode( mTabs.Item( tabNo ) );
// if ( mActiveTab >= mTabs.GetCount() );
if ( mActiveTab >= mTabs.GetCount() )
mActiveTab = mTabs.GetCount() - 1;
SetActiveTab( mActiveTab );
}
//---------------------------------------------------------------------------
int wxTabbedWindow::GetTabCount()
{
return mTabs.GetCount();
}
//---------------------------------------------------------------------------
wxWindow* wxTabbedWindow::GetTab( int tabNo )
{
return ((twTabInfo*)(mTabs.Item( tabNo )->GetData()))->mpContent;
}
//---------------------------------------------------------------------------
wxWindow* wxTabbedWindow::GetActiveTab()
{
// FIMXE:: this is lame
return GetTab( mActiveTab );
}
//---------------------------------------------------------------------------
void wxTabbedWindow::SetActiveTab( int tabNo )
{
mActiveTab = tabNo;
RecalcLayout(TRUE);
Refresh();
}
//---------------------------------------------------------------------------
// width of the decorations border (4 shade-lines), should not be changed
//---------------------------------------------------------------------------
#define BORDER_SZ 4
//---------------------------------------------------------------------------
void wxTabbedWindow::DrawShadedRect( int x, int y, int width, int height,
wxPen& upperPen, wxPen& lowerPen, wxDC& dc
)
{
// darw the lightened upper-left sides of the rectangle
dc.SetPen( upperPen );
dc.DrawLine( x,y, x, y + height - 1 ); // vert
dc.DrawLine( x,y, x + width - 1, y ); // horiz
// draw the unenlightened lower-right sides of the rectangle
dc.SetPen( lowerPen );
dc.DrawLine( x + width - 1, y, x + width - 1, y + height - 1 ); // vert
dc.DrawLine( x, y + height - 1, x + width, y + height - 1 ); // horiz
}
//---------------------------------------------------------------------------
void wxTabbedWindow::DrawDecorations( wxDC& dc )
{
// Protability NOTE::: DrawLine(..) draws a line from the first position,
// but not including the point specified by last position.
// This way Windows draws lines, not sure how Motif and Gtk
// prots behave...
int width, height;
GetClientSize( &width, &height );
// check if there's at least a bit of space to draw things
if ( width < mHorizGap*2 + BORDER_SZ*2+1 ||
height < mVertGap*2 + BORDER_SZ*2+1 + mTitleHeight
)
return;
// step #1 - draw border around the tab content area
// setup position for kind of "pencil"
int curX = mHorizGap;
int curY = mVertGap;
int xSize = width - mHorizGap*2;
int ySize = height - mVertGap *2 - mTitleHeight;
// layer 1 (upper white)
DrawShadedRect( curX+0, curY+0, xSize-0, ySize-0,
mWhitePen, mBlackPen, dc );
// layer 2 (upper gray)
DrawShadedRect( curX+1, curY+1, xSize-2-1, ySize-2-1,
mGrayPen, mGrayPen, dc );
// layer 3 (upper darkGray)
DrawShadedRect( curX+2, curY+2, xSize-3-2, ySize-3-2,
mDarkPen, mWhitePen, dc );
// layer 4 (upper black)
DrawShadedRect( curX+3, curY+3, xSize-4-3, ySize-4-3,
mBlackPen, mGrayPen, dc );
// add non-siemtric layer from the lower-right side (confroming to MFC-look)
dc.SetPen( mDarkPen );
dc.DrawLine( curX+1, curY + ySize - 2, curX + xSize - 1, curY + ySize - 2 ); // horiz
dc.DrawLine( curX + xSize - 2, curY + 1, curX + xSize - 2, curY + ySize - 2 ); // vert
// step #2 - draw tab title bars
curX = mFirstTitleGap;
curY = height - mVertGap - mTitleHeight;
size_t tabNo = 0;
wxNode* pNode = mTabs.GetFirst();
while( pNode )
{
// "hard-coded metafile" for decorations
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
xSize = tab.mDims.x;
ySize = mTitleHeight;
if ( tabNo == mActiveTab )
{
dc.SetPen( mGrayPen );
dc.DrawLine( curX+1, curY-2, curX+xSize-2, curY-2 );
dc.DrawLine( curX+1, curY-1, curX+xSize-2, curY-1 );
}
dc.SetPen( mWhitePen );
if ( tabNo == mActiveTab )
dc.DrawLine( curX, curY-2, curX, curY+ySize-2 );
else
dc.DrawLine( curX, curY, curX, curY+ySize-2 );
dc.SetPen( mDarkPen );
dc.DrawLine( curX+1, curY+ySize-3, curX+1, curY+ySize-1 ); // to pix down
dc.DrawLine( curX+2, curY+ySize-2, curX+xSize-2, curY+ySize-2 );
dc.DrawLine( curX+xSize-3, curY+ySize-3, curX+xSize-2, curY+ySize-3 );
if ( tabNo == mActiveTab )
dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-3 );
else
dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-1 );
dc.SetPen( mBlackPen );
dc.DrawLine( curX+xSize-1, curY, curX+xSize-1, curY+ySize-2 );
dc.DrawLine( curX+xSize-2, curY+ySize-2, curX+xSize-3, curY+ySize-2 );
dc.DrawLine( curX+xSize-3, curY+ySize-1, curX+1, curY+ySize-1 );
pNode = pNode->GetNext();
++tabNo;
// darw image and (or without) text centered within the
// title bar rectangle
if ( mLayoutType != wxTITLE_BORDER_ONLY && tab.HasImg() )
{
wxMemoryDC tmpDc;
tmpDc.SelectObject( tab.GetImg() );
dc.Blit( curX + mTitleHorizGap,
curY + ( ySize - tab.ImgHeight() ) / 2,
tab.ImgWidth(),
tab.ImgHeight(),
&tmpDc, 0, 0, wxCOPY
);
}
if ( mLayoutType == wxTITLE_IMG_AND_TEXT && tab.HasText() )
{
long x,w,h;
// set select default font of the window into it's device context
//dc.SetFont( GetLabelingFont() );
dc.SetTextBackground( GetBackgroundColour() );
dc.GetTextExtent(tab.mText, &w, &h );
x = curX + mTitleHorizGap +
tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap);
dc.DrawText( tab.GetText(), x, curY + ( ySize - h ) / 2 );
}
curX += xSize;
} // end of `while (pNode)'
} // wxTabbedWindow::DrawDecorations()
//---------------------------------------------------------------------------
int wxTabbedWindow::HitTest( const wxPoint& pos )
{
int width, height;
GetClientSize( &width, &height );
int curX = mFirstTitleGap;
int curY = height - mVertGap - mTitleHeight;
int tabNo = 0;
wxNode* pNode = mTabs.GetFirst();
while( pNode )
{
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
// hit test rectangle of the currnet tab title bar
if ( pos.x >= curX && pos.x < curX + tab.mDims.x &&
pos.y >= curY && pos.y < curY + tab.mDims.y
)
{
return tabNo;
}
curX += tab.mDims.x;
pNode = pNode->GetNext();
++tabNo;
}
return -1;
} // wxTabbedWindow::HitTest()
//---------------------------------------------------------------------------
void wxTabbedWindow::HideInactiveTabs( bool andRepaint )
{
if ( !andRepaint )
return;
wxNode* pNode = mTabs.GetFirst();
size_t tabNo = 0;
while( pNode )
{
if ( tabNo != mActiveTab )
{
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
tab.mpContent->Show(FALSE);
}
pNode = pNode->GetNext();
++tabNo;
}
} // wxTabbedWindow::HideInactiveTabs()
//---------------------------------------------------------------------------
wxFont wxTabbedWindow::GetLabelingFont()
{
wxFont font;
#ifdef __WINDOWS__
font.SetFaceName(_T("MS Sans Serif"));
#else
font.SetFamily( wxSWISS );
#endif
font.SetStyle(40);
font.SetWeight(40);
font.SetPointSize( 8 );
#ifdef __WINDOWS__
font.RealizeResource();
#endif
return font;
} // wxTabbedWindow::GetLabelingFont()
//---------------------------------------------------------------------------
void wxTabbedWindow::RecalcLayout(bool andRepaint)
{
HideInactiveTabs(andRepaint);
// resetup position of the active tab
int width, height;
GetClientSize( &width, &height );
int curX = mHorizGap + BORDER_SZ;
int curY = mVertGap + BORDER_SZ;
int xSize = width - mHorizGap*2 - BORDER_SZ*2-1;
int ySize = height - mVertGap*2 - BORDER_SZ*2-1 - mTitleHeight;
SizeTabs( curX, curY, xSize, ySize, andRepaint );
// pass #1 - try to layout assuming it's wxTITLE_IMG_AND_TEXT
mLayoutType = wxTITLE_IMG_AND_TEXT;
wxNode* pNode = mTabs.GetFirst();
curX = mFirstTitleGap; // the left-side gap
mTitleHeight = 0;
while( pNode )
{
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
wxWindowDC dc(this);
long w,h;
// set select default font of the window into it's device context
//dc.SetFont( GetLabelingFont() );
dc.GetTextExtent(tab.mText, &w, &h );
tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) +
tab.ImgWidth() + mTitleHorizGap*2;
tab.mDims.y = wxMax( h, tab.ImgHeight() ) + mTitleVertGap*2;
mTitleHeight = wxMax( mTitleHeight, tab.mDims.y );
curX += tab.mDims.x;
pNode = pNode->GetNext();
}
curX += mHorizGap; // the right-side gap
// make all title bars of equel height
pNode = mTabs.GetFirst();
while( pNode )
{
((twTabInfo*)(pNode->GetData()))->mDims.y = mTitleHeight;;
pNode = pNode->GetNext();
}
// if curX has'nt ran out of bounds, leave TITLE_IMG layout and return
if ( curX < width - mHorizGap )
return;
// pass #2 - try to layout assuming wxTITLE_IMG_ONLY
mLayoutType = wxTITLE_IMG_ONLY;
pNode = mTabs.GetFirst();
curX = mFirstTitleGap; // the left-side gap
int denomiator = mTabs.GetCount();
if ( denomiator == 0 )
++denomiator;
mBorderOnlyWidth = (width - mFirstTitleGap - mHorizGap) / denomiator;
while( pNode )
{
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
if ( tab.HasImg() )
{
tab.mDims.x = tab.ImgWidth() + mTitleHorizGap*2;
tab.mDims.y = tab.ImgHeight() + mTitleVertGap*2;
}
else
{
tab.mDims.x = mBorderOnlyWidth;
tab.mDims.y = mTitleHeight;
}
curX += tab.mDims.x;
pNode = pNode->GetNext();
}
curX += mHorizGap; // the right-side gap
// if curX has'nt ran out of bounds, leave IMG_ONLY layout and return
if ( curX < width - mHorizGap )
return;
// pass #3 - set the narrowest layout wxTITLE_BORDER_ONLY
mLayoutType = wxTITLE_BORDER_ONLY;
pNode = mTabs.GetFirst();
while( pNode )
{
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
tab.mDims.x = mBorderOnlyWidth;
tab.mDims.y = mTitleHeight;
pNode = pNode->GetNext();
}
} // wxTabbedWindow::RecalcLayout()
//---------------------------------------------------------------------------
// wx event handlers
//---------------------------------------------------------------------------
void wxTabbedWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
wxPaintDC dc(this);
DrawDecorations( dc );
}
//---------------------------------------------------------------------------
void wxTabbedWindow::OnSize ( wxSizeEvent& WXUNUSED(event) )
{
SetBackgroundColour( wxColour( 192,192,192 ) );
RecalcLayout(TRUE);
}
//---------------------------------------------------------------------------
void wxTabbedWindow::OnBkErase( wxEraseEvent& WXUNUSED(event) )
{
// do nothing
}
//---------------------------------------------------------------------------
void wxTabbedWindow::OnLButtonDown( wxMouseEvent& event )
{
// floats, why?
int x = (int)event.m_x;
int y = (int)event.m_y;
int tabNo = HitTest( wxPoint(x,y) );
if ( tabNo != -1 )
{
SetActiveTab( tabNo );
}
}
//---------------------------------------------------------------------------
// Implementation for class wxPagedWindow
//---------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS( wxPagedWindow, wxTabbedWindow )
//---------------------------------------------------------------------------
BEGIN_EVENT_TABLE( wxPagedWindow, wxTabbedWindow )
EVT_SIZE ( wxPagedWindow::OnSize )
EVT_PAINT ( wxPagedWindow::OnPaint )
EVT_LEFT_DOWN( wxPagedWindow::OnLButtonDown )
EVT_LEFT_UP ( wxPagedWindow::OnLButtonUp )
EVT_MOTION ( wxPagedWindow::OnMouseMove )
EVT_SCROLL ( wxPagedWindow::OnScroll )
END_EVENT_TABLE()
//---------------------------------------------------------------------------
// border for paged-window is 2 shaded-lines
//---------------------------------------------------------------------------
#undef BORDER_SZ
#define BORDER_SZ 2
//---------------------------------------------------------------------------
wxPagedWindow::wxPagedWindow()
: mScrollEventInProgress( FALSE ),
mTabTrianGap(4),
mWhiteBrush( wxColour(255,255,255), wxSOLID ),
mGrayBrush ( wxColour(192,192,192), wxSOLID ),
mCurentRowOfs( 0 ),
mAdjustableTitleRowLen( 300 ),
mIsDragged ( FALSE ),
mDagOrigin ( 0 ),
mCursorChanged( FALSE ),
mResizeCursor ( wxCURSOR_SIZEWE ),
mNormalCursor ( wxCURSOR_ARROW )
{
mTitleVertGap = 2;
mTitleHorizGap = 10;
mNoVertScroll = TRUE; // Horizontale Scroll abschalten
}
//---------------------------------------------------------------------------
wxPagedWindow::~wxPagedWindow()
{
// nothing (base class handles destruction)
}
//---------------------------------------------------------------------------
wxFont wxPagedWindow::GetLabelingFont()
{
wxFont font;
#ifdef __WINDOWS__
font.SetFaceName(_T("Comic Sans MS"));
#else
font.SetFamily( wxSWISS );
#endif
font.SetStyle(40);
font.SetWeight(40);
font.SetPointSize( 8 );
return font;
}
//---------------------------------------------------------------------------
void wxPagedWindow::OnTabAdded( twTabInfo* WXUNUSED(pInfo) )
{
int units = GetWholeTabRowLen() / 20;
mpTabScroll->SetScrollbar( 0, 1, units, 1, FALSE );
}
//---------------------------------------------------------------------------
wxScrollBar& wxPagedWindow::GetVerticalScrollBar()
{
return *mpVertScroll;
}
//---------------------------------------------------------------------------
wxScrollBar& wxPagedWindow::GetHorizontalScrollBar()
{
return *mpHorizScroll;
}
//---------------------------------------------------------------------------
int wxPagedWindow::GetWholeTabRowLen()
{
wxNode* pNode = mTabs.GetFirst();
int len = 0;
while( pNode )
{
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
len += tab.mDims.x;
pNode = pNode->GetNext();
}
return len;
} // wxPagedWindow::GetWholeTabRowLen()
//---------------------------------------------------------------------------
void wxPagedWindow::DrawPaperBar( twTabInfo& tab, int x, int y,
wxBrush& brush, wxPen& pen, wxDC& dc )
{
wxPoint poly[4];
// draw organizer-style paper outlet
poly[0].x = x - mTabTrianGap;
poly[0].y = y;
poly[1].x = x + mTabTrianGap;
poly[1].y = y + tab.mDims.y-1;
poly[2].x = x + tab.mDims.x - mTabTrianGap;
poly[2].y = y + tab.mDims.y-1;
poly[3].x = x + tab.mDims.x + mTabTrianGap;
poly[3].y = y;
dc.SetPen( pen );
dc.SetBrush( brush );
dc.DrawPolygon( 4, poly );
long w,h;
// set select default font of the window into it's device context
//dc.SetFont( GetLabelingFont() );
dc.SetTextBackground( brush.GetColour() );
dc.GetTextExtent(tab.mText, &w, &h );
if ( tab.HasImg() )
{
wxMemoryDC tmpDc;
tmpDc.SelectObject( tab.GetImg() );
dc.Blit( x + mTitleHorizGap,
y + ( tab.mDims.y - tab.ImgHeight() ) / 2,
tab.ImgWidth(),
tab.ImgHeight(),
&tmpDc, 0, 0, wxCOPY
);
}
if ( tab.HasText() )
{
int tx = x + mTitleHorizGap +
tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap);
dc.DrawText( tab.GetText(), tx, y + ( tab.mDims.y - h ) / 2 );
}
} // wxPagedWindow::DrawPaperBar()
//---------------------------------------------------------------------------
void wxPagedWindow::DrawDecorations( wxDC& dc )
{
// FIXME:: the is big body have to be split!
int width, height;
GetClientSize( &width, &height );
int curX = mHorizGap;
int curY = mVertGap;
int xSize = width - mHorizGap*2;
int ySize = height - mVertGap*2;
DrawShadedRect( curX, curY, xSize, ySize,
mDarkPen, mWhitePen, dc );
DrawShadedRect( curX+1, curY+1, xSize-2, ySize-2,
mBlackPen, mGrayPen, dc );
// draw inactive tab title bars frist (left-to-right)
wxNode* pNode = mTabs.GetFirst();
size_t tabNo = 0;
/* OLD STUFF::
curX = mTitleRowStart;
curY = height - mVertGap - BORDER_SZ - mTitleHeight;
*/
curX = mTabTrianGap;
curY = 0;
// FOR NOW:: avoid creating bitmap with invalid dimensions
if ( mTitleRowLen < 1 || mTitleHeight < 1 )
return;
wxMemoryDC tmpDc;
wxBitmap tmpBmp( mTitleRowLen, mTitleHeight );
tmpDc.SelectObject( tmpBmp );
tmpDc.SetPen( mGrayPen );
tmpDc.SetBrush( mGrayBrush );
tmpDc.DrawRectangle( 0,0, mTitleRowLen, mTitleHeight );
tmpDc.SetDeviceOrigin( mCurentRowOfs, 0 );
while( pNode )
{
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
if ( tabNo != mActiveTab )
DrawPaperBar( tab, curX, curY, mGrayBrush, mBlackPen, tmpDc );
curX += tab.mDims.x;
pNode = pNode->GetNext();
++tabNo;
}
// finally, draw the active tab (white-filled)
pNode = mTabs.GetFirst();
tabNo = 0;
curX = mTabTrianGap;
while( pNode )
{
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
if ( tabNo == mActiveTab )
{
DrawPaperBar( tab, curX, curY, mWhiteBrush, mBlackPen, tmpDc );
tmpDc.SetPen( mWhitePen );
tmpDc.DrawLine( curX - mTabTrianGap+1, curY,
curX + tab.mDims.x + mTabTrianGap, curY );
break;
}
curX += tab.mDims.x;
pNode = pNode->GetNext();
++tabNo;
}
// back to initial device origin
tmpDc.SetDeviceOrigin( 0, 0 );
// draw resize-hint-stick
curX = mTitleRowLen - 6;
DrawShadedRect( curX+0, 0+0, 6, mTitleHeight, mGrayPen, mBlackPen, tmpDc );
DrawShadedRect( curX+1, 0+1, 6-2, mTitleHeight-2, mWhitePen, mDarkPen, tmpDc );
DrawShadedRect( curX+2, 0+2, 6-4, mTitleHeight-4, mGrayPen, mGrayPen, tmpDc );
dc.Blit( mTitleRowStart,
height - mVertGap - BORDER_SZ - mTitleHeight,
mTitleRowLen, mTitleHeight,
&tmpDc, 0,0, wxCOPY );
} // wxPagedWindow::DrawDecorations()
//---------------------------------------------------------------------------
int wxPagedWindow::HitTest( const wxPoint& pos )
{
return wxTabbedWindow::HitTest( pos );
}
//---------------------------------------------------------------------------
void wxPagedWindow::RecalcLayout(bool andRepaint)
{
mTitleRowLen = mAdjustableTitleRowLen;
if ( int(mpTabScroll) == -1 ) return;
// scroll bars should be created after Create() for this window is called
if ( !mpTabScroll )
{
mpTabScroll =
new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL );
mpHorizScroll =
new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL );
if (!mNoVertScroll) // Vertical Scroll (Original)
mpVertScroll = new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_VERTICAL );
}
{
int units = GetWholeTabRowLen() / 20;
mpTabScroll->SetScrollbar( 0, 1, units, 1, FALSE );
}
// resetup position of the active tab
int thumbLen = 16; // FOR NOW:: hardcoded
int width, height;
GetClientSize( &width, &height );
mTitleHeight = thumbLen;
int curX = mHorizGap + BORDER_SZ;
int curY = mVertGap + BORDER_SZ;
int xSize;
if (!mNoVertScroll) // Vertical Scroll (Original)
xSize = width - mHorizGap*2 - BORDER_SZ*2 - thumbLen;
else
xSize = width - mHorizGap*2 - BORDER_SZ*2;
int ySize = height - mVertGap*2 - BORDER_SZ*2 - mTitleHeight;
SizeTabs( curX, curY, xSize, ySize, andRepaint );
// setup title bar LINES's horizontal scroll bar
curY = height - mVertGap - BORDER_SZ - thumbLen;
mpTabScroll->SetSize( curX, curY, thumbLen*2, thumbLen );
// setup view's HORIZONTAL scroll bar
curX += thumbLen*2;
mTitleRowStart = curX;
mFirstTitleGap = curX + mCurentRowOfs + mTabTrianGap;
mTitleRowLen = wxMin( mAdjustableTitleRowLen,
width - mHorizGap - BORDER_SZ - thumbLen*4 - curX );
curX += mTitleRowLen;
if (!mNoVertScroll) // Vertical Scroll (Original)
mpHorizScroll->SetSize( curX, curY,width - curX - mHorizGap - BORDER_SZ - thumbLen, thumbLen );
else
mpHorizScroll->SetSize( curX, curY,width - curX - mHorizGap - BORDER_SZ-4, thumbLen );
// setup view's VERTICAL scroll bar
if (!mNoVertScroll) // Vertical Scroll (Original)
{
curX = width - mHorizGap - BORDER_SZ - thumbLen;
curY = mVertGap + BORDER_SZ;
mpVertScroll->SetSize( curX, curY, thumbLen,height - curY - mVertGap - BORDER_SZ - thumbLen);
}
// layout tab title bars
mLayoutType = wxTITLE_IMG_AND_TEXT;
wxNode* pNode = mTabs.GetFirst();
while( pNode )
{
twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
wxWindowDC dc(this);
long w,h;
// set select default font of the window into it's device context
//dc.SetFont( GetLabelingFont() );
dc.GetTextExtent(tab.mText, &w, &h );
tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) +
tab.ImgWidth() + mTitleHorizGap*2;
tab.mDims.y = mTitleHeight;
pNode = pNode->GetNext();
}
// disable title-bar scroller if there's nowhere to scroll to
mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0 );
}
//---------------------------------------------------------------------------
// event handlers
//---------------------------------------------------------------------------
void wxPagedWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
wxPaintDC dc(this);
DrawDecorations( dc );
}
//---------------------------------------------------------------------------
void wxPagedWindow::OnSize ( wxSizeEvent& event )
{
wxTabbedWindow::OnSize(event);
}
//---------------------------------------------------------------------------
void wxPagedWindow::OnLButtonDown( wxMouseEvent& event )
{
if ( mCursorChanged )
{
mIsDragged = TRUE;
mDagOrigin = event.m_x;
mOriginalTitleRowLen = mAdjustableTitleRowLen;
CaptureMouse();
}
else
{
wxTabbedWindow::OnLButtonDown( event );
}
} // wxPagedWindow::OnLButtonDown()
//---------------------------------------------------------------------------
void wxPagedWindow::OnLButtonUp( wxMouseEvent& WXUNUSED(event) )
{
if ( mIsDragged )
{
mIsDragged = FALSE;
mCursorChanged = FALSE;
SetCursor( mNormalCursor );
ReleaseMouse();
}
} // wxPagedWindow::OnLButtonUp()
//---------------------------------------------------------------------------
void wxPagedWindow::OnMouseMove( wxMouseEvent& event )
{
int width, height;
GetClientSize( &width, &height );
if ( !mIsDragged )
{
int y = height - mVertGap - BORDER_SZ - mTitleHeight;
int x = mTitleRowStart + mTitleRowLen - 6;
if ( event.m_x >= x && event.m_y >= y &&
event.m_x < x + 6 &&
event.m_y < y + mTitleHeight
)
{
if ( !mCursorChanged )
{
SetCursor( mResizeCursor );
mCursorChanged = TRUE;
}
}
else
if ( mCursorChanged )
{
SetCursor( mNormalCursor );
mCursorChanged = FALSE;
}
}
else
{
if ( mIsDragged )
{
mAdjustableTitleRowLen = mOriginalTitleRowLen + ( event.m_x - mDagOrigin );
// FOR NOW:: fixed
if ( mAdjustableTitleRowLen < 6 ) mAdjustableTitleRowLen = 6;
wxWindowDC dc(this);
DrawDecorations( dc );
RecalcLayout(FALSE);
//Refresh();
}
}
} // wxPagedWindow::OnMouseMove()
//---------------------------------------------------------------------------
void wxPagedWindow::OnScroll( wxScrollEvent& event )
{
wxScrollBar* pSender = (wxScrollBar*)event.GetEventObject();
// wxMessageBox("wxPagedWindow::OnScroll","-I->");
if ( pSender == mpTabScroll )
{
int maxUnits = GetWholeTabRowLen() / 20;
mCurentRowOfs = -event.GetPosition()*maxUnits;
mFirstTitleGap = mTitleRowStart + mCurentRowOfs + mTabTrianGap;
// let' it automatically disable itself if it's time
mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0 );
// repaint title bars
wxWindowDC dc(this);
DrawDecorations( dc );
}
else
{
if ( !mScrollEventInProgress )
{
mScrollEventInProgress = TRUE;
GetActiveTab()->GetEventHandler()->ProcessEvent( event );
}
else
{
// event bounced back to us, from here we
// know that it has traveled the loop - thus it's processed!
mScrollEventInProgress = FALSE;
}
}
} // wxPagedWindow::OnScroll()
//---------------------------------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink