3f66f6a5b3
This keyword is not expanded by Git which means it's not replaced with the correct revision value in the releases made using git-based scripts and it's confusing to have lines with unexpanded "$Id$" in the released files. As expanding them with Git is not that simple (it could be done with git archive and export-subst attribute) and there are not many benefits in having them in the first place, just remove all these lines. If nothing else, this will make an eventual transition to Git simpler. Closes #14487. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@74602 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1186 lines
35 KiB
C++
1186 lines
35 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: src/os2/toolbar.cpp
|
|
// Purpose: wxToolBar
|
|
// Author: David Webster
|
|
// Modified by:
|
|
// Created: 06/30/02
|
|
// Copyright: (c) David Webster
|
|
// Licence: wxWindows licence
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// For compilers that support precompilation, includes "wx.h".
|
|
#include "wx/wxprec.h"
|
|
|
|
#if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE
|
|
|
|
#include "wx/toolbar.h"
|
|
|
|
#ifndef WX_PRECOMP
|
|
#include "wx/settings.h"
|
|
#include "wx/window.h"
|
|
#include "wx/frame.h"
|
|
#include "wx/app.h"
|
|
#include "wx/dcclient.h"
|
|
#include "wx/dcmemory.h"
|
|
#endif
|
|
|
|
#include "wx/tooltip.h"
|
|
#include "wx/os2/dcclient.h"
|
|
|
|
bool wxToolBar::m_bInitialized = false;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// private classes
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class wxToolBarTool : public wxToolBarToolBase
|
|
{
|
|
public:
|
|
inline wxToolBarTool( wxToolBar* pTbar
|
|
,int vId
|
|
,const wxString& rsLabel
|
|
,const wxBitmap& rBitmap1
|
|
,const wxBitmap& rBitmap2
|
|
,wxItemKind vKind
|
|
,wxObject* pClientData
|
|
,const wxString& rsShortHelpString
|
|
,const wxString& rsLongHelpString
|
|
) : wxToolBarToolBase( pTbar
|
|
,vId
|
|
,rsLabel
|
|
,rBitmap1
|
|
,rBitmap2
|
|
,vKind
|
|
,pClientData
|
|
,rsShortHelpString
|
|
,rsLongHelpString
|
|
)
|
|
{
|
|
}
|
|
|
|
inline wxToolBarTool( wxToolBar* pTbar
|
|
,wxControl* pControl
|
|
,const wxString& label
|
|
) : wxToolBarToolBase( pTbar
|
|
,pControl
|
|
,label
|
|
)
|
|
{
|
|
}
|
|
|
|
void SetSize(const wxSize& rSize)
|
|
{
|
|
m_vWidth = rSize.x;
|
|
m_vHeight = rSize.y;
|
|
}
|
|
|
|
wxCoord GetWidth(void) const { return m_vWidth; }
|
|
wxCoord GetHeight(void) const { return m_vHeight; }
|
|
|
|
wxCoord m_vX;
|
|
wxCoord m_vY;
|
|
wxCoord m_vWidth;
|
|
wxCoord m_vHeight;
|
|
}; // end of CLASS wxToolBarTool
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxWin macros
|
|
// ----------------------------------------------------------------------------
|
|
|
|
IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
|
|
|
|
BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
|
|
EVT_SIZE(wxToolBar::OnSize)
|
|
EVT_PAINT(wxToolBar::OnPaint)
|
|
EVT_KILL_FOCUS(wxToolBar::OnKillFocus)
|
|
EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
|
|
EVT_TIMER(-1, wxToolBar::OnTimer)
|
|
END_EVENT_TABLE()
|
|
|
|
// ============================================================================
|
|
// implementation
|
|
// ============================================================================
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// tool bar tools creation
|
|
// ----------------------------------------------------------------------------
|
|
|
|
wxToolBarToolBase* wxToolBar::CreateTool(
|
|
int nId
|
|
, const wxString& rsLabel
|
|
, const wxBitmap& rBmpNormal
|
|
, const wxBitmap& rBmpDisabled
|
|
, wxItemKind eKind
|
|
, wxObject* pClientData
|
|
, const wxString& rsShortHelp
|
|
, const wxString& rsLongHelp
|
|
)
|
|
{
|
|
return new wxToolBarTool( this
|
|
,nId
|
|
,rsLabel
|
|
,rBmpNormal
|
|
,rBmpDisabled
|
|
,eKind
|
|
,pClientData
|
|
,rsShortHelp
|
|
,rsLongHelp
|
|
);
|
|
} // end of wxToolBarSimple::CreateTool
|
|
|
|
wxToolBarToolBase *wxToolBar::CreateTool(
|
|
wxControl* pControl
|
|
, const wxString& label
|
|
)
|
|
{
|
|
return new wxToolBarTool( this
|
|
,pControl
|
|
,label
|
|
);
|
|
} // end of wxToolBarSimple::CreateTool
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxToolBarSimple creation
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void wxToolBar::Init()
|
|
{
|
|
m_nCurrentRowsOrColumns = 0;
|
|
|
|
m_vLastX = m_vLastY = 0;
|
|
m_vMaxWidth = m_vMaxHeight = 0;
|
|
m_nPressedTool = m_nCurrentTool = -1;
|
|
m_vXPos = m_vYPos = -1;
|
|
m_vTextX = m_vTextY = 0;
|
|
|
|
m_toolPacking = 1;
|
|
m_toolSeparation = 5;
|
|
|
|
m_defaultWidth = 16;
|
|
m_defaultHeight = 15;
|
|
|
|
m_pToolTip = NULL;
|
|
} // end of wxToolBar::Init
|
|
|
|
wxToolBarToolBase* wxToolBar::DoAddTool(
|
|
int vId
|
|
, const wxString& rsLabel
|
|
, const wxBitmap& rBitmap
|
|
, const wxBitmap& rBmpDisabled
|
|
, wxItemKind eKind
|
|
, const wxString& rsShortHelp
|
|
, const wxString& rsLongHelp
|
|
, wxObject* pClientData
|
|
, wxCoord vXPos
|
|
, wxCoord vYPos
|
|
)
|
|
{
|
|
//
|
|
// Rememeber the position for DoInsertTool()
|
|
//
|
|
m_vXPos = vXPos;
|
|
m_vYPos = vYPos;
|
|
|
|
return wxToolBarBase::DoAddTool( vId
|
|
,rsLabel
|
|
,rBitmap
|
|
,rBmpDisabled
|
|
,eKind
|
|
,rsShortHelp
|
|
,rsLongHelp
|
|
,pClientData
|
|
,vXPos
|
|
,vYPos
|
|
);
|
|
} // end of wxToolBar::DoAddTool
|
|
|
|
bool wxToolBar::DeleteTool(
|
|
int nId
|
|
)
|
|
{
|
|
bool bOk = wxToolBarBase::DeleteTool(nId);
|
|
|
|
if (bOk)
|
|
{
|
|
Realize();
|
|
}
|
|
return bOk;
|
|
} // end of wxToolBar::DeleteTool
|
|
|
|
bool wxToolBar::DeleteToolByPos(
|
|
size_t nPos
|
|
)
|
|
{
|
|
bool bOk = wxToolBarBase::DeleteToolByPos(nPos);
|
|
|
|
if (bOk)
|
|
{
|
|
Realize();
|
|
}
|
|
return bOk;
|
|
} // end of wxToolBar::DeleteTool
|
|
|
|
wxToolBarToolBase* wxToolBar::InsertControl(
|
|
size_t nPos
|
|
, wxControl* pControl
|
|
)
|
|
{
|
|
wxToolBarToolBase* pTool = wxToolBarBase::InsertControl( nPos
|
|
,pControl
|
|
);
|
|
if (m_bInitialized)
|
|
{
|
|
Realize();
|
|
Refresh();
|
|
}
|
|
return pTool;
|
|
} // end of wxToolBar::InsertControl
|
|
|
|
wxToolBarToolBase* wxToolBar::InsertSeparator(
|
|
size_t nPos
|
|
)
|
|
{
|
|
wxToolBarToolBase* pTool = wxToolBarBase::InsertSeparator(nPos);
|
|
|
|
if (m_bInitialized)
|
|
{
|
|
Realize();
|
|
Refresh();
|
|
}
|
|
return pTool;
|
|
} // end of wxToolBar::InsertSeparator
|
|
|
|
wxToolBarToolBase* wxToolBar::InsertTool(
|
|
size_t nPos
|
|
, int nId
|
|
, const wxString& rsLabel
|
|
, const wxBitmap& rBitmap
|
|
, const wxBitmap& rBmpDisabled
|
|
, wxItemKind eKind
|
|
, const wxString& rsShortHelp
|
|
, const wxString& rsLongHelp
|
|
, wxObject* pClientData
|
|
)
|
|
{
|
|
wxToolBarToolBase* pTool = wxToolBarBase::InsertTool( nPos
|
|
,nId
|
|
,rsLabel
|
|
,rBitmap
|
|
,rBmpDisabled
|
|
,eKind
|
|
,rsShortHelp
|
|
,rsLongHelp
|
|
,pClientData
|
|
);
|
|
if (m_bInitialized)
|
|
{
|
|
Realize();
|
|
Refresh();
|
|
}
|
|
return pTool;
|
|
} // end of wxToolBar::InsertTool
|
|
|
|
bool wxToolBar::DoInsertTool( size_t WXUNUSED(nPos),
|
|
wxToolBarToolBase* pToolBase )
|
|
{
|
|
wxToolBarTool* pTool = (wxToolBarTool *)pToolBase;
|
|
|
|
pTool->m_vX = m_vXPos;
|
|
if (pTool->m_vX == -1)
|
|
pTool->m_vX = m_xMargin;
|
|
|
|
pTool->m_vY = m_vYPos;
|
|
if (pTool->m_vY == -1)
|
|
pTool->m_vX = m_yMargin;
|
|
|
|
pTool->SetSize(GetToolSize());
|
|
|
|
if (pTool->IsButton())
|
|
{
|
|
//
|
|
// Calculate reasonable max size in case Layout() not called
|
|
//
|
|
if ((pTool->m_vX + pTool->GetNormalBitmap().GetWidth() + m_xMargin) > m_vMaxWidth)
|
|
m_vMaxWidth = (wxCoord)((pTool->m_vX + pTool->GetWidth() + m_xMargin));
|
|
|
|
if ((pTool->m_vY + pTool->GetNormalBitmap().GetHeight() + m_yMargin) > m_vMaxHeight)
|
|
m_vMaxHeight = (wxCoord)((pTool->m_vY + pTool->GetHeight() + m_yMargin));
|
|
}
|
|
return true;
|
|
} // end of wxToolBar::DoInsertTool
|
|
|
|
bool wxToolBar::DoDeleteTool( size_t WXUNUSED(nPos),
|
|
wxToolBarToolBase* pTool )
|
|
{
|
|
pTool->Detach();
|
|
Refresh();
|
|
return true;
|
|
} // end of wxToolBar::DoDeleteTool
|
|
|
|
bool wxToolBar::Create( wxWindow* pParent,
|
|
wxWindowID vId,
|
|
const wxPoint& rPos,
|
|
const wxSize& rSize,
|
|
long lStyle,
|
|
const wxString& rsName )
|
|
{
|
|
if ( !wxWindow::Create( pParent
|
|
,vId
|
|
,rPos
|
|
,rSize
|
|
,lStyle
|
|
,rsName
|
|
))
|
|
return false;
|
|
|
|
// Set it to grey (or other 3D face colour)
|
|
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));
|
|
SetFont(*wxSMALL_FONT);
|
|
|
|
if (GetWindowStyleFlag() & (wxTB_LEFT | wxTB_RIGHT))
|
|
{
|
|
m_vLastX = 7;
|
|
m_vLastY = 3;
|
|
|
|
m_maxRows = 32000; // a lot
|
|
m_maxCols = 1;
|
|
}
|
|
else
|
|
{
|
|
m_vLastX = 3;
|
|
m_vLastY = 7;
|
|
|
|
m_maxRows = 1;
|
|
m_maxCols = 32000; // a lot
|
|
}
|
|
SetCursor(*wxSTANDARD_CURSOR);
|
|
|
|
//
|
|
// The toolbar's tools, if they have labels and the winTB_TEXT
|
|
// style is set, then we need to take into account the size of
|
|
// the text when drawing tool bitmaps and the text
|
|
//
|
|
if (HasFlag(wxTB_TEXT))
|
|
{
|
|
wxClientDC vDC(this);
|
|
|
|
vDC.SetFont(GetFont());
|
|
vDC.GetTextExtent( wxT("XXXX")
|
|
,&m_vTextX
|
|
,&m_vTextY
|
|
);
|
|
}
|
|
|
|
//
|
|
// Position it
|
|
//
|
|
int nX = rPos.x;
|
|
int nY = rPos.y;
|
|
int nWidth = rSize.x;
|
|
int nHeight = rSize.y;
|
|
|
|
if (lStyle & (wxTB_TOP | wxTB_BOTTOM))
|
|
{
|
|
if (nWidth <= 0)
|
|
{
|
|
nWidth = pParent->GetClientSize().x;
|
|
}
|
|
if (nHeight <= 0)
|
|
{
|
|
if (lStyle & wxTB_TEXT)
|
|
nHeight = m_defaultHeight + m_vTextY;
|
|
else
|
|
nHeight = m_defaultHeight;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nHeight <= 0)
|
|
{
|
|
nHeight = pParent->GetClientSize().y;
|
|
}
|
|
if (nWidth <= 0)
|
|
{
|
|
if (lStyle & wxTB_TEXT)
|
|
nWidth = m_vTextX + (int)(m_vTextX/2); // a little margin
|
|
else
|
|
nWidth = m_defaultWidth + (int)(m_defaultWidth/2); // a little margin
|
|
}
|
|
}
|
|
if (nX < 0)
|
|
nX = 0;
|
|
if (nY < 0)
|
|
nY = 0;
|
|
|
|
SetSize( nX
|
|
,nY
|
|
,nWidth
|
|
,nHeight
|
|
);
|
|
return true;
|
|
} // end of wxToolBar::Create
|
|
|
|
wxToolBar::~wxToolBar()
|
|
{
|
|
wxDELETE(m_pToolTip);
|
|
} // end of wxToolBar::~wxToolBar
|
|
|
|
bool wxToolBar::Realize()
|
|
{
|
|
int nMaxToolWidth = 0;
|
|
int nMaxToolHeight = 0;
|
|
|
|
m_nCurrentRowsOrColumns = 0;
|
|
m_vLastX = m_xMargin;
|
|
m_vLastY = m_yMargin;
|
|
m_vMaxWidth = 0;
|
|
m_vMaxHeight = 0;
|
|
|
|
|
|
//
|
|
// Find the maximum tool width and height
|
|
//
|
|
wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
|
|
|
|
while (node )
|
|
{
|
|
wxToolBarTool* pTool = (wxToolBarTool *)node->GetData();
|
|
|
|
if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty())
|
|
{
|
|
//
|
|
// Set the height according to the font and the border size
|
|
//
|
|
if (pTool->GetWidth() > m_vTextX)
|
|
nMaxToolWidth = pTool->GetWidth() + 4;
|
|
else
|
|
nMaxToolWidth = m_vTextX;
|
|
if (pTool->GetHeight() + m_vTextY > nMaxToolHeight)
|
|
nMaxToolHeight = pTool->GetHeight() + m_vTextY;
|
|
}
|
|
else
|
|
{
|
|
if (pTool->GetWidth() > nMaxToolWidth )
|
|
nMaxToolWidth = pTool->GetWidth() + 4;
|
|
if (pTool->GetHeight() > nMaxToolHeight)
|
|
nMaxToolHeight = pTool->GetHeight();
|
|
}
|
|
node = node->GetNext();
|
|
}
|
|
|
|
wxCoord vTbWidth = 0L;
|
|
wxCoord vTbHeight = 0L;
|
|
|
|
GetSize( &vTbWidth
|
|
,&vTbHeight
|
|
);
|
|
if (vTbHeight < nMaxToolHeight)
|
|
{
|
|
SetSize( -1L
|
|
,-1L
|
|
,vTbWidth
|
|
,nMaxToolHeight + 4
|
|
);
|
|
if (GetParent()->IsKindOf(CLASSINFO(wxFrame)))
|
|
{
|
|
wxFrame* pFrame = wxDynamicCast(GetParent(), wxFrame);
|
|
|
|
if (pFrame)
|
|
pFrame->PositionToolBar();
|
|
}
|
|
}
|
|
|
|
int nSeparatorSize = m_toolSeparation;
|
|
|
|
node = m_tools.GetFirst();
|
|
while (node)
|
|
{
|
|
wxToolBarTool* pTool = (wxToolBarTool *)node->GetData();
|
|
|
|
if (pTool->IsSeparator())
|
|
{
|
|
if (GetWindowStyleFlag() & (wxTB_TOP | wxTB_BOTTOM))
|
|
{
|
|
pTool->m_vX = m_vLastX + nSeparatorSize;
|
|
pTool->m_vHeight = m_defaultHeight + m_vTextY;
|
|
if (m_nCurrentRowsOrColumns >= m_maxCols)
|
|
m_vLastY += nSeparatorSize;
|
|
else
|
|
m_vLastX += nSeparatorSize * 4;
|
|
}
|
|
else
|
|
{
|
|
pTool->m_vY = m_vLastY + nSeparatorSize;
|
|
pTool->m_vHeight = m_defaultHeight + m_vTextY;
|
|
if (m_nCurrentRowsOrColumns >= m_maxRows)
|
|
m_vLastX += nSeparatorSize;
|
|
else
|
|
m_vLastY += nSeparatorSize * 4;
|
|
}
|
|
}
|
|
else if (pTool->IsButton())
|
|
{
|
|
if (GetWindowStyleFlag() & (wxTB_TOP | wxTB_BOTTOM))
|
|
{
|
|
if (m_nCurrentRowsOrColumns >= m_maxCols)
|
|
{
|
|
m_nCurrentRowsOrColumns = 0;
|
|
m_vLastX = m_xMargin;
|
|
m_vLastY += nMaxToolHeight + m_toolPacking;
|
|
}
|
|
pTool->m_vX = m_vLastX + (nMaxToolWidth - ((int)(nMaxToolWidth/2) + (int)(pTool->GetWidth()/2)));
|
|
if (HasFlag(wxTB_TEXT))
|
|
pTool->m_vY = m_vLastY + nSeparatorSize - 2; // just bit of adjustment
|
|
else
|
|
pTool->m_vY = m_vLastY + (nMaxToolHeight - (int)(pTool->GetHeight()/2));
|
|
m_vLastX += nMaxToolWidth + m_toolPacking + m_toolSeparation;
|
|
}
|
|
else
|
|
{
|
|
if (m_nCurrentRowsOrColumns >= m_maxRows)
|
|
{
|
|
m_nCurrentRowsOrColumns = 0;
|
|
m_vLastX += (nMaxToolWidth + m_toolPacking);
|
|
m_vLastY = m_yMargin;
|
|
}
|
|
pTool->m_vX = m_vLastX + pTool->GetWidth();
|
|
if ( HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty() )
|
|
pTool->m_vY = m_vLastY + (nMaxToolHeight - m_vTextY) + m_toolPacking;
|
|
else
|
|
pTool->m_vY = m_vLastY + (nMaxToolHeight - (int)(pTool->GetHeight()/2));
|
|
m_vLastY += nMaxToolHeight + m_toolPacking + m_toolSeparation;
|
|
}
|
|
m_nCurrentRowsOrColumns++;
|
|
}
|
|
else
|
|
{
|
|
// TODO: support the controls
|
|
}
|
|
|
|
if (m_vLastX > m_maxWidth)
|
|
m_maxWidth = m_vLastX;
|
|
if (m_vLastY > m_maxHeight)
|
|
m_maxHeight = m_vLastY;
|
|
|
|
node = node->GetNext();
|
|
}
|
|
|
|
if (GetWindowStyleFlag() & (wxTB_TOP | wxTB_BOTTOM))
|
|
m_maxWidth += nMaxToolWidth;
|
|
else
|
|
m_maxHeight += nMaxToolHeight;
|
|
|
|
m_maxWidth += m_xMargin;
|
|
m_maxHeight += m_yMargin;
|
|
m_bInitialized = true;
|
|
return true;
|
|
} // end of wxToolBar::Realize
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// event handlers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void wxToolBar::OnPaint (
|
|
wxPaintEvent& WXUNUSED(rEvent)
|
|
)
|
|
{
|
|
wxPaintDC vDc(this);
|
|
|
|
PrepareDC(vDc);
|
|
|
|
static int nCount = 0;
|
|
|
|
//
|
|
// Prevent reentry of OnPaint which would cause wxMemoryDC errors.
|
|
//
|
|
if (nCount > 0)
|
|
return;
|
|
nCount++;
|
|
|
|
wxPMDCImpl *impl = (wxPMDCImpl*) vDc.GetImpl();
|
|
::WinFillRect(impl->GetHPS(), &impl->m_vRclPaint, GetBackgroundColour().GetPixel());
|
|
for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
|
|
node;
|
|
node = node->GetNext() )
|
|
{
|
|
wxToolBarTool* pTool = (wxToolBarTool*)node->GetData();
|
|
|
|
if (pTool->IsButton() )
|
|
DrawTool(vDc, pTool);
|
|
if (pTool->IsSeparator())
|
|
{
|
|
wxColour gray85(85, 85, 85);
|
|
wxPen vDarkGreyPen( gray85, 1, wxSOLID );
|
|
int nX;
|
|
int nY;
|
|
int nHeight = 0;
|
|
int nWidth = 0;
|
|
|
|
vDc.SetPen(vDarkGreyPen);
|
|
if (HasFlag(wxTB_TEXT))
|
|
{
|
|
if (HasFlag(wxTB_TOP) || HasFlag(wxTB_BOTTOM))
|
|
{
|
|
nX = pTool->m_vX;
|
|
nY = pTool->m_vY - (m_vTextY - 6);
|
|
nHeight = (m_vTextY - 2) + pTool->GetHeight();
|
|
}
|
|
else
|
|
{
|
|
nX = pTool->m_vX + m_xMargin + 10;
|
|
nY = pTool->m_vY + m_vTextY + m_toolSeparation;
|
|
nWidth = pTool->GetWidth() > m_vTextX ? pTool->GetWidth() : m_vTextX;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nX = pTool->m_vX;
|
|
nY = pTool->m_vY;
|
|
if (HasFlag(wxTB_TOP) || HasFlag(wxTB_BOTTOM))
|
|
nHeight = pTool->GetHeight() - 2;
|
|
else
|
|
{
|
|
nX += m_xMargin + 10;
|
|
nY += m_yMargin + m_toolSeparation;
|
|
nWidth = pTool->GetWidth();
|
|
}
|
|
}
|
|
vDc.DrawLine(nX, nY, nX + nWidth, nY + nHeight);
|
|
}
|
|
}
|
|
nCount--;
|
|
} // end of wxToolBar::OnPaint
|
|
|
|
void wxToolBar::OnSize (
|
|
wxSizeEvent& WXUNUSED(rEvent)
|
|
)
|
|
{
|
|
#if wxUSE_CONSTRAINTS
|
|
if (GetAutoLayout())
|
|
Layout();
|
|
#endif
|
|
} // end of wxToolBar::OnSize
|
|
|
|
void wxToolBar::OnKillFocus(
|
|
wxFocusEvent& WXUNUSED(rEvent)
|
|
)
|
|
{
|
|
OnMouseEnter(m_nPressedTool = m_nCurrentTool = -1);
|
|
} // end of wxToolBar::OnKillFocus
|
|
|
|
void wxToolBar::OnMouseEvent(
|
|
wxMouseEvent& rEvent
|
|
)
|
|
{
|
|
POINTL vPoint;
|
|
HWND hWnd;
|
|
wxCoord vX;
|
|
wxCoord vY;
|
|
HPOINTER hPtr = ::WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE);
|
|
|
|
::WinSetPointer(HWND_DESKTOP, hPtr);
|
|
::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
|
|
hWnd = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE);
|
|
if (hWnd != (HWND)GetHwnd())
|
|
{
|
|
m_vToolTimer.Stop();
|
|
return;
|
|
}
|
|
|
|
rEvent.GetPosition(&vX, &vY);
|
|
|
|
wxToolBarTool* pTool = (wxToolBarTool *)FindToolForPosition( vX
|
|
,vY
|
|
);
|
|
|
|
if (rEvent.LeftDown())
|
|
{
|
|
CaptureMouse();
|
|
}
|
|
if (rEvent.LeftUp())
|
|
{
|
|
ReleaseMouse();
|
|
}
|
|
|
|
if (!pTool)
|
|
{
|
|
m_vToolTimer.Stop();
|
|
if (m_nCurrentTool > -1)
|
|
{
|
|
if (rEvent.LeftIsDown())
|
|
SpringUpButton(m_nCurrentTool);
|
|
pTool = (wxToolBarTool *)FindById(m_nCurrentTool);
|
|
if (pTool && !pTool->IsToggled())
|
|
{
|
|
RaiseTool( pTool, FALSE );
|
|
}
|
|
m_nCurrentTool = -1;
|
|
OnMouseEnter(-1);
|
|
}
|
|
return;
|
|
}
|
|
if (!rEvent.IsButton())
|
|
{
|
|
if (pTool->GetId() != m_nCurrentTool)
|
|
{
|
|
//
|
|
// If the left button is kept down and moved over buttons,
|
|
// press those buttons.
|
|
//
|
|
if (rEvent.LeftIsDown() && pTool->IsEnabled())
|
|
{
|
|
SpringUpButton(m_nCurrentTool);
|
|
if (pTool->CanBeToggled())
|
|
{
|
|
pTool->Toggle();
|
|
}
|
|
DrawTool(pTool);
|
|
}
|
|
wxToolBarTool* pOldTool = (wxToolBarTool*)FindById(m_nCurrentTool);
|
|
|
|
if (pOldTool && !pTool->IsToggled())
|
|
RaiseTool( pOldTool, FALSE );
|
|
m_nCurrentTool = pTool->GetId();
|
|
OnMouseEnter(m_nCurrentTool);
|
|
if (!pTool->GetShortHelp().empty())
|
|
{
|
|
if (m_pToolTip)
|
|
delete m_pToolTip;
|
|
m_pToolTip = new wxToolTip(pTool->GetShortHelp());
|
|
m_vXMouse = (wxCoord)vPoint.x;
|
|
m_vYMouse = (wxCoord)vPoint.y;
|
|
m_vToolTimer.Start(1000L, TRUE);
|
|
}
|
|
if (!pTool->IsToggled())
|
|
RaiseTool(pTool);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Left button pressed.
|
|
if (rEvent.LeftDown() && pTool->IsEnabled())
|
|
{
|
|
if (pTool->CanBeToggled())
|
|
{
|
|
pTool->Toggle();
|
|
}
|
|
DrawTool(pTool);
|
|
}
|
|
else if (rEvent.RightDown())
|
|
{
|
|
OnRightClick( pTool->GetId()
|
|
,vX
|
|
,vY
|
|
);
|
|
}
|
|
|
|
//
|
|
// Left Button Released. Only this action confirms selection.
|
|
// If the button is enabled and it is not a toggle tool and it is
|
|
// in the pressed state, then raise the button and call OnLeftClick.
|
|
//
|
|
if (rEvent.LeftUp() && pTool->IsEnabled() )
|
|
{
|
|
//
|
|
// Pass the OnLeftClick event to tool
|
|
//
|
|
if (!OnLeftClick( pTool->GetId()
|
|
,pTool->IsToggled()) &&
|
|
pTool->CanBeToggled())
|
|
{
|
|
//
|
|
// If it was a toggle, and OnLeftClick says No Toggle allowed,
|
|
// then change it back
|
|
//
|
|
pTool->Toggle();
|
|
}
|
|
DrawTool(pTool);
|
|
}
|
|
} // end of wxToolBar::OnMouseEvent
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// drawing
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void wxToolBar::DrawTool( wxToolBarToolBase* pTool )
|
|
{
|
|
wxClientDC vDc(this);
|
|
|
|
DrawTool( vDc, pTool );
|
|
} // end of wxToolBar::DrawTool
|
|
|
|
void wxToolBar::DrawTool( wxDC& rDc, wxToolBarToolBase* pToolBase )
|
|
{
|
|
wxToolBarTool* pTool = (wxToolBarTool *)pToolBase;
|
|
wxColour gray85( 85,85,85 );
|
|
wxPen vDarkGreyPen( gray85, 1, wxSOLID );
|
|
wxBitmap vBitmap = pTool->GetNormalBitmap();
|
|
bool bUseMask = false;
|
|
wxMask* pMask = NULL;
|
|
|
|
PrepareDC(rDc);
|
|
|
|
if (!vBitmap.IsOk())
|
|
return;
|
|
if ((pMask = vBitmap.GetMask()) != NULL)
|
|
if (pMask->GetMaskBitmap() != NULLHANDLE)
|
|
bUseMask = true;
|
|
|
|
if (!pTool->IsToggled())
|
|
{
|
|
LowerTool(pTool, FALSE);
|
|
if (!pTool->IsEnabled())
|
|
{
|
|
wxColour vColor(wxT("GREY"));
|
|
|
|
rDc.SetTextForeground(vColor);
|
|
if (!pTool->GetDisabledBitmap().IsOk())
|
|
pTool->SetDisabledBitmap(wxDisableBitmap( vBitmap
|
|
,(long)GetBackgroundColour().GetPixel()
|
|
));
|
|
rDc.DrawBitmap( pTool->GetDisabledBitmap()
|
|
,pTool->m_vX
|
|
,pTool->m_vY
|
|
,bUseMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
rDc.SetTextForeground(*wxBLACK);
|
|
rDc.DrawBitmap( vBitmap
|
|
,pTool->m_vX
|
|
,pTool->m_vY
|
|
,bUseMask
|
|
);
|
|
}
|
|
if (m_windowStyle & wxTB_3DBUTTONS)
|
|
{
|
|
RaiseTool(pTool);
|
|
}
|
|
if ( HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty() )
|
|
{
|
|
wxCoord vX;
|
|
wxCoord vY;
|
|
wxCoord vLeft = pTool->m_vX - (int)(pTool->GetWidth()/2);
|
|
|
|
rDc.SetFont(GetFont());
|
|
rDc.GetTextExtent( pTool->GetLabel()
|
|
,&vX
|
|
,&vY
|
|
);
|
|
if (pTool->GetWidth() > vX) // large tools
|
|
{
|
|
vLeft = pTool->m_vX + (pTool->GetWidth() - vX);
|
|
GetSize(&vX, &vY);
|
|
rDc.DrawText( pTool->GetLabel()
|
|
,vLeft
|
|
,vY - m_vTextY - 1
|
|
);
|
|
}
|
|
else // normal tools
|
|
{
|
|
vLeft += (wxCoord)((m_vTextX - vX)/2);
|
|
rDc.DrawText( pTool->GetLabel()
|
|
,vLeft
|
|
,pTool->m_vY + m_vTextY - 1 // a bit of margin
|
|
);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wxColour vColor(wxT("GREY"));
|
|
|
|
LowerTool(pTool);
|
|
rDc.SetTextForeground(vColor);
|
|
if (!pTool->GetDisabledBitmap().IsOk())
|
|
pTool->SetDisabledBitmap(wxDisableBitmap( vBitmap
|
|
,(long)GetBackgroundColour().GetPixel()
|
|
));
|
|
rDc.DrawBitmap( pTool->GetDisabledBitmap()
|
|
,pTool->m_vX
|
|
,pTool->m_vY
|
|
,bUseMask
|
|
);
|
|
if ( HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty() )
|
|
{
|
|
wxCoord vX;
|
|
wxCoord vY;
|
|
wxCoord vLeft = pTool->m_vX - (int)(pTool->GetWidth()/2);
|
|
|
|
rDc.SetFont(GetFont());
|
|
rDc.GetTextExtent( pTool->GetLabel()
|
|
,&vX
|
|
,&vY
|
|
);
|
|
vLeft += (wxCoord)((m_vTextX - vX)/2);
|
|
rDc.DrawText( pTool->GetLabel()
|
|
,vLeft
|
|
,pTool->m_vY + m_vTextY - 1 // a bit of margin
|
|
);
|
|
}
|
|
}
|
|
} // end of wxToolBar::DrawTool
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// toolbar geometry
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void wxToolBar::SetRows(
|
|
int nRows
|
|
)
|
|
{
|
|
wxCHECK_RET( nRows != 0, wxT("max number of rows must be > 0") );
|
|
|
|
m_maxCols = (GetToolsCount() + nRows - 1) / nRows;
|
|
Refresh();
|
|
} // end of wxToolBar::SetRows
|
|
|
|
wxToolBarToolBase* wxToolBar::FindToolForPosition(
|
|
wxCoord vX
|
|
, wxCoord vY
|
|
) const
|
|
{
|
|
wxCoord vTBarHeight = 0;
|
|
|
|
GetSize( NULL
|
|
,&vTBarHeight
|
|
);
|
|
vY = vTBarHeight - vY;
|
|
wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
|
|
while (node)
|
|
{
|
|
wxToolBarTool* pTool = (wxToolBarTool *)node->GetData();
|
|
|
|
if ( HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty() )
|
|
{
|
|
if ((vX >= (pTool->m_vX - ((wxCoord)(pTool->GetWidth()/2) - 2))) &&
|
|
(vY >= (pTool->m_vY - 2)) &&
|
|
(vX <= (pTool->m_vX + pTool->GetWidth())) &&
|
|
(vY <= (pTool->m_vY + pTool->GetHeight() + m_vTextY + 2)))
|
|
{
|
|
return pTool;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((vX >= pTool->m_vX) &&
|
|
(vY >= pTool->m_vY) &&
|
|
(vX <= (pTool->m_vX + pTool->GetWidth())) &&
|
|
(vY <= (pTool->m_vY + pTool->GetHeight())))
|
|
{
|
|
return pTool;
|
|
}
|
|
}
|
|
node = node->GetNext();
|
|
}
|
|
return NULL;
|
|
} // end of wxToolBar::FindToolForPosition
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// tool state change handlers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void wxToolBar::DoEnableTool(
|
|
wxToolBarToolBase* pTool
|
|
, bool WXUNUSED(bEnable)
|
|
)
|
|
{
|
|
DrawTool(pTool);
|
|
} // end of wxToolBar::DoEnableTool
|
|
|
|
void wxToolBar::DoToggleTool(
|
|
wxToolBarToolBase* pTool
|
|
, bool WXUNUSED(bToggle)
|
|
)
|
|
{
|
|
DrawTool(pTool);
|
|
} // end of wxToolBar::DoToggleTool
|
|
|
|
void wxToolBar::DoSetToggle(
|
|
wxToolBarToolBase* WXUNUSED(pTool)
|
|
, bool WXUNUSED(bToggle)
|
|
)
|
|
{
|
|
// nothing to do
|
|
} // end of wxToolBar::DoSetToggle
|
|
|
|
//
|
|
// Okay, so we've left the tool we're in ... we must check if the tool we're
|
|
// leaving was a 'sprung push button' and if so, spring it back to the up
|
|
// state.
|
|
//
|
|
void wxToolBar::SpringUpButton(
|
|
int vId
|
|
)
|
|
{
|
|
wxToolBarToolBase* pTool = FindById(vId);
|
|
|
|
if (pTool && pTool->CanBeToggled())
|
|
{
|
|
if (pTool->IsToggled())
|
|
pTool->Toggle();
|
|
|
|
DrawTool(pTool);
|
|
}
|
|
} // end of wxToolBar::SpringUpButton
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// private helpers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void wxToolBar::LowerTool ( wxToolBarToolBase* pToolBase,
|
|
bool bLower )
|
|
{
|
|
wxToolBarTool* pTool = (wxToolBarTool*)pToolBase;
|
|
wxCoord vX;
|
|
wxCoord vY;
|
|
wxCoord vWidth;
|
|
wxCoord vHeight;
|
|
wxColour gray85( 85,85,85 );
|
|
wxPen vDarkGreyPen( gray85, 1, wxSOLID );
|
|
wxPen vClearPen( GetBackgroundColour(), 1, wxSOLID );
|
|
wxClientDC vDC(this);
|
|
|
|
if (!pTool)
|
|
return;
|
|
|
|
if (pTool->IsSeparator())
|
|
return;
|
|
|
|
//
|
|
// We only do this for flat toolbars
|
|
//
|
|
if (!HasFlag(wxTB_FLAT))
|
|
return;
|
|
|
|
if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty())
|
|
{
|
|
if (pTool->GetWidth() > m_vTextX)
|
|
{
|
|
vX = pTool->m_vX - 2;
|
|
vWidth = pTool->GetWidth() + 4;
|
|
}
|
|
else
|
|
{
|
|
vX = pTool->m_vX - (wxCoord)(pTool->GetWidth()/2);
|
|
vWidth = m_vTextX + 4;
|
|
}
|
|
vY = pTool->m_vY - 2;
|
|
vHeight = pTool->GetHeight() + m_vTextY + 2;
|
|
}
|
|
else
|
|
{
|
|
vX = pTool->m_vX - 2;
|
|
vY = pTool->m_vY - 2;
|
|
vWidth = pTool->GetWidth() + 4;
|
|
vHeight = pTool->GetHeight() + 4;
|
|
}
|
|
if (bLower)
|
|
{
|
|
vDC.SetPen(*wxWHITE_PEN);
|
|
vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
|
|
vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
|
|
vDC.SetPen(vDarkGreyPen);
|
|
vDC.DrawLine(vX, vY, vX + vWidth, vY);
|
|
vDC.DrawLine(vX, vY + vHeight, vX, vY);
|
|
}
|
|
else
|
|
{
|
|
vDC.SetPen(vClearPen);
|
|
vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
|
|
vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
|
|
vDC.DrawLine(vX, vY, vX + vWidth, vY);
|
|
vDC.DrawLine(vX, vY + vHeight, vX, vY);
|
|
}
|
|
} // end of WinGuiBase_CToolBarTool::LowerTool
|
|
|
|
void wxToolBar::RaiseTool ( wxToolBarToolBase* pToolBase,
|
|
bool bRaise )
|
|
{
|
|
wxToolBarTool* pTool = (wxToolBarTool*)pToolBase;
|
|
wxCoord vX;
|
|
wxCoord vY;
|
|
wxCoord vWidth;
|
|
wxCoord vHeight;
|
|
wxColour gray85( 85,85,85 );
|
|
wxPen vDarkGreyPen( gray85, 1, wxSOLID );
|
|
wxPen vClearPen( GetBackgroundColour(), 1, wxSOLID );
|
|
wxClientDC vDC(this);
|
|
|
|
if (!pTool)
|
|
return;
|
|
|
|
if (pTool->IsSeparator())
|
|
return;
|
|
|
|
if (!pTool->IsEnabled())
|
|
return;
|
|
|
|
//
|
|
// We only do this for flat toolbars
|
|
//
|
|
if (!HasFlag(wxTB_FLAT))
|
|
return;
|
|
|
|
if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty())
|
|
{
|
|
if (pTool->GetWidth() > m_vTextX)
|
|
{
|
|
vX = pTool->m_vX - 2;
|
|
vWidth = pTool->GetWidth() + 4;
|
|
}
|
|
else
|
|
{
|
|
vX = pTool->m_vX - (wxCoord)(pTool->GetWidth()/2);
|
|
vWidth = m_vTextX + 4;
|
|
}
|
|
vY = pTool->m_vY - 2;
|
|
vHeight = pTool->GetHeight() + m_vTextY + 2;
|
|
}
|
|
else
|
|
{
|
|
vX = pTool->m_vX - 2;
|
|
vY = pTool->m_vY - 2;
|
|
vWidth = pTool->GetWidth() + 4;
|
|
vHeight = pTool->GetHeight() + 4;
|
|
}
|
|
if (bRaise)
|
|
{
|
|
vDC.SetPen(vDarkGreyPen);
|
|
vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
|
|
vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
|
|
vDC.SetPen(*wxWHITE_PEN);
|
|
vDC.DrawLine(vX, vY, vX + vWidth, vY);
|
|
vDC.DrawLine(vX, vY + vHeight, vX, vY);
|
|
}
|
|
else
|
|
{
|
|
vDC.SetPen(vClearPen);
|
|
vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
|
|
vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
|
|
vDC.DrawLine(vX, vY, vX + vWidth, vY);
|
|
vDC.DrawLine(vX, vY + vHeight, vX, vY);
|
|
}
|
|
} // end of wxToolBar::RaiseTool
|
|
|
|
void wxToolBar::OnTimer ( wxTimerEvent& rEvent )
|
|
{
|
|
if (rEvent.GetId() == m_vToolTimer.GetId())
|
|
{
|
|
wxPoint vPos( m_vXMouse, m_vYMouse );
|
|
|
|
m_pToolTip->DisplayToolTipWindow(vPos);
|
|
m_vToolTimer.Stop();
|
|
m_vToolExpTimer.Start(4000L, TRUE);
|
|
}
|
|
else if (rEvent.GetId() == m_vToolExpTimer.GetId())
|
|
{
|
|
m_pToolTip->HideToolTipWindow();
|
|
GetParent()->Refresh();
|
|
m_vToolExpTimer.Stop();
|
|
}
|
|
} // end of wxToolBar::OnTimer
|
|
|
|
#endif // ndef for wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE
|