void tpanelnotebook::PostSplitSizeCorrect() {
#if TPANEL_COPIOUS_LOGGING
LogMsgFormat(LOGT::TPANELTRACE, "TCL: tpanelnotebook::PostSplitSizeCorrect(): START");
#endif
wxSize totalsize=GetClientSize();
wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
size_t pane_count = all_panes.GetCount();
size_t tabctrl_count = 0;
std::forward_list<wxAuiPaneInfo *> tabctrlarray;
for (size_t i = 0; i < pane_count; ++i) {
if (all_panes.Item(i).name != wxT("dummy")) {
tabctrl_count++;
tabctrlarray.push_front(&(all_panes.Item(i)));
#if TPANEL_COPIOUS_LOGGING
LogMsgFormat(LOGT::TPANELTRACE, "TCL: PostSplitSizeCorrect1 %d %d %d %d", all_panes.Item(i).dock_direction, all_panes.Item(i).dock_layer,
all_panes.Item(i).dock_row, all_panes.Item(i).dock_pos);
#endif
}
}
for (auto &it : tabctrlarray) {
wxAuiPaneInfo &pane = *it;
pane.BestSize(totalsize.GetWidth() / tabctrl_count, totalsize.GetHeight());
pane.MaxSize(totalsize.GetWidth() / tabctrl_count, totalsize.GetHeight());
pane.DockFixed();
if (pane.dock_direction != wxAUI_DOCK_LEFT && pane.dock_direction != wxAUI_DOCK_RIGHT && pane.dock_direction != wxAUI_DOCK_CENTRE) {
pane.Right();
pane.dock_row = 0;
pane.dock_pos = 1; //trigger code below
}
if (pane.dock_pos > 0) { //make a new row, bumping up any others to make room
if (pane.dock_direction == wxAUI_DOCK_LEFT) {
for (auto &jt : tabctrlarray) {
if (jt->dock_direction == pane.dock_direction && jt->dock_row > pane.dock_row && jt->dock_layer == pane.dock_layer) {
jt->dock_row++;
}
}
pane.dock_pos = 0;
pane.dock_row++;
} else {
for (auto &jt : tabctrlarray) {
if (jt->dock_direction == pane.dock_direction && jt->dock_row >= pane.dock_row &&
jt->dock_layer == pane.dock_layer && jt->dock_pos == 0) {
jt->dock_row++;
}
}
pane.dock_pos = 0;
}
}
}
for (auto &it : tabctrlarray) {
m_mgr.InsertPane(it->window, *it, wxAUI_INSERT_ROW);
}
m_mgr.Update();
for (size_t i = 0; i < pane_count; ++i) {
if (all_panes.Item(i).name != wxT("dummy")) {
#if TPANEL_COPIOUS_LOGGING
LogMsgFormat(LOGT::TPANELTRACE, "TCL: PostSplitSizeCorrect2 %d %d %d %d", all_panes.Item(i).dock_direction, all_panes.Item(i).dock_layer,
all_panes.Item(i).dock_row, all_panes.Item(i).dock_pos);
#endif
}
}
DoSizing();
owner->Refresh();
#if TPANEL_COPIOUS_LOGGING
LogMsgFormat(LOGT::TPANELTRACE, "TCL: tpanelnotebook::PostSplitSizeCorrect(): END");
#endif
}
AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
const wxPoint & pos,
const wxSize & size):
wxFrame(parent,
id,
"Audacity",
pos,
size),
mRate((double) gPrefs->Read("/SamplingRate/DefaultProjectSampleRate",
44100)),
mDirty(false),
mAPalette(NULL),
mDrag(NULL),
mTrackPanel(NULL),
mHistoryWindow(NULL),
mAutoScrolling(false)
{
//
// Create track list
//
mTracks = new TrackList();
mLastSavedTracks = NULL;
//
// Initialize view info (shared with TrackPanel)
//
// Selection
mViewInfo.sel0 = 0.0;
mViewInfo.sel1 = 0.0;
// Horizontal scrollbar
mViewInfo.total = 1.0;
mViewInfo.screen = 1.0;
mViewInfo.h = 0.0;
mViewInfo.zoom = 44100.0 / 512.0;
mViewInfo.lastZoom = mViewInfo.zoom;
// Vertical scrollbar
mViewInfo.vpos = 0;
mViewInfo.scrollStep = 16;
mViewInfo.sbarH = 0;
mViewInfo.sbarScreen = 1;
mViewInfo.sbarTotal = 1;
mMenuBar = NULL;
CreateMenuBar();
int left = 0, top = 0, width, height;
GetClientSize(&width, &height);
//
// Create the Palette (if we're not using a windowed palette)
//
if (!gWindowedPalette) {
int h = GetAPaletteHeight();
int ptop = 0;
#ifdef __WXMSW__
ptop++;
#endif
mAPalette = new APalette(this, 0,
wxPoint(10, ptop), wxSize(width - 10, h));
top += h + 1 + ptop;
height -= h + 1 + ptop;
}
//
// Create the status bar
//
int sh = GetStatusHeight();
mStatus = new AStatus(this, 0,
wxPoint(0, height - sh),
wxSize(width, sh), mRate, this);
height -= sh;
mStatus->SetField("Welcome to Audacity version "
AUDACITY_VERSION_STRING, 0);
//
// Create the TrackPanel and the scrollbars
//
mTrackPanel = new TrackPanel(this, TrackPanelID,
wxPoint(left, top),
wxSize(width - sbarSpaceWidth,
height - sbarSpaceWidth), mTracks,
&mViewInfo, this);
int hoffset = mTrackPanel->GetLeftOffset() - 1;
int voffset = mTrackPanel->GetRulerHeight();
#ifdef __WXMAC__
width++;
height++;
#endif
mHsbar =
new wxScrollBar(this, HSBarID,
wxPoint(hoffset, top + height - sbarSpaceWidth),
wxSize(width - hoffset - sbarSpaceWidth +
sbarExtraLen, sbarControlWidth),
wxSB_HORIZONTAL);
mVsbar =
new wxScrollBar(this, VSBarID,
wxPoint(width - sbarSpaceWidth, top + voffset),
wxSize(sbarControlWidth,
height - sbarSpaceWidth - voffset +
sbarExtraLen), wxSB_VERTICAL);
InitialState();
FixScrollbars();
//
// Set the Icon
//
// loads either the XPM or the windows resource, depending on the platform
#ifndef __WXMAC__
wxIcon ic(wxICON(AudacityLogo));
SetIcon(ic);
#endif
// Min size, max size
SetSizeHints(250, 200, 20000, 20000);
// Create tags object
mTags = new Tags();
#ifdef __WXMSW__
// Accept drag 'n' drop files
DragAcceptFiles(true);
#endif
gAudacityProjects.Add(this);
}
void GLAnimationCanvas::OnMouse(wxMouseEvent& event)
{
if (m_iType == TYPE_CURVE)
{
wxPoint wxpt = event.GetPosition();
Spline::Point pt(wxpt.x, wxpt.y);
if (event.ButtonDown(wxMOUSE_BTN_LEFT))
{
size_t index;
if(m_spline->findKont(pt, index))
{
m_selectedIndex = index;
}
else
{
m_selectedIndex = -1;
}
}
else if(event.ButtonDown(wxMOUSE_BTN_RIGHT))
{
size_t index;
if(m_spline->findKont(pt, index))
{
m_spline->removeKnot(index);
m_selectedIndex = -1;
}
else
{
m_selectedIndex = m_spline->addKnots(pt);
}
}
else if (event.Dragging())
{
if(m_selectedIndex >= 0)
{
m_spline->setKnot(m_selectedIndex, pt);
}
}
}
else if (m_iType == TYPE_ANIMATION)
{
if(event.ButtonDown(wxMOUSE_BTN_RIGHT))
{
ShowCursor(false);
SetFocus();
if (!HasCapture())
{
CaptureMouse();
}
m_bRightDown = true;
}
else if(event.ButtonUp(wxMOUSE_BTN_RIGHT))
{
ShowCursor(true);
if (HasCapture())
{
ReleaseMouse();
}
ResetKeyStates();
m_bRightDown = false;
}
else if(event.ButtonDown(wxMOUSE_BTN_LEFT))
{
ShowCursor(false);
SetFocus();
if (!HasCapture())
{
CaptureMouse();
}
m_bLeftDown = true;
}
else if(event.ButtonUp(wxMOUSE_BTN_LEFT))
{
ShowCursor(true);
if (!HasCapture())
{
CaptureMouse();
}
ResetKeyStates();
m_bLeftDown = false;
}
else if(event.Dragging())
{
wxPoint curPos = event.GetPosition();
wxPoint pnt = ClientToScreen(curPos);
SetCursorPos(pnt.x, pnt.y);
CRenderManager* pRenderMgr = CRenderManager::GetInstance();
if (m_bRightDown)
{
int nDeltaX = curPos.x - m_lastPosition.x;
int nDeltaY = curPos.y - m_lastPosition.y;
wxSize clientSize = GetClientSize();
pRenderMgr->GetCamera()->Yaw((float)nDeltaX / clientSize.x);
pRenderMgr->GetCamera()->Pitch((float)nDeltaY / clientSize.y);
}
}
else if(event.GetWheelAxis() == wxMOUSE_WHEEL_VERTICAL)
{
kmVec3 vec3Speed;
kmVec3Fill(&vec3Speed, SHIFTWHEELSPEED, SHIFTWHEELSPEED, SHIFTWHEELSPEED);
if (event.GetWheelRotation() > 0)
{
CRenderManager::GetInstance()->GetCamera()->Update(vec3Speed, (1 << CCamera::eCMT_STRAIGHT));
}
else if (event.GetWheelRotation() < 0)
{
kmVec3Scale(&vec3Speed, &vec3Speed, -1.0f);
CRenderManager::GetInstance()->GetCamera()->Update(vec3Speed, (1 << CCamera::eCMT_STRAIGHT));
}
}
m_lastPosition = event.GetPosition();
}
}
void DashboardInstrument_Dial::DrawData(wxGCDC* dc, double value,
wxString unit, wxString format, DialPositionOption position)
{
if (position == DIAL_POSITION_NONE)
return;
dc->SetFont(*g_pFontLabel);
wxColour cl;
GetGlobalColor(_T("DASHF"), &cl);
dc->SetTextForeground(cl);
wxSize size = GetClientSize();
wxString text;
if(!wxIsNaN(value))
{
if (unit == _T("\u00B0"))
text = wxString::Format(format, value)+DEGREE_SIGN;
else if (unit == _T("\u00B0L")) // No special display for now, might be XX°< (as in text-only instrument)
text = wxString::Format(format, value)+DEGREE_SIGN;
else if (unit == _T("\u00B0R")) // No special display for now, might be >XX°
text = wxString::Format(format, value)+DEGREE_SIGN;
else if (unit == _T("\u00B0T"))
text = wxString::Format(format, value)+DEGREE_SIGN+_T("T");
else if (unit == _T("\u00B0M"))
text = wxString::Format(format, value)+DEGREE_SIGN+_T("M");
else if (unit == _T("N")) // Knots
text = wxString::Format(format, value)+_T(" Kts");
else
text = wxString::Format(format, value)+_T(" ")+unit;
}
else
text = _T("---");
int width, height;
dc->GetMultiLineTextExtent(text, &width, &height, NULL, g_pFontLabel);
wxRect TextPoint;
TextPoint.width = width;
TextPoint.height = height;
switch (position)
{
case DIAL_POSITION_NONE:
// This case was already handled before, it's here just
// to avoid compiler warning.
return;
case DIAL_POSITION_INSIDE:
{
TextPoint.x = m_cx - (width / 2) - 1;
TextPoint.y = (size.y * .75) - height;
GetGlobalColor(_T("DASHL"), &cl);
int penwidth = size.x / 100;
wxPen* pen = wxThePenList->FindOrCreatePen( cl, penwidth, wxPENSTYLE_SOLID );
dc->SetPen( *pen );
GetGlobalColor(_T("DASHB"), &cl);
dc->SetBrush(cl);
// There might be a background drawn below
// so we must clear it first.
dc->DrawRoundedRectangle(TextPoint.x-2, TextPoint.y-2, width+4, height+4, 3);
break;
}
case DIAL_POSITION_TOPLEFT:
TextPoint.x = 0;
TextPoint.y = m_TitleHeight;
break;
case DIAL_POSITION_TOPRIGHT:
TextPoint.x = size.x-width-1;
TextPoint.y = m_TitleHeight;
break;
case DIAL_POSITION_BOTTOMLEFT:
TextPoint.x = 0;
TextPoint.y = size.y-height;
break;
case DIAL_POSITION_BOTTOMRIGHT:
TextPoint.x = size.x-width-1;
TextPoint.y = size.x-height;
break;
}
wxColour c2;
GetGlobalColor( _T("DASHB"), &c2 );
wxColour c3;
GetGlobalColor( _T("DASHF"), &c3 );
wxStringTokenizer tkz( text, _T("\n") );
wxString token;
token = tkz.GetNextToken();
while(token.Length()) {
dc->GetTextExtent(token, &width, &height, NULL, NULL, g_pFontLabel);
#ifdef __WXMSW__
if( g_pFontLabel->GetPointSize() <= 12 ) {
wxBitmap tbm( width, height, -1 );
wxMemoryDC tdc( tbm );
tdc.SetBackground( c2 );
tdc.Clear();
tdc.SetFont(*g_pFontLabel );
tdc.SetTextForeground( c3 );
tdc.DrawText(token, 0, 0 );
tdc.SelectObject( wxNullBitmap );
dc->DrawBitmap(tbm, TextPoint.x, TextPoint.y, false);
}
else
#endif
dc->DrawText(token, TextPoint.x, TextPoint.y );
TextPoint.y += height;
token = tkz.GetNextToken();
}
}
// Position and size subwindows.
// Note that the border size applies to each subwindow, not
// including the edges next to the sash.
void wxSplitterWindow::SizeWindows()
{
// check if we have delayed setting the real sash position
if ( m_requestedSashPosition != INT_MAX )
{
int newSashPosition = ConvertSashPosition(m_requestedSashPosition);
if ( newSashPosition != m_sashPosition )
{
DoSetSashPosition(newSashPosition);
}
if ( newSashPosition <= m_sashPosition
&& newSashPosition >= m_sashPosition - GetBorderSize() )
{
// don't update it any more
m_requestedSashPosition = INT_MAX;
}
}
int w, h;
GetClientSize(&w, &h);
if ( GetWindow1() && !GetWindow2() )
{
GetWindow1()->SetSize(GetBorderSize(), GetBorderSize(),
w - 2*GetBorderSize(), h - 2*GetBorderSize());
}
else if ( GetWindow1() && GetWindow2() )
{
const int border = GetBorderSize(),
sash = GetSashSize();
int size1 = GetSashPosition() - border,
size2 = GetSashPosition() + sash;
int x2, y2, w1, h1, w2, h2;
if ( GetSplitMode() == wxSPLIT_VERTICAL )
{
w1 = size1;
w2 = w - 2*border - sash - w1;
if (w2 < 0)
w2 = 0;
h2 = h - 2*border;
if (h2 < 0)
h2 = 0;
h1 = h2;
x2 = size2;
y2 = border;
}
else // horz splitter
{
w2 = w - 2*border;
if (w2 < 0)
w2 = 0;
w1 = w2;
h1 = size1;
h2 = h - 2*border - sash - h1;
if (h2 < 0)
h2 = 0;
x2 = border;
y2 = size2;
}
GetWindow2()->SetSize(x2, y2, w2, h2);
GetWindow1()->SetSize(border, border, w1, h1);
}
wxClientDC dc(this);
DrawSash(dc);
}
// Position and size subwindows.
// Note that the border size applies to each subwindow, not
// including the edges next to the sash.
void wxSashWindow::SizeWindows()
{
int cw, ch;
GetClientSize(&cw, &ch);
if (GetChildren().GetCount() == 1)
{
wxWindow* child = GetChildren().GetFirst()->GetData();
int x = 0;
int y = 0;
int width = cw;
int height = ch;
// Top
if (m_sashes[0].m_show)
{
y = m_borderSize;
height -= m_borderSize;
}
y += m_extraBorderSize;
// Left
if (m_sashes[3].m_show)
{
x = m_borderSize;
width -= m_borderSize;
}
x += m_extraBorderSize;
// Right
if (m_sashes[1].m_show)
{
width -= m_borderSize;
}
width -= 2*m_extraBorderSize;
// Bottom
if (m_sashes[2].m_show)
{
height -= m_borderSize;
}
height -= 2*m_extraBorderSize;
child->SetSize(x, y, width, height);
}
else if (GetChildren().GetCount() > 1)
{
// Perhaps multiple children are themselves sash windows.
// TODO: this doesn't really work because the subwindows sizes/positions
// must be set to leave a gap for the parent's sash (hit-test and decorations).
// Perhaps we can allow for this within LayoutWindow, testing whether the parent
// is a sash window, and if so, allowing some space for the edges.
wxLayoutAlgorithm layout;
layout.LayoutWindow(this);
}
wxClientDC dc(this);
DrawBorders(dc);
DrawSashes(dc);
}
void
GraphCanvas::Center(int x, int y)
{
wxSize size = GetClientSize();
Scroll(x * m_Zoom - size.GetWidth() / 2, y * m_Zoom - size.GetHeight() / 2);
}
void LineChart::OnPaint(wxPaintEvent &event){
wxPaintDC old_dc(this);
float zoomFactor = (float)_zoomPercentage / 100;
int w,h ;
GetClientSize(&w,&h);
if (w != _currentWidth || h != _currentHeight){
delete (_memBitmap);
_currentWidth = w;
_currentHeight = h;
_memBitmap = new wxBitmap(_currentWidth, _currentHeight);
}
/////////////////
// Create a memory DC
wxMemoryDC dc;
dc.SelectObject(*_memBitmap);
wxColor backColor = GetBackgroundColour();
dc.SetBackground(*wxTheBrushList->FindOrCreateBrush(backColor,wxSOLID));
dc.SetBrush(*wxTheBrushList->FindOrCreateBrush(backColor,wxSOLID));
dc.Clear();
DrawGrid(dc);
if (m_showScale){
m_leftEdge = DrawScale(dc);
}
else{
m_leftEdge = 0;
}
size_t largestBufferSize = GetMaxSeriesBufferSize();
double lastValue = 0;
for (SeriesMap::iterator it = m_seriesMap.begin(); it != m_seriesMap.end(); ++it){
float currentX = (float)m_leftEdge;
int lastX = (int)currentX;
int lastY;
Series *series = it->second;
dc.SetPen(*wxThePenList->FindOrCreatePen(series->GetColor(), 1, wxSOLID));
size_t bufSize = series->GetBufferSize();
Range *range = m_rangeArray[series->GetRangeId()];
if (bufSize > 0){
double minValue = range->GetMin();
double maxValue = range->GetMax();
double loggedValue = series->GetValueAt(0);
double percentageOfMax = (loggedValue - minValue) / (maxValue - minValue);
lastY = h - (int)(((double)h) * percentageOfMax);
size_t i = (size_t)(((double)largestBufferSize) * m_viewOffsetFactor);
while (i < bufSize && currentX < _currentWidth ){
if (i == m_markerIndex){
wxPen pen = dc.GetPen();
dc.SetPen(*wxThePenList->FindOrCreatePen(*wxLIGHT_GREY, 1, wxSOLID));
dc.DrawLine(currentX, 0, currentX, _currentHeight);
DrawCurrentValues(dc, i, currentX, CURRENT_VALUES_TOP_OFFSET);
dc.SetPen(pen);
}
loggedValue = series->GetValueAt(i);
if (DatalogValue::NULL_VALUE == loggedValue){
loggedValue = lastValue;
}
else{
lastValue = loggedValue;
}
double percentageOfMax = (loggedValue - minValue) / (maxValue - minValue);
int y = h - (int)(((double)h) * percentageOfMax);
dc.DrawLine(lastX, lastY, (int)currentX, y);
lastX = (int)currentX;
lastY = y;
currentX += zoomFactor;
i++;
}
}
}
if (m_showData) DrawMouseoverMarker(dc);
//blit into the real DC
old_dc.Blit(0,0,_currentWidth,_currentHeight,&dc,0,0);
}
void GCDCGraphs::DrawYAxisVals(wxGraphicsContext& dc) {
Draw* draw = m_draws_wdg->GetSelectedDraw();
if (draw == NULL)
return;
DrawInfo *di = draw->GetDrawInfo();
if (!di->IsValid())
return;
double min = di->GetMin();
double max = di->GetMax();
if( max <= min ) {
// FIXME: Draw3 should atomaticly detect axes in that case, but
// it currently doesnt :(
wxLogWarning(_T("Parameter %s has invalid min/max values: min %f, max %f. Min is set to 0, and max to 100."), di->GetName().c_str(), min, max);
min = 0;
max = 100;
}
//procedure for calculating distance between marks stolen from SzarpDraw2
double x = max - min;
double step;
int i = 0;
if (x < 1)
for (;x < 1; x *=10, --i);
else
for (;(int)x / 10; x /=10, ++i);
if (x <= 1.5)
step = .1;
else if (x <= 3.)
step = .2;
else if (x <= 7.5)
step = .5;
else
step = 1.;
double acc = 1;
int prec = di->GetPrec();
for (int p = prec; p > 0; --p)
acc /= 10;
double factor = (i > 0) ? 10 : .1;
for (;i; i -= i / abs(i))
step *= factor;
if (step < acc)
step = acc;
dc.SetPen(wxPen(*wxWHITE, 1, wxSOLID));
int w, h;
GetClientSize(&w, &h);
h -= m_screen_margins.bottommargin + m_screen_margins.topmargin;
for (double val = max; (min - val) < acc; val -= step) {
int y = GetY(val, di);
dc.StrokeLine(m_screen_margins.leftmargin - 8, y, m_screen_margins.leftmargin, y);
wxString sval = di->GetValueStr(val, _T("- -"));
double textw, texth, textd, textel;
dc.GetTextExtent(sval, &textw, &texth, &textd, &textel);
dc.DrawText(sval, m_screen_margins.leftmargin - textw - 1, y + 2);
}
}
void wxSTEditorFrame::CreateOptions( const wxSTEditorOptions& options )
{
m_options = options;
wxConfigBase *config = GetConfigBase();
wxSTEditorMenuManager *steMM = GetOptions().GetMenuManager();
if (steMM && GetOptions().HasFrameOption(STF_CREATE_MENUBAR))
{
wxMenuBar *menuBar = GetMenuBar();
if (!menuBar)
menuBar = new wxMenuBar(wxMB_DOCKABLE);
steMM->CreateMenuBar(menuBar, true);
SetMenuBar(menuBar);
wxAcceleratorHelper::SetAcceleratorTable(this, *steMM->GetAcceleratorArray());
wxAcceleratorHelper::SetAccelText(menuBar, *steMM->GetAcceleratorArray());
if (GetOptions().HasFrameOption(STF_CREATE_FILEHISTORY) && !GetOptions().GetFileHistory())
{
// If there is wxID_OPEN then we can use wxFileHistory to save them
wxMenu* menu = NULL;
wxMenuItem* item = menuBar->FindItem(wxID_OPEN, &menu);
if (menu && item)
{
int open_index = menu->GetMenuItems().IndexOf(item);
if (open_index != wxNOT_FOUND)
{
wxMenu* submenu = new wxMenu();
menu->Insert(open_index + 1, wxID_ANY, _("Open &Recent"), submenu);
GetOptions().SetFileHistory(new wxFileHistory(9), false);
GetOptions().GetFileHistory()->UseMenu(submenu);
if (config)
{
GetOptions().LoadFileConfig(*config);
}
}
}
GetOptions().SetMenuBar(menuBar);
}
}
if (steMM && GetOptions().HasFrameOption(STF_CREATE_TOOLBAR))
{
wxToolBar* toolBar = (GetToolBar() != NULL) ? GetToolBar() : CreateToolBar();
steMM->CreateToolBar(toolBar);
GetOptions().SetToolBar(toolBar);
}
if ((GetStatusBar() == NULL) && GetOptions().HasFrameOption(STF_CREATE_STATUSBAR))
{
CreateStatusBar(1);
GetOptions().SetStatusBar(GetStatusBar());
}
if (steMM)
{
if (GetOptions().HasEditorOption(STE_CREATE_POPUPMENU))
{
wxMenu* menu = steMM->CreateEditorPopupMenu();
wxAcceleratorHelper::SetAccelText(menu, *steMM->GetAcceleratorArray());
GetOptions().SetEditorPopupMenu(menu, false);
}
if (GetOptions().HasSplitterOption(STS_CREATE_POPUPMENU))
GetOptions().SetSplitterPopupMenu(steMM->CreateSplitterPopupMenu(), false);
if (GetOptions().HasNotebookOption(STN_CREATE_POPUPMENU))
GetOptions().SetNotebookPopupMenu(steMM->CreateNotebookPopupMenu(), false);
}
if (!m_sideSplitter && GetOptions().HasFrameOption(STF_CREATE_SIDEBAR))
{
m_sideSplitter = new wxSplitterWindow(this, ID_STF_SIDE_SPLITTER);
m_sideSplitter->SetMinimumPaneSize(10);
m_sideNotebook = new wxNotebook(m_sideSplitter, ID_STF_SIDE_NOTEBOOK);
m_steTreeCtrl = new wxSTEditorTreeCtrl(m_sideNotebook, ID_STF_FILE_TREECTRL);
m_dirCtrl = new wxGenericDirCtrl(m_sideNotebook, ID_STF_FILE_DIRCTRL,
wxFileName::GetCwd(),
wxDefaultPosition, wxDefaultSize,
wxDIRCTRL_3D_INTERNAL
#if wxCHECK_VERSION(2, 9, 2)
|(GetOptions().HasFrameOption(STF_CREATE_NOTEBOOK) ? wxDIRCTRL_MULTIPLE : 0)
#endif // wxCHECK_VERSION(2, 9, 2)
);
m_sideNotebook->AddPage(m_steTreeCtrl, _("Files"));
m_sideNotebook->AddPage(m_dirCtrl, _("Open"));
m_sideSplitterWin1 = m_sideNotebook;
}
if (!m_steNotebook && GetOptions().HasFrameOption(STF_CREATE_NOTEBOOK))
{
m_mainSplitter = new wxSplitterWindow(m_sideSplitter ? (wxWindow*)m_sideSplitter : (wxWindow*)this, ID_STF_MAIN_SPLITTER);
m_mainSplitter->SetMinimumPaneSize(1);
m_steNotebook = new wxSTEditorNotebook(m_mainSplitter, wxID_ANY, wxDefaultPosition, wxDefaultSize,
wxCLIP_CHILDREN);
m_steNotebook->CreateOptions(m_options);
(void)m_steNotebook->InsertEditorSplitter(-1, wxID_ANY, GetOptions().GetDefaultFileName(), true);
// update after adding a single page
m_steNotebook->UpdateAllItems();
m_mainSplitter->Initialize(m_steNotebook);
m_mainSplitterWin1 = m_steNotebook;
m_sideSplitterWin2 = m_mainSplitter;
if (m_steTreeCtrl)
m_steTreeCtrl->SetSTENotebook(m_steNotebook);
}
else if (!m_steSplitter && GetOptions().HasFrameOption(STF_CREATE_SINGLEPAGE))
{
m_mainSplitter = new wxSplitterWindow(m_sideSplitter ? (wxWindow*)m_sideSplitter : (wxWindow*)this, ID_STF_MAIN_SPLITTER);
m_mainSplitter->SetMinimumPaneSize(1);
m_steSplitter = new wxSTEditorSplitter(m_mainSplitter, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0);
m_steSplitter->CreateOptions(m_options);
m_mainSplitter->Initialize(m_steSplitter);
m_mainSplitterWin1 = m_steSplitter;
}
//else user will set up the rest
if (m_mainSplitter && m_mainSplitterWin1 && !m_resultsNotebook && GetOptions().HasFrameOption(STF_CREATE_RESULT_NOTEBOOK))
{
m_resultsNotebook = new wxNotebook(m_mainSplitter, wxID_ANY);
m_findResultsEditor = new wxSTEditorFindResultsEditor(m_resultsNotebook, wxID_ANY);
m_findResultsEditor->CreateOptionsFromEditorOptions(options);
m_resultsNotebook->AddPage(m_findResultsEditor, _("Search Results"));
wxSTEditorFindReplacePanel::SetFindResultsEditor(m_findResultsEditor);
m_mainSplitter->SplitHorizontally(m_mainSplitterWin1, m_resultsNotebook, GetClientSize().GetHeight()*2/3);
m_mainSplitterWin2 = m_resultsNotebook;
}
if (GetOptions().HasFrameOption(STF_CREATE_SIDEBAR) && GetSideSplitter() && m_sideSplitterWin1 && m_sideSplitterWin2)
{
GetSideSplitter()->SplitVertically(m_sideSplitterWin1, m_sideSplitterWin2, m_sideSplitter_pos);
}
#if wxUSE_DRAG_AND_DROP
if (GetOptions().HasFrameOption(STF_DO_DRAG_AND_DROP))
{
SetDropTarget(new wxSTEditorFileDropTarget(this));
}
#endif //wxUSE_DRAG_AND_DROP
if (GetOptions().HasConfigOption(STE_CONFIG_FINDREPLACE) && config)
{
if (GetOptions().GetFindReplaceData() &&
!GetOptions().GetFindReplaceData()->HasLoadedConfig())
GetOptions().GetFindReplaceData()->LoadConfig(*config);
}
if (config)
LoadConfig(*config);
// The config may change the frame size so relayout the splitters
if (m_mainSplitter && m_mainSplitter->IsSplit()) //m_mainSplitterWin1 && m_resultsNotebook)
m_mainSplitter->SetSashPosition(GetClientSize().GetHeight()*2/3);
UpdateAllItems();
// if we've got an editor let it update gui
wxSTEditor *editor = GetEditor();
if (editor)
editor->UpdateAllItems();
}
HK_PROMPT_DIALOG( wxWindow* aParent, wxWindowID aId, const wxString& aTitle,
const wxString& aName, const wxString& aCurrentKey )
: DIALOG_SHIM( aParent, aId, aTitle, wxDefaultPosition, wxDefaultSize )
{
wxPanel* panel = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize );
wxBoxSizer* sizer = new wxBoxSizer( wxVERTICAL );
/* Dialog layout:
*
* inst_label........................
* ----------------------------------
*
* cmd_label_0 cmd_label_1 \
* | fgsizer
* key_label_0 key_label_1 /
*/
wxStaticText* inst_label = new wxStaticText( panel, wxID_ANY, wxEmptyString,
wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE_HORIZONTAL );
inst_label->SetLabelText( _( "Press a new hotkey, or press Esc to cancel..." ) );
sizer->Add( inst_label, 0, wxALL, 5 );
sizer->Add( new wxStaticLine( panel ), 0, wxALL | wxEXPAND, 2 );
wxFlexGridSizer* fgsizer = new wxFlexGridSizer( 2 );
wxStaticText* cmd_label_0 = new wxStaticText( panel, wxID_ANY, _( "Command:" ) );
fgsizer->Add( cmd_label_0, 0, wxALL | wxALIGN_CENTRE_VERTICAL, 5 );
wxStaticText* cmd_label_1 = new wxStaticText( panel, wxID_ANY, wxEmptyString );
cmd_label_1->SetFont( cmd_label_1->GetFont().Bold() );
cmd_label_1->SetLabel( aName );
fgsizer->Add( cmd_label_1, 0, wxALL | wxALIGN_CENTRE_VERTICAL, 5 );
wxStaticText* key_label_0 = new wxStaticText( panel, wxID_ANY, _( "Current key:" ) );
fgsizer->Add( key_label_0, 0, wxALL | wxALIGN_CENTRE_VERTICAL, 5 );
wxStaticText* key_label_1 = new wxStaticText( panel, wxID_ANY, wxEmptyString );
key_label_1->SetFont( key_label_1->GetFont().Bold() );
key_label_1->SetLabel( aCurrentKey );
fgsizer->Add( key_label_1, 0, wxALL | wxALIGN_CENTRE_VERTICAL, 5 );
sizer->Add( fgsizer, 1, wxEXPAND );
// Wrap the sizer in a second to give a larger border around the whole dialog
wxBoxSizer* outer_sizer = new wxBoxSizer( wxVERTICAL );
outer_sizer->Add( sizer, 0, wxALL | wxEXPAND, 10 );
panel->SetSizer( outer_sizer );
Layout();
outer_sizer->Fit( this );
Center();
SetMinClientSize( GetClientSize() );
// Binding both EVT_CHAR and EVT_CHAR_HOOK ensures that all key events,
// including specials like Tab and Return, are received, particularly
// on MSW.
panel->Bind( wxEVT_CHAR, &HK_PROMPT_DIALOG::OnChar, this );
panel->Bind( wxEVT_CHAR_HOOK, &HK_PROMPT_DIALOG::OnCharHook, this );
}
void wxWindow::Refresh(bool eraseBackground, const wxRect *rect)
{
wxRect rectClient; // the same rectangle in client coordinates
wxPoint origin = GetClientAreaOrigin();
wxSize size = GetClientSize();
if ( rect )
{
// the rectangle passed as argument is in client coordinates
rectClient = *rect;
// don't refresh anything beyond the client area (scrollbars for
// example)
if ( rectClient.GetRight() > size.x )
rectClient.SetRight(size.x);
if ( rectClient.GetBottom() > size.y )
rectClient.SetBottom(size.y);
}
else // refresh the entire client area
{
// x,y is already set to 0 by default
rectClient.SetSize(size);
}
// convert refresh rectangle to window coordinates:
wxRect rectWin(rectClient);
rectWin.Offset(origin);
// debugging helper
#ifdef WXDEBUG_REFRESH
static bool s_refreshDebug = false;
if ( s_refreshDebug )
{
wxWindowDC dc(this);
dc.SetBrush(*wxCYAN_BRUSH);
dc.SetPen(*wxTRANSPARENT_PEN);
dc.DrawRectangle(rectWin);
// under Unix we use "--sync" X option for this
#if defined(__WXMSW__) && !defined(__WXMICROWIN__)
::GdiFlush();
::Sleep(200);
#endif // __WXMSW__
}
#endif // WXDEBUG_REFRESH
wxWindowNative::Refresh(eraseBackground, &rectWin);
// Refresh all sub controls if any.
wxWindowList& children = GetChildren();
for ( wxWindowList::iterator i = children.begin(); i != children.end(); ++i )
{
wxWindow *child = *i;
// only refresh subcontrols if they are visible:
if ( child->IsTopLevel() || !child->IsShown() || child->IsFrozen() )
continue;
// ...and when the subcontrols are in the update region:
wxRect childrect(child->GetRect());
childrect.Intersect(rectClient);
if ( childrect.IsEmpty() )
continue;
// refresh the subcontrol now:
childrect.Offset(-child->GetPosition());
// NB: We must call wxWindowNative version because we need to refresh
// the entire control, not just its client area, and this is why we
// don't account for child client area origin here neither. Also
// note that we don't pass eraseBackground to the child, but use
// true instead: this is because we can't be sure that
// eraseBackground=false is safe for children as well and not only
// for the parent.
child->wxWindowNative::Refresh(eraseBackground, &childrect);
}
}
wxRect wxWindow::ScrollNoRefresh(int dx, int dy, const wxRect *rectTotal)
{
wxASSERT_MSG( !dx || !dy, _T("can't be used for diag scrolling") );
// the rect to refresh (which we will calculate)
wxRect rect;
if ( !dx && !dy )
{
// nothing to do
return rect;
}
// calculate the part of the window which we can just redraw in the new
// location
wxSize sizeTotal = rectTotal ? rectTotal->GetSize() : GetClientSize();
wxLogTrace(_T("scroll"), _T("rect is %dx%d, scroll by %d, %d"),
sizeTotal.x, sizeTotal.y, dx, dy);
// the initial and end point of the region we move in client coords
wxPoint ptSource, ptDest;
if ( rectTotal )
{
ptSource = rectTotal->GetPosition();
ptDest = rectTotal->GetPosition();
}
// the size of this region
wxSize size;
size.x = sizeTotal.x - abs(dx);
size.y = sizeTotal.y - abs(dy);
if ( size.x <= 0 || size.y <= 0 )
{
// just redraw everything as nothing of the displayed image will stay
wxLogTrace(_T("scroll"), _T("refreshing everything"));
rect = rectTotal ? *rectTotal : wxRect(0, 0, sizeTotal.x, sizeTotal.y);
}
else // move the part which doesn't change to the new location
{
// note that when we scroll the canvas in some direction we move the
// block which doesn't need to be refreshed in the opposite direction
if ( dx < 0 )
{
// scroll to the right, move to the left
ptSource.x -= dx;
}
else
{
// scroll to the left, move to the right
ptDest.x += dx;
}
if ( dy < 0 )
{
// scroll down, move up
ptSource.y -= dy;
}
else
{
// scroll up, move down
ptDest.y += dy;
}
#if wxUSE_CARET
// we need to hide the caret before moving or it will erase itself at
// the wrong (old) location
wxCaret *caret = GetCaret();
if ( caret )
caret->Hide();
#endif // wxUSE_CARET
// do move
wxClientDC dc(this);
wxBitmap bmp(size.x, size.y);
wxMemoryDC dcMem;
dcMem.SelectObject(bmp);
dcMem.Blit(wxPoint(0,0), size, &dc, ptSource
#if defined(__WXGTK__) && !defined(wxHAS_WORKING_GTK_DC_BLIT)
+ GetClientAreaOrigin()
#endif // broken wxGTK wxDC::Blit
);
dc.Blit(ptDest, size, &dcMem, wxPoint(0,0));
wxLogTrace(_T("scroll"),
_T("Blit: (%d, %d) of size %dx%d -> (%d, %d)"),
ptSource.x, ptSource.y,
size.x, size.y,
ptDest.x, ptDest.y);
// and now repaint the uncovered area
// FIXME: We repaint the intersection of these rectangles twice - is
// it bad? I don't think so as it is rare to scroll the window
// diagonally anyhow and so adding extra logic to compute
// rectangle intersection is probably not worth the effort
rect.x = ptSource.x;
rect.y = ptSource.y;
if ( dx )
{
if ( dx < 0 )
{
// refresh the area along the right border
rect.x += size.x + dx;
rect.width = -dx;
}
else
{
// refresh the area along the left border
rect.width = dx;
}
rect.height = sizeTotal.y;
wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
rect.x, rect.y,
rect.GetRight() + 1, rect.GetBottom() + 1);
}
if ( dy )
{
if ( dy < 0 )
{
// refresh the area along the bottom border
rect.y += size.y + dy;
rect.height = -dy;
}
else
{
// refresh the area along the top border
rect.height = dy;
}
rect.width = sizeTotal.x;
wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
rect.x, rect.y,
rect.GetRight() + 1, rect.GetBottom() + 1);
}
#if wxUSE_CARET
if ( caret )
caret->Show();
#endif // wxUSE_CARET
}
return rect;
}
void GLCanvas::SyncWithOptions()
{
SetZoomSize( GetClientSize().GetWidth(), GetClientSize().GetHeight() );
}
void C3D_MODEL_VIEWER::OnPaint( wxPaintEvent &event )
{
wxPaintDC( this );
// SwapBuffer requires the window to be shown before calling
if( !IsShownOnScreen() )
{
wxLogTrace( m_logTrace, wxT( "C3D_MODEL_VIEWER::OnPaint !IsShown" ) );
return;
}
// "Makes the OpenGL state that is represented by the OpenGL rendering
// context context current, i.e. it will be used by all subsequent OpenGL calls.
// This function may only be called when the window is shown on screen"
GL_CONTEXT_MANAGER::Get().LockCtx( m_glRC, this );
// Set the OpenGL viewport according to the client size of this canvas.
// This is done here rather than in a wxSizeEvent handler because our
// OpenGL rendering context (and thus viewport setting) is used with
// multiple canvases: If we updated the viewport in the wxSizeEvent
// handler, changing the size of one canvas causes a viewport setting that
// is wrong when next another canvas is repainted.
wxSize clientSize = GetClientSize();
if( !m_ogl_initialized )
{
m_ogl_initialized = true;
ogl_initialize();
}
if( m_reload_is_needed )
{
wxLogTrace( m_logTrace, wxT( "C3D_MODEL_VIEWER::OnPaint m_reload_is_needed" ) );
m_reload_is_needed = false;
m_ogl_3dmodel = new C_OGL_3DMODEL( *m_3d_model );
// It convert a model as it was a board, so get the max size dimension of the board
// and compute the conversion scale
m_BiuTo3Dunits = (double)RANGE_SCALE_3D / ((double)m_ogl_3dmodel->GetBBox().GetMaxDimension() * UNITS3D_TO_UNITSPCB);
}
glViewport( 0, 0, clientSize.x, clientSize.y );
m_trackBallCamera.SetCurWindowSize( clientSize );
// clear color and depth buffers
// /////////////////////////////////////////////////////////////////////////
glEnable( GL_DEPTH_TEST );
glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
glClearDepth( 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Set projection and modelview matrixes
// /////////////////////////////////////////////////////////////////////////
glMatrixMode( GL_PROJECTION );
glLoadMatrixf( glm::value_ptr( m_trackBallCamera.GetProjectionMatrix() ) );
glMatrixMode( GL_MODELVIEW );
glLoadMatrixf( glm::value_ptr( m_trackBallCamera.GetViewMatrix() ) );
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// Render Model
if( m_ogl_3dmodel )
{
glPushMatrix();
double modelunit_to_3d_units_factor = m_BiuTo3Dunits * UNITS3D_TO_UNITSPCB;
glScaled( modelunit_to_3d_units_factor, modelunit_to_3d_units_factor, modelunit_to_3d_units_factor);
// Center model in the render viewport
const SFVEC3F model_center = m_ogl_3dmodel->GetBBox().GetCenter();
glTranslatef( -model_center.x, -model_center.y, -model_center.z );
// !TODO: draw transparent models
m_ogl_3dmodel->Draw_opaque();
m_ogl_3dmodel->Draw_transparent();
//m_ogl_3dmodel->Draw_bboxes();
glPopMatrix();
}
glViewport( 0, 0, clientSize.y / 8 , clientSize.y / 8 ); // YxY squared view port
glClear( GL_DEPTH_BUFFER_BIT );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 45.0f, 1.0f, 0.01f, RANGE_SCALE_3D * 2.0f );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
const glm::mat4 TranslationMatrix = glm::translate( glm::mat4(1.0f), SFVEC3F( 0.0f, 0.0f, -RANGE_SCALE_3D ) );
const glm::mat4 ViewMatrix = TranslationMatrix * m_trackBallCamera.GetRotationMatrix();
glLoadMatrixf( glm::value_ptr( ViewMatrix ) );
ogl_set_arrow_material();
glColor3f( 0.9f, 0.0f, 0.0f );
OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
SFVEC3F( RANGE_SCALE_3D / 2.65f, 0.0f, 0.0f ),
0.275f );
glColor3f( 0.0f, 0.9f, 0.0f );
OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
SFVEC3F( 0.0f, RANGE_SCALE_3D / 2.65f, 0.0f ),
0.275f );
glColor3f( 0.0f, 0.0f, 0.9f );
OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
SFVEC3F( 0.0f, 0.0f, RANGE_SCALE_3D / 2.65f ),
0.275f );
// "Swaps the double-buffer of this window, making the back-buffer the
// front-buffer and vice versa, so that the output of the previous OpenGL
// commands is displayed on the window."
SwapBuffers();
GL_CONTEXT_MANAGER::Get().UnlockCtx( m_glRC );
event.Skip();
}
void GCDCGraphs::DrawSeasonLimitInfo(wxGraphicsContext &dc, int i, int month, int day, bool summer) {
const double stripe_width = 2;
double x1 = GetX(i);
double x2 = GetX(i + 1);
double x = (x1 + x2) / 2;
int w, h;
GetClientSize(&w, &h);
wxColour color = summer ? *wxBLUE : *wxRED;
dc.SetFont(GetFont(), color);
dc.SetPen(wxPen(color, 1, wxSOLID));
wxBrush brush(color);
dc.SetBrush(brush);
dc.DrawRectangle(x + 1, m_screen_margins.topmargin, stripe_width, w - m_screen_margins.topmargin - m_screen_margins.bottommargin);
wxString str;
if (summer)
str = wxString(_("summer season"));
else
str = wxString(_("winter season"));
str += wxString::Format(_T(" %d "), day);
switch (month) {
case 1:
str += _("january");
break;
case 2:
str += _("february");
break;
case 3:
str += _("march");
break;
case 4:
str += _("april");
break;
case 5:
str += _("may");
break;
case 6:
str += _("june");
break;
case 7:
str += _("july");
break;
case 8:
str += _("august");
break;
case 9:
str += _("septermber");
break;
case 10:
str += _("october");
break;
case 11:
str += _("november");
break;
case 12:
str += _("december");
break;
default:
assert(false);
}
double tw, th, td, tsel;
dc.GetTextExtent(_T("W"), &tw, &th, &td, &tsel);
int ty = m_screen_margins.topmargin + 1;
for (size_t i = 0; i < str.Len(); ++i) {
double lw, lh, ld, lsel;
wxString letter = str.Mid(i, 1);
dc.GetTextExtent(letter, &lw, &lh, &ld, &lsel);
dc.DrawText(letter, x + stripe_width + 2 + (tw - lw) / 2, ty);
ty += th + 2;
}
}
// Draw the sash
void wxSashWindow::DrawSash(wxSashEdgePosition edge, wxDC& dc)
{
int w, h;
GetClientSize(&w, &h);
wxPen facePen(m_faceColour, 1, wxSOLID);
wxBrush faceBrush(m_faceColour, wxSOLID);
wxPen mediumShadowPen(m_mediumShadowColour, 1, wxSOLID);
wxPen darkShadowPen(m_darkShadowColour, 1, wxSOLID);
wxPen lightShadowPen(m_lightShadowColour, 1, wxSOLID);
wxPen hilightPen(m_hilightColour, 1, wxSOLID);
wxColour blackClr(0, 0, 0);
wxColour whiteClr(255, 255, 255);
wxPen blackPen(blackClr, 1, wxSOLID);
wxPen whitePen(whiteClr, 1, wxSOLID);
if ( edge == wxSASH_LEFT || edge == wxSASH_RIGHT )
{
int sashPosition = (edge == wxSASH_LEFT) ? 0 : ( w - GetEdgeMargin(edge) );
dc.SetPen(facePen);
dc.SetBrush(faceBrush);
dc.DrawRectangle(sashPosition, 0, GetEdgeMargin(edge), h);
if (GetWindowStyleFlag() & wxSW_3DSASH)
{
if (edge == wxSASH_LEFT)
{
// Draw a dark grey line on the left to indicate that the
// sash is raised
dc.SetPen(mediumShadowPen);
dc.DrawLine(GetEdgeMargin(edge), 0, GetEdgeMargin(edge), h);
}
else
{
// Draw a highlight line on the right to indicate that the
// sash is raised
dc.SetPen(hilightPen);
dc.DrawLine(w - GetEdgeMargin(edge), 0, w - GetEdgeMargin(edge), h);
}
}
}
else // top or bottom
{
int sashPosition = (edge == wxSASH_TOP) ? 0 : ( h - GetEdgeMargin(edge) );
dc.SetPen(facePen);
dc.SetBrush(faceBrush);
dc.DrawRectangle(0, sashPosition, w, GetEdgeMargin(edge));
if (GetWindowStyleFlag() & wxSW_3DSASH)
{
if (edge == wxSASH_BOTTOM)
{
// Draw a highlight line on the bottom to indicate that the
// sash is raised
dc.SetPen(hilightPen);
dc.DrawLine(0, h - GetEdgeMargin(edge), w, h - GetEdgeMargin(edge));
}
else
{
// Draw a drak grey line on the top to indicate that the
// sash is raised
dc.SetPen(mediumShadowPen);
dc.DrawLine(1, GetEdgeMargin(edge), w-1, GetEdgeMargin(edge));
}
}
}
dc.SetPen(wxNullPen);
dc.SetBrush(wxNullBrush);
}
void GCDCGraphs::OnMouseLeftDown(wxMouseEvent& event) {
/* get widget size */
int w, h;
GetClientSize(&w, &h);
/* check for 'move cursor left' event */
if (event.GetX() < m_screen_margins.leftmargin) {
m_draws_wdg->MoveCursorLeft();
return;
}
/* check for 'move cursor right' event */
if (event.GetX() > (w - m_screen_margins.rightmargin)) {
m_draws_wdg->MoveCursorRight();
return;
}
int index = m_draws_wdg->GetSelectedDrawIndex();
if (index < 0)
return;
wxDateTime ct = m_draws_wdg->GetSelectedDraw()->GetCurrentTime();
if (!ct.IsValid())
return;
struct VoteInfo {
double dist;
wxDateTime time;
};
VoteInfo infos[m_draws.size()];
int x = event.GetX();
int y = event.GetY();
int remark_idx = GetRemarkClickedIndex(x, y);
if (remark_idx != -1) {
m_draws_wdg->ShowRemarks(remark_idx);
return;
}
for (size_t i = 0; i < m_draws.size(); ++i) {
VoteInfo & in = infos[i];
in.dist = -1;
if (m_draws[i]->GetEnable())
GetDistance(i, x, y, in.dist, in.time);
}
double min = INFINITY;
int j = -1;
int selected_draw = m_draws_wdg->GetSelectedDrawIndex();
for (size_t i = 1; i <= m_draws.size(); ++i) {
size_t k = (i + selected_draw) % m_draws.size();
VoteInfo & in = infos[k];
if (in.dist < 0)
continue;
if (in.dist < 9 * 9
&& in.time == ct) {
j = k;
break;
}
if ((int)k == selected_draw && in.dist == 0) {
j = k;
break;
}
if (min > in.dist) {
j = k;
min = in.dist;
}
}
if (j == -1)
return;
if (selected_draw != j && infos[j].dist < 1000) {
m_draws_wdg->SelectDraw(j, true, infos[j].time);
} else
m_draws_wdg->SelectDraw(selected_draw, true, infos[selected_draw].time);
}
void
GraphCanvas::OnPaint(wxPaintEvent& evt)
{
// __REMARK__
// Previously we were using a wxMetafileDC to both evaluate the
// graph size and serve as a cache to draw it to a wxBitmapDC and
// avoid having to parse the xdot file again. The wxBitmapDC then
// was used on all paint operations until the user changed the
// zoom value.
wxAutoBufferedPaintDC dc(this);
DoPrepareDC(dc);
// Get the size of the client area.
int clwidth, clheight;
GetClientSize(&clwidth, &clheight);
// The deltas start at 0.
int dx = 0, dy = 0;
// If the width of the drawing is less than the width
// of the client area, we compute the delta to
// centralize horizontally. width and height are
// computed in another place.
if (m_Width < clwidth)
{
dx = (clwidth - m_Width) / 2;
}
// The same for the height.
if (m_Height < clheight)
{
dy = (clheight - m_Height) / 2;
}
// Get the pre-computed offset.
wxCoord x, y;
dc.GetDeviceOrigin(&x, &y);
// Set the user scale.
dc.SetUserScale(m_Zoom, m_Zoom);
// Clear the client area.
dc.SetBackground(*wxWHITE_BRUSH);
dc.Clear();
// Set the offset to the original one plus the deltas plus the border.
int zborder = (int)(m_BorderSize * m_Zoom);
dc.SetDeviceOrigin(x + dx + zborder, y + dy + zborder);
// Paint will draw whatever it wants to draw.
Paint(dc);
// Draw a dot at the bottom-right of the DC to account for the border.
if (m_BorderSize > 0)
{
int x = dc.MaxX() + zborder - 1;
int y = dc.MaxY() + zborder - 1;
wxColor color;
dc.GetPixel(x, y, &color);
wxPen pen(color);
dc.SetPen(pen);
dc.DrawPoint(x, y);
dc.SetPen(wxNullPen);
}
// Set the user scale back to 1.0, 1.0 to avoid
// pixalation.
// __REMARK__
// Windows doesn't need it but on Linux
// we get a pixelated image if we don't do it.
dc.SetUserScale(1.0, 1.0);
}
// Print the canvas contents to a bitmap:
void gateImage::generateImage() {
//WARNING!!! Heavily platform-dependent code ahead! This only works in MS Windows because of the
// DIB Section OpenGL rendering.
wxSize sz = GetClientSize();
// Create a DIB section.
// (The Windows wxBitmap implementation will create a DIB section for a bitmap if you set
// a color depth of 24 or greater.)
wxBitmap theBM( GATEIMAGESIZE, GATEIMAGESIZE, 32 );
// Get a memory hardware device context for writing to the bitmap DIB Section:
wxMemoryDC myDC;
myDC.SelectObject(theBM);
WXHDC theHDC = myDC.GetHDC();
// The basics of setting up OpenGL to render to the bitmap are found at:
// http://www.nullterminator.net/opengl32.html
// http://www.codeguru.com/cpp/g-m/opengl/article.php/c5587/
PIXELFORMATDESCRIPTOR pfd;
int iFormat;
// set the pixel format for the DC
::ZeroMemory( &pfd, sizeof( pfd ) );
pfd.nSize = sizeof( pfd );
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL | PFD_SUPPORT_GDI;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 16;
pfd.iLayerType = PFD_MAIN_PLANE;
iFormat = ::ChoosePixelFormat( (HDC) theHDC, &pfd );
::SetPixelFormat( (HDC) theHDC, iFormat, &pfd );
// create and enable the render context (RC)
HGLRC hRC = ::wglCreateContext( (HDC) theHDC );
HGLRC oldhRC = ::wglGetCurrentContext();
HDC oldDC = ::wglGetCurrentDC();
::wglMakeCurrent( (HDC) theHDC, hRC );
// Setup the viewport for rendering:
setViewport();
// Reset the glViewport to the size of the bitmap:
glViewport(0, 0, GATEIMAGESIZE, GATEIMAGESIZE);
// Set the bitmap clear color:
glClearColor (1.0, 1.0, 1.0, 0.0);
glColor3b(0, 0, 0);
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
//TODO: Check if alpha is hardware supported, and
// don't enable it if not!
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
//*********************************
//Edit by Joshua Lansford 4/09/07
//anti-alis ing is nice
//glEnable( GL_LINE_SMOOTH );
//End of edit
// Load the font texture
guiText::loadFont(wxGetApp().appSettings.textFontFile);
// Do the rendering here.
renderMap();
// Flush the OpenGL buffer to make sure the rendering has happened:
glFlush();
// Destroy the OpenGL rendering context, release the memDC, and
// convert the DIB Section into a wxImage to return to the caller:
::wglMakeCurrent( oldDC, oldhRC );
//::wglMakeCurrent( NULL, NULL );
::wglDeleteContext( hRC );
myDC.SelectObject(wxNullBitmap);
gImage = theBM.ConvertToImage();
}
void DashboardInstrument_Dial::DrawLabels(wxGCDC* dc)
{
if (m_LabelOption == DIAL_LABEL_NONE)
return;
wxPoint TextPoint;
wxPen pen;
wxColor cl;
GetGlobalColor(_T("DASHF"), &cl);
#ifdef __WXMSW__
wxSize size = GetClientSize();
// Create a new bitmap for this method graphics
wxBitmap tbm( size.x, size.y, -1 );
wxMemoryDC tdc( tbm );
wxColour cback;
GetGlobalColor( _T("DASHB"), &cback );
tdc.SetBackground( cback );
tdc.Clear();
tdc.SetFont(*g_pFontSmall);
tdc.SetTextForeground(cl);
#endif
dc->SetFont(*g_pFontSmall);
dc->SetTextForeground(cl);
int diff_angle = m_AngleStart + m_AngleRange - ANGLE_OFFSET;
// angle between markers
double abm = m_AngleRange * m_LabelStep / (m_MainValueMax - m_MainValueMin);
// don't draw last value, it's already done as first
if (m_AngleRange == 360) diff_angle -= abm;
int offset = 0;
int value = m_MainValueMin;
int width, height;
for(double angle = m_AngleStart - ANGLE_OFFSET; angle <= diff_angle; angle += abm)
{
wxString label = (m_LabelArray.GetCount() ? m_LabelArray.Item(offset) : wxString::Format(_T("%d"), value));
#ifdef __WXMSW__
if( g_pFontSmall->GetPointSize() <= 12 )
tdc.GetTextExtent(label, &width, &height, 0, 0, g_pFontSmall);
else
#endif
dc->GetTextExtent(label, &width, &height, 0, 0, g_pFontSmall);
double halfW = width / 2;
if (m_LabelOption == DIAL_LABEL_HORIZONTAL)
{
double halfH = height / 2;
//double delta = sqrt(width*width+height*height);
double delta = sqrt(halfW*halfW+halfH*halfH);
TextPoint.x = m_cx + ((m_radius * 0.90) - delta) * cos(deg2rad(angle)) - halfW;
TextPoint.y = m_cy + ((m_radius * 0.90) - delta) * sin(deg2rad(angle)) - halfH;
#ifdef __WXMSW__
if( g_pFontSmall->GetPointSize() <= 12 )
tdc.DrawText(label, TextPoint);
else
#endif
dc->DrawText(label, TextPoint);
}
else if (m_LabelOption == DIAL_LABEL_ROTATED)
{
// The coordinates of dc->DrawRotatedText refer to the top-left corner
// of the rectangle bounding the string. So we must calculate the
// right coordinates depending of the angle.
// Move left from the Marker so that the position is in the Middle of Text
long double tmpangle = angle - rad2deg(asin(halfW / (0.90 * m_radius)));
TextPoint.x = m_cx + m_radius * 0.90 * cos(deg2rad(tmpangle));
TextPoint.y = m_cy + m_radius * 0.90 * sin(deg2rad(tmpangle));
#ifdef __WXMSW__
if( g_pFontSmall->GetPointSize() <= 12 )
tdc.DrawRotatedText(label, TextPoint, -90 - angle);
else
#endif
dc->DrawRotatedText(label, TextPoint, -90 - angle);
}
offset++;
value += m_LabelStep;
}
#ifdef __WXMSW__
tdc.SelectObject( wxNullBitmap );
if( g_pFontSmall->GetPointSize() <= 12 )
dc->DrawBitmap(tbm, 0, 0, false);
#endif
}
AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
const wxPoint & pos,
const wxSize & size):wxFrame(parent,
id,
"Audacity",
pos,
size),
mRate((double) gPrefs->
Read("/SamplingRate/DefaultProjectSampleRate", 44100)),
mDirty(false), mDrag(NULL), mTrackPanel(NULL), mHistoryWindow(NULL),
mAutoScrolling(false), mTotalToolBarHeight(0), mDraggingToolBar(NoneID)
{
//
// Create track list
//
mTracks = new TrackList();
mLastSavedTracks = NULL;
//
// Initialize view info (shared with TrackPanel)
//
// Selection
mViewInfo.sel0 = 0.0;
mViewInfo.sel1 = 0.0;
// Horizontal scrollbar
mViewInfo.total = 1.0;
mViewInfo.screen = 1.0;
mViewInfo.h = 0.0;
mViewInfo.zoom = 44100.0 / 512.0;
mViewInfo.lastZoom = mViewInfo.zoom;
// Vertical scrollbar
mViewInfo.vpos = 0;
mViewInfo.scrollStep = 16;
mViewInfo.sbarH = 0;
mViewInfo.sbarScreen = 1;
mViewInfo.sbarTotal = 1;
// Some GUI prefs
gPrefs->Read("/GUI/UpdateSpectrogram", &mViewInfo.bUpdateSpectrogram, true);
gPrefs->Read("/GUI/AutoScroll", &mViewInfo.bUpdateTrackIndicator, true);
// Some extra information
mViewInfo.bIsPlaying = false;
mViewInfo.bRedrawWaveform = false;
mMenuBar = NULL;
CreateMenuBar();
int left = 0, top = 0, width, height;
GetClientSize(&width, &height);
//
// Create the Control Toolbar (if we're not using a windowed toolbar)
// The control toolbar should be automatically loaded--other toolbars are optional.
if (!gControlToolBarStub->GetWindowedStatus())
{
int h = gControlToolBarStub->GetHeight();
ToolBar *tb = new ControlToolBar(this, 0, wxPoint(10, top), wxSize(width - 10, h));
mToolBarArray.Add((ToolBar *) tb);
top += h + 1;
height -= h + 1;
mTotalToolBarHeight += h;
}
if (gEditToolBarStub) {
if(gEditToolBarStub->GetLoadedStatus()
&& !gEditToolBarStub->GetWindowedStatus())
{
int h = gEditToolBarStub->GetHeight();
ToolBar *etb = new EditToolBar(this,0 ,wxPoint(10,top), wxSize(width-10,h));
mToolBarArray.Add((ToolBar *) etb);
top +=h + 1;
height -= h + 1;
mTotalToolBarHeight +=h;
}
}
//
// Create the status bar
//
int sh = GetStatusHeight();
mStatus = new AStatus(this, 0,
wxPoint(0, height - sh),
wxSize(width, sh), mRate, this);
height -= sh;
mStatus->SetField(wxString::Format("Welcome to Audacity version %s",
AUDACITY_VERSION_STRING), 0);
//
// Create the TrackPanel and the scrollbars
//
mTrackPanel = new TrackPanel(this, TrackPanelID,
wxPoint(left, top),
wxSize(width - sbarSpaceWidth,
height - sbarSpaceWidth), mTracks,
&mViewInfo, this);
int hoffset = mTrackPanel->GetLeftOffset() - 1;
int voffset = mTrackPanel->GetRulerHeight();
#ifdef __WXMAC__
width++;
height++;
#endif
mHsbar =
new wxScrollBar(this, HSBarID,
wxPoint(hoffset, top + height - sbarSpaceWidth),
wxSize(width - hoffset - sbarSpaceWidth +
sbarExtraLen, sbarControlWidth),
wxSB_HORIZONTAL);
mVsbar =
new wxScrollBar(this, VSBarID,
wxPoint(width - sbarSpaceWidth, top + voffset),
wxSize(sbarControlWidth,
height - sbarSpaceWidth - voffset +
sbarExtraLen), wxSB_VERTICAL);
InitialState();
FixScrollbars();
//
// Set the Icon
//
// loads either the XPM or the windows resource, depending on the platform
#ifndef __WXMAC__
wxIcon ic(wxICON(AudacityLogo));
SetIcon(ic);
#endif
// Min size, max size
SetSizeHints(250, 200, 20000, 20000);
// Create tags object
mTags = new Tags();
#ifdef __WXMSW__
// Accept drag 'n' drop files
DragAcceptFiles(true);
#endif
gAudacityProjects.Add(this);
}
int wxSplitterWindow::GetWindowSize() const
{
wxSize size = GetClientSize();
return m_splitMode == wxSPLIT_VERTICAL ? size.x : size.y;
}
void AudacityProject::OnPaint(wxPaintEvent & event)
{
wxPaintDC dc(this);
int top = 0;
int h = 0;
int i, j;
int toolbartop, toolbarbottom, toolbarheight;
wxRect r;
int width, height;
GetClientSize(&width, &height);
//Deal with the ToolBars
for (i = 0; i < mToolBarArray.GetCount(); i++) {
AColor::Medium(&dc, false);
toolbartop = h;
h += mToolBarArray[i]->GetHeight();
toolbarbottom = h;
toolbarheight = toolbarbottom - toolbartop;
//Adjust a little for Windows (tm)
#ifdef __WXMSW__
h++;
#endif
//Draw a rectangle the space of scrollbar
r.x = width - sbarSpaceWidth;
r.y = toolbartop;
r.width = sbarSpaceWidth;
r.height = toolbarheight;
dc.DrawRectangle(r);
//Draw a rectangle around the "grab-bar"
r.x = 0;
r.y = toolbartop;
r.width = 10;
r.height = toolbarheight;
dc.DrawRectangle(r);
// Draw little bumps to the left of the toolbar to
// make it a "grab-bar".
//adjust min and max so that they aren't too close to the edges
int minbump = (toolbarheight % 2 == 0) ? 3 : 4;
int maxbump =
(toolbarheight % 2 == 0) ? toolbarheight - 3 : toolbarheight - 4;
AColor::Light(&dc, false);
for (j = minbump; j < maxbump; j += 4)
dc.DrawLine(3, toolbartop + j, 6, toolbartop + j);
AColor::Dark(&dc, false);
for (j = minbump + 1; j < maxbump + 1; j += 4)
dc.DrawLine(3, toolbartop + j, 6, toolbartop + j);
//Draw a black line to the right of the grab-bar
dc.SetPen(*wxBLACK_PEN);
dc.DrawLine(9, toolbartop, 9, toolbarbottom);
//Draw some more lines for Windows (tm)
#ifdef __WXMSW__
dc.DrawLine(0, toolbartop, width, toolbartop);
dc.DrawLine(0, toolbartop, 0, toolbarbottom);
#endif
dc.DrawLine(0, toolbarbottom, width, toolbarbottom);
h++;
}
//Now, h is equal to the total height of all the toolbars
top += h;
height -= h;
int sh = GetStatusHeight();
height -= sh;
// Fill in space on sides of scrollbars
dc.SetPen(*wxBLACK_PEN);
dc.DrawLine(width - sbarSpaceWidth, top,
width - sbarSpaceWidth, top + height - sbarSpaceWidth + 1);
dc.DrawLine(0, top + height - sbarSpaceWidth,
width - sbarSpaceWidth, top + height - sbarSpaceWidth);
wxRect f;
f.x = 0;
f.y = top + height - sbarSpaceWidth + 1;
f.width = mTrackPanel->GetLeftOffset() - 2;
f.height = sbarSpaceWidth - 2;
AColor::Medium(&dc, false);
dc.DrawRectangle(f);
AColor::Bevel(dc, true, f);
}
void TextEditorStc::OnSize(wxSizeEvent& evt)
{
edwnd->SetSize(GetClientSize());
}
// draw focus background on area in a way typical on platform
void
wxComboCtrl::PrepareBackground( wxDC& dc, const wxRect& rect, int flags ) const
{
#if wxUSE_UXTHEME
wxUxThemeHandle hTheme(this, L"COMBOBOX");
#endif
wxSize sz = GetClientSize();
bool isEnabled;
bool doDrawFocusRect; // also selected
// For smaller size control (and for disabled background) use less spacing
int focusSpacingX;
int focusSpacingY;
if ( !(flags & wxCONTROL_ISSUBMENU) )
{
// Drawing control
isEnabled = IsEnabled();
doDrawFocusRect = ShouldDrawFocus();
#if wxUSE_UXTHEME
// Windows-style: for smaller size control (and for disabled background) use less spacing
if ( hTheme )
{
// WinXP Theme
focusSpacingX = isEnabled ? 2 : 1;
focusSpacingY = sz.y > (GetCharHeight()+2) && isEnabled ? 2 : 1;
}
else
#endif
{
// Classic Theme
if ( isEnabled )
{
focusSpacingX = 1;
focusSpacingY = 1;
}
else
{
focusSpacingX = 0;
focusSpacingY = 0;
}
}
}
else
{
// Drawing a list item
isEnabled = true; // they are never disabled
doDrawFocusRect = flags & wxCONTROL_SELECTED ? true : false;
focusSpacingX = 0;
focusSpacingY = 0;
}
// Set the background sub-rectangle for selection, disabled etc
wxRect selRect(rect);
selRect.y += focusSpacingY;
selRect.height -= (focusSpacingY*2);
int wcp = 0;
if ( !(flags & wxCONTROL_ISSUBMENU) )
wcp += m_widthCustomPaint;
selRect.x += wcp + focusSpacingX;
selRect.width -= wcp + (focusSpacingX*2);
//wxUxThemeEngine* theme = NULL;
//if ( hTheme )
// theme = wxUxThemeEngine::GetIfActive();
wxColour bgCol;
bool doDrawDottedEdge = false;
bool doDrawSelRect = true;
// TODO: doDrawDottedEdge = true when focus has arrived to control via tab.
// (and other cases which are not that apparent).
if ( isEnabled )
{
// If popup is hidden and this control is focused,
// then draw the focus-indicator (selbgcolor background etc.).
if ( doDrawFocusRect )
{
// NB: We can't really use XP visual styles to get TMT_TEXTCOLOR since
// it is not properly defined for combo boxes. Instead, they expect
// you to use DrawThemeText.
//
// Here is, however, sample code how to get theme colours:
//
// COLORREF cref;
// theme->GetThemeColor(hTheme,EP_EDITTEXT,ETS_NORMAL,TMT_TEXTCOLOR,&cref);
// dc.SetTextForeground( wxRGBToColour(cref) );
if ( (m_iFlags & wxCC_FULL_BUTTON) && !(flags & wxCONTROL_ISSUBMENU) )
{
// Vista style read-only combo
doDrawSelRect = false;
doDrawDottedEdge = true;
}
else
{
dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT) );
bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
}
}
else
{
dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT) );
bgCol = GetBackgroundColour();
doDrawSelRect = false;
}
}
else
{
dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT) );
bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
}
dc.SetBrush(bgCol);
if ( doDrawSelRect )
{
dc.SetPen(bgCol);
dc.DrawRectangle(selRect);
}
if ( doDrawDottedEdge )
wxMSWDrawFocusRect(dc, selRect);
// Don't clip exactly to the selection rectangle so we can draw
// to the non-selected area in front of it.
wxRect clipRect(rect.x,rect.y,
(selRect.x+selRect.width)-rect.x-1,rect.height);
dc.SetClippingRegion(clipRect);
}
void AudacityProject::OnPaint(wxPaintEvent & event)
{
// Draw a colored strip on the right and bottom edges of
// the window to fill in the small area not covered by
// the TrackPanel or the scrollbars.
wxPaintDC dc(this);
int width, height;
GetClientSize(&width, &height);
AColor::Medium(&dc, false);
int top = 0;
if (!gWindowedPalette) {
int h = GetAPaletteHeight();
#ifdef __WXMSW__
h++;
#endif
top += h + 1;
height -= h + 1;
}
int sh = GetStatusHeight();
height -= sh;
wxRect r;
r.x = width - sbarSpaceWidth;
r.y = 0;
r.width = sbarSpaceWidth;
r.height = height;
dc.DrawRectangle(r);
// If we're displaying the palette inside the window,
// draw little bumps to the left of the palette to
// indicate it's grabable
if (!gWindowedPalette) {
int h = GetAPaletteHeight();
r.x = 0;
r.y = 0;
r.width = 10;
r.height = h;
dc.DrawRectangle(r);
int i;
AColor::Light(&dc, false);
for (i = h / 2 - 20; i < h / 2 + 20; i += 4)
dc.DrawLine(3, i, 6, i);
AColor::Dark(&dc, false);
for (i = h / 2 - 19; i < h / 2 + 21; i += 4)
dc.DrawLine(3, i, 6, i);
dc.SetPen(*wxBLACK_PEN);
dc.DrawLine(9, 0, 9, h);
#ifdef __WXMSW__
dc.DrawLine(0, 0, width, 0);
dc.DrawLine(0, 0, 0, h);
#endif
dc.DrawLine(0, h, width, h);
}
// Fill in space on sides of scrollbars
dc.SetPen(*wxBLACK_PEN);
dc.DrawLine(width - sbarSpaceWidth, top,
width - sbarSpaceWidth, top + height - sbarSpaceWidth + 1);
dc.DrawLine(0, top + height - sbarSpaceWidth,
width - sbarSpaceWidth, top + height - sbarSpaceWidth);
wxRect f;
f.x = 0;
f.y = top + height - sbarSpaceWidth + 1;
f.width = mTrackPanel->GetLeftOffset() - 2;
f.height = sbarSpaceWidth - 2;
AColor::Medium(&dc, false);
dc.DrawRectangle(f);
AColor::Bevel(dc, true, f);
}
void wxComboCtrl::OnPaintEvent( wxPaintEvent& WXUNUSED(event) )
{
// TODO: Convert drawing in this function to Windows API Code
wxSize sz = GetClientSize();
wxAutoBufferedPaintDC dc(this);
const wxRect& rectButton = m_btnArea;
wxRect rectTextField = m_tcArea;
wxColour bgCol = GetBackgroundColour();
#if wxUSE_UXTHEME
const bool isEnabled = IsEnabled();
wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl();
HDC hDc = GetHdcOf(*impl);
HWND hWnd = GetHwndOf(this);
wxUxThemeEngine* theme = NULL;
wxUxThemeHandle hTheme(this, L"COMBOBOX");
if ( hTheme )
theme = wxUxThemeEngine::GetIfActive();
#endif // wxUSE_UXTHEME
wxRect borderRect(0,0,sz.x,sz.y);
if ( m_iFlags & wxCC_IFLAG_BUTTON_OUTSIDE )
{
borderRect = m_tcArea;
borderRect.Inflate(1);
}
int drawButFlags = 0;
#if wxUSE_UXTHEME
if ( hTheme )
{
const bool useVistaComboBox = ::wxGetWinVersion() >= wxWinVersion_Vista;
RECT rFull;
wxCopyRectToRECT(borderRect, rFull);
RECT rButton;
wxCopyRectToRECT(rectButton, rButton);
RECT rBorder;
wxCopyRectToRECT(borderRect, rBorder);
bool isNonStdButton = (m_iFlags & wxCC_IFLAG_BUTTON_OUTSIDE) ||
(m_iFlags & wxCC_IFLAG_HAS_NONSTANDARD_BUTTON);
//
// Get some states for themed drawing
int butState;
if ( !isEnabled )
{
butState = CBXS_DISABLED;
}
// Vista will display the drop-button as depressed always
// when the popup window is visilbe
else if ( (m_btnState & wxCONTROL_PRESSED) ||
(useVistaComboBox && !IsPopupWindowState(Hidden)) )
{
butState = CBXS_PRESSED;
}
else if ( m_btnState & wxCONTROL_CURRENT )
{
butState = CBXS_HOT;
}
else
{
butState = CBXS_NORMAL;
}
int comboBoxPart = 0; // For XP, use the 'default' part
RECT* rUseForBg = &rBorder;
bool drawFullButton = false;
int bgState = butState;
const bool isFocused = (FindFocus() == GetMainWindowOfCompositeControl()) ? true : false;
if ( useVistaComboBox )
{
// FIXME: Either SetBackgroundColour or GetBackgroundColour
// doesn't work under Vista, so here's a temporary
// workaround.
bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
// Draw the entire control as a single button?
if ( !isNonStdButton )
{
if ( HasFlag(wxCB_READONLY) )
drawFullButton = true;
}
if ( drawFullButton )
{
comboBoxPart = CP_READONLY;
rUseForBg = &rFull;
// It should be safe enough to update this flag here.
m_iFlags |= wxCC_FULL_BUTTON;
}
else
{
comboBoxPart = CP_BORDER;
m_iFlags &= ~wxCC_FULL_BUTTON;
if ( isFocused )
bgState = CBB_FOCUSED;
else
bgState = CBB_NORMAL;
}
}
//
// Draw parent's background, if necessary
RECT* rUseForTb = NULL;
if ( theme->IsThemeBackgroundPartiallyTransparent( hTheme, comboBoxPart, bgState ) )
rUseForTb = &rFull;
else if ( m_iFlags & wxCC_IFLAG_BUTTON_OUTSIDE )
rUseForTb = &rButton;
if ( rUseForTb )
theme->DrawThemeParentBackground( hWnd, hDc, rUseForTb );
//
// Draw the control background (including the border)
if ( m_widthCustomBorder > 0 )
{
theme->DrawThemeBackground( hTheme, hDc, comboBoxPart, bgState, rUseForBg, NULL );
}
else
{
// No border. We can't use theme, since it cannot be relied on
// to deliver borderless drawing, even with DrawThemeBackgroundEx.
dc.SetBrush(bgCol);
dc.SetPen(bgCol);
dc.DrawRectangle(borderRect);
}
//
// Draw the drop-button
if ( !isNonStdButton )
{
drawButFlags = Button_BitmapOnly;
int butPart = CP_DROPDOWNBUTTON;
if ( useVistaComboBox )
{
if ( drawFullButton )
{
// We need to alter the button style slightly before
// drawing the actual button (but it was good above
// when background etc was done).
if ( butState == CBXS_HOT || butState == CBXS_PRESSED )
butState = CBXS_NORMAL;
}
if ( m_btnSide == wxRIGHT )
butPart = CP_DROPDOWNBUTTONRIGHT;
else
butPart = CP_DROPDOWNBUTTONLEFT;
}
theme->DrawThemeBackground( hTheme, hDc, butPart, butState, &rButton, NULL );
}
else if ( useVistaComboBox &&
(m_iFlags & wxCC_IFLAG_BUTTON_OUTSIDE) )
{
// We'll do this, because DrawThemeParentBackground
// doesn't seem to be reliable on Vista.
drawButFlags |= Button_PaintBackground;
}
}
else
#endif
{
// Windows 2000 and earlier
drawButFlags = Button_PaintBackground;
dc.SetBrush(bgCol);
dc.SetPen(bgCol);
dc.DrawRectangle(borderRect);
}
// Button rendering (may only do the bitmap on button, depending on the flags)
DrawButton( dc, rectButton, drawButFlags );
// Paint required portion of the custom image on the control
if ( (!m_text || m_widthCustomPaint) )
{
wxASSERT( m_widthCustomPaint >= 0 );
// this is intentionally here to allow drawed rectangle's
// right edge to be hidden
if ( m_text )
rectTextField.width = m_widthCustomPaint;
dc.SetFont( GetFont() );
dc.SetClippingRegion(rectTextField);
if ( m_popupInterface )
m_popupInterface->PaintComboControl(dc,rectTextField);
else
wxComboPopup::DefaultPaintComboControl(this,dc,rectTextField);
}
}
void GlyphPreviewWindow::OnPaint(wxPaintEvent& evt)
{
wxPaintDC dc(this);
if (m_entry.IsOK() && m_font.IsOk())
{
wxUint32 glyph = m_font.GetGlyphIndex(m_entry.GetCode());
wxSize glyphSize = m_font.GetGlyphSize(glyph);
wxSize clientSize = GetClientSize();
if (glyphSize.GetHeight() != 0 && glyphSize.GetWidth() != 0)
{
float scale;
if (glyphSize.GetWidth() > glyphSize.GetHeight())
{
scale = (float)clientSize.GetWidth()/glyphSize.GetWidth();
}
else {
scale = (float) clientSize.GetHeight() / glyphSize.GetHeight();
}
scale *= 0.9f;
int size = m_font.GetGlyphBitmap(glyph, NULL, NULL, NULL);
if (size > 0)
{
int width, height;
wxUint8 *bitmap = new wxUint8[size];
wxSize glyphSize = m_font.GetGlyphSize(glyph);
wxPoint bearing = m_font.GetGlyphBearing(glyph);
m_font.GetGlyphBitmap(glyph, bitmap, &width, &height);
wxImage image(width, height);
unsigned char *rgb = image.GetData();
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int offset = ((y) * image.GetWidth() + x) * 3;
wxASSERT(offset+2 < image.GetWidth()*image.GetHeight()*3);
wxASSERT(offset >= 0);
rgb[0 + offset] = 255 - bitmap[y * width + x];
rgb[1 + offset] = 255 - bitmap[y * width + x];
rgb[2 + offset] = 255 - bitmap[y * width + x];
}
}
image.Rescale(width*scale, height*scale);
wxPoint origin((clientSize.GetWidth() - glyphSize.GetWidth()*scale)/2,
(clientSize.GetHeight() - glyphSize.GetHeight()*scale)/2);
origin.y += bearing.y*scale;
wxPoint glyphPos = origin + wxPoint(bearing.x, -bearing.y)*scale;
dc.DrawBitmap(wxBitmap(image), glyphPos);
dc.SetPen(*wxRED_PEN);
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRectangle(glyphPos, wxSize(image.GetWidth(), image.GetHeight()));
dc.SetPen(*wxGREEN_PEN);
dc.DrawLine(0, origin.y, clientSize.GetWidth(), origin.y);
dc.DrawLine(origin.x, 0, origin.x, clientSize.GetHeight());
wxPoint advancePoint = origin += m_font.GetGlyphAdvance(glyph)*scale;
dc.SetPen(*wxBLUE_PEN);
dc.DrawLine(advancePoint.x - 10, advancePoint.y, advancePoint.x + 10, advancePoint.y);
dc.DrawLine(advancePoint.x, advancePoint.y - 10, advancePoint.x, advancePoint.y + 10);
delete [] bitmap;
}
}
}
}
void CMusikListCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
{
wxBufferedPaintDC dc(this);
MSWDefWindowProc(WM_ERASEBKGND, (WPARAM) (HDC) dc.GetHDC(), 0);
MSWDefWindowProc(WM_PAINT, (WPARAM) (HDC) dc.GetHDC(), 0);
/* copied from original wxwindows code */
// Reset the device origin since it may have been set
dc.SetDeviceOrigin(0, 0);
bool drawHRules = ((GetWindowStyle() & wxLC_HRULES) != 0);
bool drawVRules = ((GetWindowStyle() & wxLC_VRULES) != 0);
if (!drawHRules && !drawVRules)
return;
if ((GetWindowStyle() & wxLC_REPORT) == 0)
return;
wxPen pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT), 1, wxSOLID);
dc.SetPen(pen);
dc.SetBrush(* wxTRANSPARENT_BRUSH);
wxSize clientSize = GetClientSize();
wxRect itemRect;
int cy=0;
int itemCount = GetItemCount();
int i;
if (drawHRules)
{
long top = GetTopItem();
for (i = top; i < top + GetCountPerPage() + 1; i++)
{
if (GetItemRect(i, itemRect))
{
cy = itemRect.GetTop();
if (i != 0) // Don't draw the first one
{
dc.DrawLine(0, cy, clientSize.x, cy);
}
// Draw last line
if (i == itemCount - 1)
{
cy = itemRect.GetBottom();
dc.DrawLine(0, cy, clientSize.x, cy);
}
}
}
}
i = itemCount - 1;
if (drawVRules && (i > -1))
{
wxRect firstItemRect;
GetItemRect(0, firstItemRect);
if (GetItemRect(i, itemRect))
{
int col;
int x = itemRect.GetX();
for (col = 0; col < GetColumnCount(); col++)
{
int colWidth = GetColumnWidth(col);
x += colWidth ;
dc.DrawLine(x-1, firstItemRect.GetY() - 2, x-1, itemRect.GetBottom());
}
}
}
}
