void PythonInterpreter::OnUpdateUI(wxUpdateUIEvent& event)
{
#ifndef TOOLSPLUSLINK
if(m_ViewMenu)
{
m_ViewMenu->Check(ID_INTERP_WINDOW_TOGGLE,IsWindowReallyShown(m_shellmgr));
// allow other UpdateUI handlers to process this event
// *very* important! don't forget it...
event.Skip();
}
#endif // TOOLSPLUSLINK
}
void OccurrencesHighlighting::OnUpdateViewMenu(wxUpdateUIEvent &event)
{
if (m_pViewMenu)
{
bool isVis = IsWindowReallyShown((wxWindow*)m_pPanel);
m_pViewMenu->Check(idViewOccurencesPanel, isVis);
//event.Check(isVis);
}
// must do...
event.Skip();
}
void SourceView::OnUpdateUI(wxUpdateUIEvent& event)
{
long col, line;
const bool result = PositionToXY(GetInsertionPoint(), &col, &line);
if(!result)
line = -1;
else
line += 1;//convert to 1-based line numbering
mainwin->setCurrent(currentfile, line);
event.Skip();
}
void ErdPanel::OnToolUpdate(wxUpdateUIEvent& event)
{
if(event.GetId() == XRCID("IDT_ERD_TOOL"))
event.Check(m_nToolMode == modeDESIGN);
else if(event.GetId() == XRCID("IDT_ERD_TABLE"))
event.Check(m_nToolMode == modeTABLE);
else if(event.GetId() == XRCID("IDT_ERD_LINE"))
event.Check(m_nToolMode == modeLine);
else if(event.GetId() == XRCID("IDT_ERD_VIEW"))
event.Check(m_nToolMode == modeVIEW);
else
event.Skip();
}
void AbstractApp::OnUpdateMenuItem(wxUpdateUIEvent& event) {
if (event.GetId() == wxID_ABOUT ||
event.GetId() == TrenchBroom::View::CommandIds::Menu::HelpShowHelp)
event.Enable(true);
else if (event.GetId() == wxID_PREFERENCES ||
event.GetId() == wxID_NEW ||
event.GetId() == wxID_OPEN)
event.Enable(m_preferencesFrame == NULL);
else
event.Enable(false);
if (GetTopWindow() != NULL && m_preferencesFrame == NULL)
event.Skip();
}
void CDlgOptions::OnEnableSOCKSProxyCtrlUpdate(wxUpdateUIEvent& event) {
if (m_EnableSOCKSProxyCtrl->IsEnabled() && m_EnableSOCKSProxyCtrl->IsChecked()) {
m_SOCKSAddressCtrl->Enable(true);
m_SOCKSPortCtrl->Enable(true);
m_SOCKSUsernameCtrl->Enable(true);
m_SOCKSPasswordCtrl->Enable(true);
} else {
m_SOCKSAddressCtrl->Enable(false);
m_SOCKSPortCtrl->Enable(false);
m_SOCKSUsernameCtrl->Enable(false);
m_SOCKSPasswordCtrl->Enable(false);
}
event.Skip();
}
void EnvVarsProjectOptionsDlg::OnUpdateUI(wxUpdateUIEvent& event)
{
#if TRACE_ENVVARS
Manager::Get()->GetLogManager()->DebugLog(F(_T("OnUpdateUI")));
#endif
wxCheckBox* checkbox_control = XRCCTRL(*this, "chkEnvvarSet", wxCheckBox);
if (checkbox_control)
{
wxChoice* choice_control = XRCCTRL(*this, "choEnvvarSets", wxChoice);
if (choice_control)
choice_control->Enable(checkbox_control->IsChecked());
}
event.Skip();
}// OnUpdateUI
void Exporter::OnUpdateUI(wxUpdateUIEvent &event)
{
if (Manager::IsAppShuttingDown())
{
event.Skip();
return;
}
wxMenuBar *mbar = Manager::Get()->GetAppFrame()->GetMenuBar();
if (mbar)
{
EditorManager *em = Manager::Get()->GetEditorManager();
// Enabled if there's a source file opened (be sure it isn't the "Start here" page)
bool disable = !em || !em->GetActiveEditor() || !em->GetBuiltinActiveEditor();
mbar->Enable(idFileExportHTML, !disable);
mbar->Enable(idFileExportRTF, !disable);
mbar->Enable(idFileExportODT, !disable);
mbar->Enable(idFileExportPDF, !disable);
}
event.Skip();
}
void CDlgOptions::OnEnableHTTPProxyCtrlUpdate(wxUpdateUIEvent& event) {
if (m_EnableHTTPProxyCtrl->IsEnabled() && m_EnableHTTPProxyCtrl->IsChecked()) {
m_HTTPAddressCtrl->Enable(true);
m_HTTPPortCtrl->Enable(true);
m_HTTPUsernameCtrl->Enable(true);
m_HTTPPasswordCtrl->Enable(true);
m_HTTPNoProxiesCtrl->Enable(true);
} else {
m_HTTPAddressCtrl->Enable(false);
m_HTTPPortCtrl->Enable(false);
m_HTTPUsernameCtrl->Enable(false);
m_HTTPPasswordCtrl->Enable(false);
m_HTTPNoProxiesCtrl->Enable(false);
}
event.Skip();
}
void OutputTabWindow::OnEditUI(wxUpdateUIEvent& e)
{
if ( !IsFocused() || !m_sci ) {
e.Skip();
return;
}
switch (e.GetId()) {
case wxID_COPY:
e.Enable( m_sci->GetSelectedText().IsEmpty() == false );
break;
case wxID_SELECTALL:
e.Enable(true);
break;
default:
break;
}
}
void DebuggerAsciiViewer::OnEditUI(wxUpdateUIEvent& e)
{
if ( !IsFocused() ) {
e.Skip();
return;
}
switch ( e.GetId() ) {
case wxID_SELECTALL:
e.Enable(true);
break;
case wxID_COPY:
e.Enable( m_textView->GetSelectedText().IsEmpty() == false );
break;
default:
e.Enable(false);
break;
}
}
void DebuggerToolbarHandler::OnUpdateUI(wxUpdateUIEvent& event)
{
cbDebuggerPlugin *plugin = Manager::Get()->GetDebuggerManager()->GetActiveDebugger();
ProjectManager *manager = Manager::Get()->GetProjectManager();
bool en = false;
bool stopped = false, isRunning = false;
if (plugin)
{
cbProject* prj = manager->GetActiveProject();
en = (prj && !prj->GetCurrentlyCompilingTarget()) || plugin->IsAttachedToProcess();
stopped = plugin->IsStopped();
isRunning = plugin->IsRunning();
}
if (m_Toolbar)
{
cbEditor* ed = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor();
cbPlugin *runningPlugin = manager->GetIsRunning();
if (runningPlugin != NULL && runningPlugin != plugin)
en = false;
m_Toolbar->EnableTool(idMenuDebug, (!isRunning || stopped) && en);
m_Toolbar->EnableTool(idMenuRunToCursor, en && ed && stopped);
m_Toolbar->EnableTool(idMenuNext, isRunning && en && stopped);
m_Toolbar->EnableTool(idMenuNextInstr, isRunning && en && stopped);
m_Toolbar->EnableTool(idMenuStepIntoInstr, isRunning && en && stopped);
m_Toolbar->EnableTool(idMenuStep, en && stopped);
m_Toolbar->EnableTool(idMenuStepOut, isRunning && en && stopped);
m_Toolbar->EnableTool(idToolbarStop, isRunning && en);
m_Toolbar->EnableTool(idMenuBreak, isRunning && !stopped && en);
m_Toolbar->EnableTool(idDebuggerToolInfo, plugin && plugin->ToolMenuEnabled());
}
// allow other UpdateUI handlers to process this event
// *very* important! don't forget it...
event.Skip();
}
void CQuickFindBar::OnEditUI(wxUpdateUIEvent& e)
{
wxTextCtrl *ctrl = GetFocusedControl();
if ( !ctrl ) {
e.Skip();
return;
}
switch (e.GetId()) {
case wxID_SELECTALL:
e.Enable(ctrl->GetValue().IsEmpty() == false);
break;
case wxID_COPY:
e.Enable(ctrl->CanCopy());
break;
case wxID_PASTE:
e.Enable(ctrl->CanPaste());
break;
default:
e.Enable(false);
break;
}
}
//-------------------------------------------------------------------------------------------------
void DynaDialog::OnUpdateUI( wxUpdateUIEvent& event )
{
event.Skip();
}
void FindPath::OnUpdateUI( wxUpdateUIEvent &event )
{
event.Skip( TRUE );
}
void MvcController::UponUpdateUI(wxUpdateUIEvent& event)
{
event.Skip();
unit_test_idle_processing_completed_ = false;
// Explicitly disregard any wxUpdateUIEvent received while this
// application is not active: see
// http://lists.gnu.org/archive/html/lmi/2006-03/msg00006.html
// for a discussion.
if(!TheApp().IsActive())
{
return;
}
// A disabled window might have focus:
// http://lists.nongnu.org/archive/html/lmi/2005-11/msg00040.html
// so make sure focus is valid now.
EnsureOptimalFocus();
// Exit immediately if nothing changed. The library calls this
// function continually in idle time, and it's pointless to fret
// over inputs that didn't change on this update because they've
// already been handled. Complex processing of many inputs has
// been observed to consume excessive CPU time when a malloc
// debugger is running, so this optimization is significant.
//
// The early-exit condition cannot succeed until Assimilate() has
// been called: therefore, Assimilate() is guaranteed to be called
// here by the time the user can interact with the GUI.
TransferDataFromWindow();
if(cached_transfer_data_ == transfer_data_)
{
unit_test_idle_processing_completed_ = true;
return;
}
cached_transfer_data_ = transfer_data_;
DiagnosticsWindow().SetLabel("");
std::vector<std::string> control_changes;
std::string const name_to_ignore = NameOfControlToDeferEvaluating();
typedef std::map<std::string,std::string>::const_iterator smci;
for(smci i = transfer_data_.begin(); i != transfer_data_.end(); ++i)
{
std::string const& name = i->first;
std::string const& view_value = i->second;
std::string const& model_value = model_.Entity(name).str();
if(name == name_to_ignore || ModelAndViewValuesEquivalent(name))
{
continue;
}
try
{
std::string change =
name + ":\n"
+ " model: '" + model_value + "'\n"
+ " view: '" + view_value + "'\n"
;
control_changes.push_back(change);
model_.Entity(name) = view_value;
}
catch(std::exception const& e)
{
DiagnosticsWindow().SetLabel(name + ": " + e.what());
}
}
// wxEVT_UPDATE_UI events should occur frequently enough that two
// control changes cannot be simultaneous.
if(1 < control_changes.size())
{
warning() << "Contents of more than one control changed.\n";
typedef std::vector<std::string>::const_iterator svci;
for(svci i = control_changes.begin(); i != control_changes.end(); ++i)
{
warning() << *i;
}
warning() << LMI_FLUSH;
}
Assimilate(name_to_ignore);
}
void DebuggerTreeListCtrlBase::OnRefreshUI(wxUpdateUIEvent& event)
{
event.Skip();
}
void StripMenuButton::onUpdateUI( wxUpdateUIEvent& event)
{
updateMouse();
event.Skip();
}
void EditorButton::OnUpdateUI( wxUpdateUIEvent& event )
{
EditorSettings* settings = wxGetApp().GetSettingsManager()->GetSettings< EditorSettings >();
if ( !settings )
{
return;
}
bool needsUpdate = false;
if ( !( GetOptions() & PanelButtonOptions::AlwaysShowText ) && ( settings->m_ShowTextOnButtons != m_ShowText ) )
{
m_ShowText = settings->m_ShowTextOnButtons;
needsUpdate = true;
}
if ( settings->m_ShowIconsOnButtons != m_ShowIcons )
{
m_ShowIcons = settings->m_ShowIconsOnButtons;
needsUpdate = true;
}
if ( settings->m_IconSizeOnButtons != m_IconSize )
{
m_IconSize = settings->m_IconSizeOnButtons;
needsUpdate = true;
}
if ( !needsUpdate )
{
return;
}
wxWindowList children = GetChildren();
for ( wxWindowList::iterator itr = children.begin(), end = children.end(); itr != end; ++itr )
{
wxStaticBitmap* bitmap = dynamic_cast< wxStaticBitmap* >( (*itr) );
if ( bitmap )
{
if ( m_ShowIcons )
{
bitmap->Show();
}
else
{
bitmap->Hide();
}
DynamicBitmap* dynamicBitmap = dynamic_cast< DynamicBitmap* >( (*itr) );
if ( dynamicBitmap )
{
switch( m_IconSize )
{
case IconSize::Small:
dynamicBitmap->SetIconSize( 16 );
break;
case IconSize::Medium:
dynamicBitmap->SetIconSize( 24 );
break;
case IconSize::Large:
dynamicBitmap->SetIconSize( 32 );
break;
default:
HELIUM_BREAK();
break;
}
}
continue;
}
wxStaticText* text = dynamic_cast< wxStaticText* >( (*itr) );
if ( text )
{
if ( m_ShowText )
{
text->Show();
}
else
{
text->Hide();
}
continue;
}
}
Refresh();
GetSizer()->RecalcSizes();
Layout();
GetParent()->Refresh();
GetParent()->GetSizer()->RecalcSizes();
GetParent()->Layout();
event.Skip();
}
void MainFrm::OnUpdateTool(wxUpdateUIEvent& event)
{
switch(event.GetId())
{
case IDT_GRID:
event.Check(m_fShowGrid);
break;
case IDT_GC:
event.Check( wxSFShapeCanvas::IsGCEnabled() );
break;
case IDT_BITMAPSHP:
event.Check(m_nToolMode == modeBITMAP);
break;
case IDT_CIRCLESHP:
event.Check(m_nToolMode == modeCIRCLE);
break;
case IDT_CURVESHP:
event.Check(m_nToolMode == modeCURVE);
break;
case IDT_ORTHOSHP:
event.Check(m_nToolMode == modeORTHOLINE);
break;
case IDT_RNDORTHOSHP:
event.Check(m_nToolMode == modeROUNDORTHOLINE);
break;
case IDT_DIAMONDSHP:
event.Check(m_nToolMode == modeDIAMOND);
break;
case IDT_EDITTEXTSHP:
event.Check(m_nToolMode == modeEDITTEXT);
break;
case IDT_ELLIPSESHP:
event.Check(m_nToolMode == modeELLIPSE);
break;
case IDT_GRIDSHP:
event.Check(m_nToolMode == modeGRID);
break;
case IDT_FLEXGRIDSHP:
event.Check(m_nToolMode == modeFLEXGRID);
break;
case IDT_LINESHP:
event.Check(m_nToolMode == modeLINE);
break;
case IDT_STANDALONELINESHP:
event.Check(m_nToolMode == modeSTANDALONELINE);
break;
case IDT_RECTSHP:
event.Check(m_nToolMode == modeRECT);
break;
case IDT_RNDRECTSHP:
event.Check(m_nToolMode == modeROUNDRECT);
break;
case IDT_SQUARESHP:
event.Check(m_nToolMode == modeFIXEDRECT);
break;
case IDT_TEXTSHP:
event.Check(m_nToolMode == modeTEXT);
break;
case IDT_TOOL:
event.Check(m_nToolMode == modeDESIGN);
break;
case IDT_ALIGN_RIGHT:
case IDT_ALIGN_LEFT:
case IDT_ALIGN_TOP:
case IDT_ALIGN_BOTTOM:
case IDT_ALIGN_MIDDLE:
case IDT_ALIGN_CENTER:
if( m_pShapeCanvas ) event.Enable(m_pShapeCanvas->CanAlignSelected());
break;
default:
event.Skip();
break;
}
}
void DebuggerMenuHandler::OnUpdateUI(wxUpdateUIEvent& event)
{
cbProject* prj = Manager::Get()->GetProjectManager()->GetActiveProject();
bool en = false, stopped = false, isRunning = false, isAttached = false;
if (m_activeDebugger)
{
isAttached = m_activeDebugger->IsAttachedToProcess();
en = (prj && !prj->GetCurrentlyCompilingTarget()) || isAttached;
stopped = m_activeDebugger->IsStopped() && !m_activeDebugger->IsBusy();
isRunning = m_activeDebugger->IsRunning();
}
cbEditor* ed = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor();
wxMenuBar* mbar = Manager::Get()->GetAppFrame()->GetMenuBar();
cbPlugin *runningPlugin = Manager::Get()->GetProjectManager()->GetIsRunning();
bool otherPlugin = false;
if (runningPlugin != NULL && runningPlugin != m_activeDebugger)
{
en = false;
otherPlugin = true;
}
if (mbar && Manager::Get()->GetDebuggerManager()->HasMenu())
{
bool hasBreaks = Support(m_activeDebugger, cbDebuggerFeature::Breakpoints);
mbar->Enable(idMenuDebug, (!isRunning || stopped) && en);
mbar->Enable(idMenuNext, isRunning && en && stopped);
mbar->Enable(idMenuNextInstr, isRunning && en && stopped);
mbar->Enable(idMenuStepIntoInstr, isRunning && en && stopped);
mbar->Enable(idMenuStep, en && stopped);
mbar->Enable(idMenuStepOut, isRunning && en && stopped);
mbar->Enable(idMenuRunToCursor,
en && ed && stopped && Support(m_activeDebugger, cbDebuggerFeature::RunToCursor));
mbar->Enable(idMenuSetNextStatement,
en && ed && stopped && isRunning && Support(m_activeDebugger, cbDebuggerFeature::SetNextStatement));
mbar->Enable(idMenuToggleBreakpoint, ed && m_activeDebugger && hasBreaks);
mbar->Enable(idMenuRemoveAllBreakpoints, m_activeDebugger && hasBreaks);
mbar->Enable(idMenuSendCommand, isRunning && stopped);
mbar->Enable(idMenuAddSymbolFile, isRunning && stopped);
mbar->Enable(idMenuStop, isRunning && en);
mbar->Enable(idMenuBreak, isRunning && !stopped && en);
mbar->Enable(idMenuAttachToProcess, !isRunning && !otherPlugin && m_activeDebugger);
mbar->Enable(idMenuDetach, isRunning && stopped && isAttached);
wxMenu *activeMenu = GetMenuById(idMenuDebugActive);
if (activeMenu)
{
for (size_t ii = 0; ii < activeMenu->GetMenuItemCount(); ++ii)
activeMenu->Enable(activeMenu->FindItemByPosition(ii)->GetId(), !isRunning);
}
mbar->Enable(idMenuTools, m_activeDebugger && m_activeDebugger->ToolMenuEnabled());
}
// allow other UpdateUI handlers to process this event
// *very* important! don't forget it...
event.Skip();
}
void BatchBuildDlg::OnMoveDownUI( wxUpdateUIEvent& event )
{
event.Skip();
}
void CDlgOptions::OnNotebookUpdate(wxUpdateUIEvent& event)
{
event.Skip();
}
