bool ThreadSearchView::UpdatePreview(const wxString& file, long line)
{
bool success(true);
if ( line > 0 )
{
// Line display begins at 1 but line index at 0
line--;
}
// Disable read only
m_pSearchPreview->Enable(false);
m_pSearchPreview->SetReadOnly(false);
// Loads file if different from current loaded
wxFileName filename(file);
if ( (m_PreviewFilePath != file) || (m_PreviewFileDate != filename.GetModificationTime()) )
{
ConfigManager* mgr = Manager::Get()->GetConfigManager(_T("editor"));
// Remember current file path and modification time
m_PreviewFilePath = file;
m_PreviewFileDate = filename.GetModificationTime();
EncodingDetector enc(m_PreviewFilePath, false);
success = enc.IsOK();
m_pSearchPreview->SetText(enc.GetWxStr());
// Colorize
cbEditor::ApplyStyles(m_pSearchPreview);
EditorColourSet EdColSet;
EdColSet.Apply(EdColSet.GetLanguageForFilename(m_PreviewFilePath), m_pSearchPreview, false,
true);
SetFoldingIndicator(mgr->ReadInt(_T("/folding/indicator"), 2));
UnderlineFoldedLines(mgr->ReadBool(_T("/folding/underline_folded_line"), true));
}
if ( success == true )
{
// Display the selected line
int onScreen = m_pSearchPreview->LinesOnScreen() >> 1;
m_pSearchPreview->GotoLine(line - onScreen);
m_pSearchPreview->GotoLine(line + onScreen);
m_pSearchPreview->GotoLine(line);
m_pSearchPreview->EnsureVisible(line);
int startPos = m_pSearchPreview->PositionFromLine(line);
int endPos = m_pSearchPreview->GetLineEndPosition(line);
m_pSearchPreview->SetSelectionVoid(endPos, startPos);
}
void AutosaveConfigDlg::LoadSettings()
{
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("autosave"));
bool doProjects = cfg->ReadBool(_T("do_project"));
bool doSources = cfg->ReadBool(_T("do_sources"));
XRCCTRL(*this, "do_project", wxCheckBox)->SetValue(doProjects);
XRCCTRL(*this, "do_sources", wxCheckBox)->SetValue(doSources);
XRCCTRL(*this, "do_workspace", wxCheckBox)->SetValue(cfg->ReadBool(_T("do_workspace"), true));
XRCCTRL(*this, "all_projects", wxCheckBox)->SetValue(cfg->ReadBool(_T("all_projects"), true));
int minsProjects = std::max(cfg->ReadInt(_T("project_mins"), 1), 1);
int minsSources = std::max(cfg->ReadInt(_T("source_mins"), 1), 1);
XRCCTRL(*this, "project_mins", wxTextCtrl)->SetValue(wxString::Format(_T("%d"), minsProjects));
XRCCTRL(*this, "source_mins", wxTextCtrl)->SetValue(wxString::Format(_T("%d"), minsSources));
XRCCTRL(*this, "do_workspace", wxCheckBox)->Enable(doProjects);
XRCCTRL(*this, "all_projects", wxCheckBox)->Enable(doProjects);
XRCCTRL(*this, "project_mins", wxTextCtrl)->Enable(doProjects);
XRCCTRL(*this, "source_mins", wxTextCtrl)->Enable(doSources);
XRCCTRL(*this, "method", wxChoice)->SetSelection(cfg->ReadInt(_T("method"), 2));
}
SearchInPanel::SearchInPanel(wxWindow* parent, int id, const wxPoint& pos, const wxSize& size, long WXUNUSED(style)):
wxPanel(parent, id, pos, size, wxTAB_TRAVERSAL)
{
//{ Getting the imagesize for the buttons (16x16 or 22x22) and the appropriate path
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
bool toolbar_size = cfg->ReadBool(_T("/environment/toolbar_size"),true);
wxString prefix = ConfigManager::GetDataFolder() + _T("/images/ThreadSearch/") + (toolbar_size?_T("16x16/"):_T("22x22/"));
// create a dummy button to get the standard button-size,
// wxCustomButton does not do that properly
// we have to force this size as MinSize to make it work
wxBitmapButton dummyBtn(this, wxID_ANY, wxBitmap(prefix + wxT("openfiles.png"), wxBITMAP_TYPE_PNG));
wxSize dummySize = dummyBtn.GetSize();
m_pBtnSearchOpenFiles = new wxCustomButton(this, controlIDs.Get(ControlIDs::idBtnSearchOpenFiles),
wxBitmap(prefix + wxT("openfiles.png"), wxBITMAP_TYPE_PNG),
wxDefaultPosition, dummySize);
m_pBtnSearchOpenFiles->SetBitmapDisabled(wxBitmap(prefix + wxT("openfilesdisabled.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchOpenFiles->SetBitmapSelected(wxBitmap(prefix + wxT("openfilesselected.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchOpenFiles->SetMinSize(dummySize);
m_pBtnSearchTargetFiles = new wxCustomButton(this, controlIDs.Get(ControlIDs::idBtnSearchTargetFiles),
wxBitmap(prefix + wxT("target.png"), wxBITMAP_TYPE_PNG),
wxDefaultPosition, dummySize);
m_pBtnSearchTargetFiles->SetBitmapDisabled(wxBitmap(prefix + wxT("targetdisabled.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchTargetFiles->SetBitmapSelected(wxBitmap(prefix + wxT("targetselected.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchTargetFiles->SetMinSize(dummySize);
m_pBtnSearchProjectFiles = new wxCustomButton(this, controlIDs.Get(ControlIDs::idBtnSearchProjectFiles),
wxBitmap(prefix + wxT("project.png"), wxBITMAP_TYPE_PNG),
wxDefaultPosition, dummySize);
m_pBtnSearchProjectFiles->SetBitmapDisabled(wxBitmap(prefix + wxT("projectdisabled.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchProjectFiles->SetBitmapSelected(wxBitmap(prefix + wxT("projectselected.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchProjectFiles->SetMinSize(dummySize);
m_pBtnSearchWorkspaceFiles = new wxCustomButton(this, controlIDs.Get(ControlIDs::idBtnSearchWorkspaceFiles),
wxBitmap(prefix + wxT("workspace.png"), wxBITMAP_TYPE_PNG),
wxDefaultPosition, dummySize);
m_pBtnSearchWorkspaceFiles->SetBitmapDisabled(wxBitmap(prefix + wxT("workspacedisabled.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchWorkspaceFiles->SetBitmapSelected(wxBitmap(prefix + wxT("workspaceselected.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchWorkspaceFiles->SetMinSize(dummySize);
m_pBtnSearchDir = new wxCustomButton(this, controlIDs.Get(ControlIDs::idBtnSearchDirectoryFiles),
wxBitmap(prefix + wxT("folder.png"), wxBITMAP_TYPE_PNG),
wxDefaultPosition, dummySize);
m_pBtnSearchDir->SetBitmapDisabled(wxBitmap(prefix + wxT("folderdisabled.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchDir->SetBitmapSelected(wxBitmap(prefix + wxT("folderselected.png"), wxBITMAP_TYPE_PNG));
m_pBtnSearchDir->SetMinSize(dummySize);
set_properties();
do_layout();
// end wxGlade
}
void ReopenEditorConfDLg::SaveSettings()
{
ReopenEditor* plugin = (ReopenEditor*)Manager::Get()->GetPluginManager()->FindPluginByName(_T("ReopenEditor"));
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("editor"));
bool wasManaged = cfg->ReadBool(_T("/reopen_editor/managed"),true);
bool isManaged = XRCCTRL(*this, "rbReopenDockOrNot", wxRadioBox)->GetSelection() == 1;
if(wasManaged != isManaged)
{
cfg->Write(_T("/reopen_editor/managed"),isManaged);
plugin->SetManaged(isManaged);
plugin->ShowList();
}
}
void PlaceWindow(wxTopLevelWindow *w, cbPlaceDialogMode mode, bool enforce)
// TODO (thomas#1#): The non-Windows implementation is *pathetic*.
// However, I don't know how to do it well under GTK / X / Xinerama / whatever.
// Anyone?
{
int the_mode;
wxWindow* referenceWindow = Manager::Get()->GetAppWindow();
if(!referenceWindow) // let's not crash on shutdown
return;
if(!w)
cbThrow(_T("Passed NULL pointer to PlaceWindow."));
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
if(!enforce && cfg->ReadBool(_T("/dialog_placement/do_place")) == false)
return;
if(mode == pdlBest)
the_mode = cfg->ReadInt(_T("/dialog_placement/dialog_position"), (int) pdlCentre);
else
the_mode = (int) mode;
if(the_mode == pdlCentre || the_mode == pdlHead)
{
w->CentreOnScreen();
return;
}
else
{
wxRect windowRect = w->GetRect();
wxRect parentRect = referenceWindow->GetRect(); // poo again!
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
x1 = std::max(x1, parentRect.x);
x2 = std::min(x2, parentRect.GetRight());
y1 = std::max(y1, parentRect.y);
y2 = std::min(y2, parentRect.GetBottom());
w->SetSize(x1, y1, x2-x1, y2-y1, wxSIZE_ALLOW_MINUS_ONE);
}
}
void CodeBlocksApp::InitLocale()
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("app"));
wxString path(ConfigManager::GetDataFolder() + _T("/locale"));
if (cfg->ReadBool(_T("/locale/enable"), false) == false)
return;
wxString lang(cfg->Read(_T("/locale/language")));
wxLocale::AddCatalogLookupPathPrefix(path);
const wxLanguageInfo *info;
if (!lang.IsEmpty()) // Note: You can also write this line of code as !(!lang) from wx-2.9 onwards
info = wxLocale::FindLanguageInfo(lang);
else
info = wxLocale::GetLanguageInfo(wxLANGUAGE_DEFAULT);
if (info == nullptr) // should never happen, but who knows...
return;
m_locale.Init(info->Language);
path.Alloc(path.length() + 10);
path.Append(_T('/'));
path.Append(info->CanonicalName);
if ( !wxDirExists(path) )
return;
wxDir dir(path);
if (!dir.IsOpened())
return;
wxString moName;
if (dir.GetFirst(&moName, _T("*.mo"), wxDIR_FILES))
{
do
{
m_locale.AddCatalog(moName);
} while (dir.GetNext(&moName));
}
}
bool ThreadSearch::BuildToolBar(wxToolBar* toolBar)
{
if ( !IsAttached() || !toolBar )
return false;
m_pToolbar = toolBar;
m_pThreadSearchView->SetToolBar(toolBar);
const wxString &prefix = m_pThreadSearchView->GetImagePrefix();
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
if (cfg->ReadBool(_T("/environment/toolbar_size"),true))
m_pToolbar->SetToolBitmapSize(wxSize(16,16));
else
m_pToolbar->SetToolBitmapSize(wxSize(22,22));
m_pCboSearchExpr = new wxComboBox(toolBar, controlIDs.Get(ControlIDs::idCboSearchExpr),
wxEmptyString, wxDefaultPosition, wxSize(130, -1), 0, NULL, wxCB_DROPDOWN);
m_pCboSearchExpr->SetToolTip(_("Text to search"));
toolBar->AddControl(m_pCboSearchExpr);
toolBar->AddTool(controlIDs.Get(ControlIDs::idBtnSearch), _(""),
wxBitmap(prefix + wxT("findf.png"), wxBITMAP_TYPE_PNG),
wxBitmap(prefix + wxT("findfdisabled.png"), wxBITMAP_TYPE_PNG),
wxITEM_NORMAL, _("Run search"));
toolBar->AddTool(controlIDs.Get(ControlIDs::idBtnOptions), _(""),
wxBitmap(prefix + wxT("options.png"), wxBITMAP_TYPE_PNG),
wxBitmap(prefix + wxT("optionsdisabled.png"), wxBITMAP_TYPE_PNG),
wxITEM_NORMAL, _("Show options window"));
m_pThreadSearchView->UpdateOptionsButtonImage(m_FindData);
m_pCboSearchExpr->Append(m_pThreadSearchView->GetSearchHistory());
if ( m_pCboSearchExpr->GetCount() > 0 )
{
m_pCboSearchExpr->SetSelection(0);
}
toolBar->Realize();
#if wxCHECK_VERSION(2, 8, 0)
toolBar->SetInitialSize();
#else
toolBar->SetBestFittingSize();
#endif
return true;
}
void ParserBase::ReadOptions()
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("code_completion"));
// one-time default settings change: upgrade everyone
bool force_all_on = !cfg->ReadBool(_T("/parser_defaults_changed"), false);
if (force_all_on)
{
cfg->Write(_T("/parser_defaults_changed"), true);
cfg->Write(_T("/parser_follow_local_includes"), true);
cfg->Write(_T("/parser_follow_global_includes"), true);
cfg->Write(_T("/want_preprocessor"), true);
cfg->Write(_T("/parse_complex_macros"), true);
}
// Page "Code Completion"
m_Options.useSmartSense = cfg->ReadBool(_T("/use_SmartSense"), true);
m_Options.whileTyping = cfg->ReadBool(_T("/while_typing"), true);
m_Options.caseSensitive = cfg->ReadBool(_T("/case_sensitive"), false);
// Page "C / C++ parser"
m_Options.followLocalIncludes = cfg->ReadBool(_T("/parser_follow_local_includes"), true);
m_Options.followGlobalIncludes = cfg->ReadBool(_T("/parser_follow_global_includes"), true);
m_Options.wantPreprocessor = cfg->ReadBool(_T("/want_preprocessor"), true);
m_Options.parseComplexMacros = cfg->ReadBool(_T("/parse_complex_macros"), true);
// Page "Symbol browser"
m_BrowserOptions.showInheritance = cfg->ReadBool(_T("/browser_show_inheritance"), false);
m_BrowserOptions.expandNS = cfg->ReadBool(_T("/browser_expand_ns"), false);
m_BrowserOptions.treeMembers = cfg->ReadBool(_T("/browser_tree_members"), true);
// Token tree
m_BrowserOptions.displayFilter = (BrowserDisplayFilter)cfg->ReadInt(_T("/browser_display_filter"), bdfFile);
m_BrowserOptions.sortType = (BrowserSortType)cfg->ReadInt(_T("/browser_sort_type"), bstKind);
// Page "Documentation:
m_Options.storeDocumentation = cfg->ReadBool(_T("/use_documentation_helper"), false);
// force e-read of file types
ParserCommon::EFileType ft_dummy = ParserCommon::FileType(wxEmptyString, true);
wxUnusedVar(ft_dummy);
}
void EditorTweaks::OnAttach()
{
// do whatever initialization you need for your plugin
// NOTE: after this function, the inherited member variable
// m_IsAttached will be TRUE...
// You should check for it in other functions, because if it
// is FALSE, it means that the application did *not* "load"
// (see: does not need) this plugin...
Manager* pm = Manager::Get();
pm->RegisterEventSink(cbEVT_EDITOR_OPEN, new cbEventFunctor<EditorTweaks, CodeBlocksEvent>(this, &EditorTweaks::OnEditorOpen));
m_tweakmenu=NULL;
EditorManager* em = Manager::Get()->GetEditorManager();
for (int i=0;i<em->GetEditorsCount();i++)
{
cbEditor* ed=em->GetBuiltinEditor(i);
if (ed && ed->GetControl())
{
ed->GetControl()->SetOvertype(false);
ed->GetControl()->Connect(wxEVT_KEY_DOWN,(wxObjectEventFunction) (wxEventFunction) (wxCharEventFunction)&EditorTweaks::OnKeyPress,NULL,this);
ed->GetControl()->Connect(wxEVT_CHAR,(wxObjectEventFunction) (wxEventFunction) (wxCharEventFunction)&EditorTweaks::OnChar,NULL,this);
}
}
AlignerMenuEntry e;
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("EditorTweaks"));
for (int i = 0 ; i < cfg->ReadInt(_T("/aligner/saved_entries"),defaultStoredAlignerEntries) ; ++i)
{
e.MenuName = cfg->Read(wxString::Format(_T("/aligner/first_name_%d"),i),defaultNames[i]);
e.ArgumentString = cfg->Read(wxString::Format(_T("/aligner/first_argument_string_%d"),i) ,defaultStrings[i]);
e.UsageCount = 0;
e.id = wxNewId();
AlignerMenuEntries.push_back(e);
Connect(e.id, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(EditorTweaks::OnAlign) );
}
m_suppress_insert = cfg->ReadBool(wxT("/suppress_insert_key"), false);
m_convert_braces = cfg->ReadBool(wxT("/convert_braces"), false);
m_buffer_caret = -1;
}
void nsEnvVars::EnvVarsDebugLog(const wxChar* msg, ...)
{
// load and apply configuration (to application only)
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("envvars"));
if (!cfg)
return;
// get whether to print debug message to debug log or not
bool debug_log = cfg->ReadBool(_T("/debug_log"));
if (!debug_log)
return;
wxString log_msg;
va_list arg_list;
va_start(arg_list, msg);
log_msg = wxString::FormatV(msg, arg_list);
va_end(arg_list);
Manager::Get()->GetLogManager()->DebugLog(log_msg);
}// EnvVarsDebugLog
MiniStyledTextCtrl::MiniStyledTextCtrl(wxWindow* pParent, int id, const wxPoint& pos, const wxSize& size, long style):
cbStyledTextCtrl(pParent, id, pos, size, style)
{
Init();
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("editor"));
if (cfg->ReadBool(_T("/highlight_occurrence/enabled"), true))
{
const int theIndicator = 10;
wxColour highlightColour(Manager::Get()->GetColourManager()->GetColour(wxT("editor_highlight_occurrence")));
IndicatorSetStyle(theIndicator, wxSCI_INDIC_HIGHLIGHT);
IndicatorSetForeground(theIndicator, highlightColour );
#ifndef wxHAVE_RAW_BITMAP
IndicatorSetUnder(theIndicator,true);
#endif
}
const int thePermIndicator = 12;
IndicatorSetStyle(thePermIndicator, wxSCI_INDIC_HIGHLIGHT);
IndicatorSetForeground(thePermIndicator, wxColour(Manager::Get()->GetColourManager()->GetColour(wxT("editor_highlight_occurrence_permanently"))) );
#ifndef wxHAVE_RAW_BITMAP
IndicatorSetUnder(thePermIndicator,true);
#endif
const int theFindFoudIndicator = 21;
IndicatorSetStyle(theFindFoudIndicator, wxSCI_INDIC_HIGHLIGHT);
IndicatorSetForeground(theFindFoudIndicator, wxColour(cfg->ReadColour(_T("/incremental_search/text_found_colour"), wxColour(160, 32, 240))) );
#ifndef wxHAVE_RAW_BITMAP
IndicatorSetUnder(theFindFoudIndicator,true);
#endif
const int theFindHighlightIndicator = 22;
IndicatorSetStyle(theFindHighlightIndicator, wxSCI_INDIC_HIGHLIGHT);
IndicatorSetForeground(theFindHighlightIndicator, wxColour(cfg->ReadColour(_T("/incremental_search/highlight_colour"), wxColour(255, 165, 0))) );
#ifndef wxHAVE_RAW_BITMAP
IndicatorSetUnder(theFindHighlightIndicator,true);
#endif
}
void MiniStyledTextCtrl::SetMarker()
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("editor"));
bool inverse = cfg->ReadBool(_T("/mini_doc/inverse_designator"), false);
Freeze();
wxColor color = Manager::Get()->GetColourManager()->GetColour(wxT("minidoc_background"));
MarkerDeleteAll(GetOurMarkerNumber());
MarkerSetBackground(GetOurMarkerNumber(), color);
if (inverse)
{
for (int l = visibleFrom; l < visibleFrom+visibleLength ; ++l)
MarkerAdd(l, GetOurMarkerNumber());
}
else
{
for (int l = 0; l < visibleFrom ; ++l)
MarkerAdd(l, GetOurMarkerNumber());
for (int l = visibleFrom+visibleLength; l < GetLineCount() ; ++l)
MarkerAdd(l, GetOurMarkerNumber());
}
Thaw();
}
bool cbDebuggerCommonConfig::GetFlag(Flags flag)
{
ConfigManager *c = Manager::Get()->GetConfigManager(wxT("debugger_common"));
switch (flag)
{
case AutoBuild:
return c->ReadBool(wxT("/common/auto_build"), true);
case AutoSwitchFrame:
return c->ReadBool(wxT("/common/auto_switch_frame"), true);
case ShowDebuggersLog:
return c->ReadBool(wxT("/common/debug_log"), false);
case JumpOnDoubleClick:
return c->ReadBool(wxT("/common/jump_on_double_click"), false);
case RequireCtrlForTooltips:
return c->ReadBool(wxT("/common/require_ctrl_for_tooltips"), false);
case ShowTemporaryBreakpoints:
return c->ReadBool(wxT("/common/show_temporary_breakpoints"), false);
default:
return false;
}
}
void Execution::LoadSettings()
{
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("HeaderFixup"));
if (!cfg)
return;
if (m_Scope)
m_Scope->SetSelection(cfg->ReadInt(_T("/scope"), 0));
if (m_Options)
m_Options->SetSelection(cfg->ReadInt(_T("/options"), 1));
if (m_Ignore)
m_Ignore->SetValue(cfg->ReadBool(_T("/ignore")));
if (m_FwdDecl)
m_FwdDecl->SetValue(cfg->ReadBool(_T("/fwd_decl")));
if (m_ObsoleteLog)
m_ObsoleteLog->SetValue(cfg->ReadBool(_T("/obsolete_log")));
if (m_FileType)
m_FileType->SetSelection(cfg->ReadInt(_T("/file_type"), 2));
if (m_Protocol)
m_Protocol->SetValue(cfg->ReadBool(_T("/protocol")));
if (m_Simulation)
m_Simulation->SetValue(cfg->ReadBool(_T("/simulation")));
if (m_Sets)
{
for (size_t i=0; i<m_Sets->GetCount(); i++)
{
wxString Sel; Sel.Printf(_T("/selection%lu"), static_cast<unsigned long>(i));
m_Sets->Check(i, cfg->ReadBool(Sel, true));
}
}
}// LoadSettings
EnvironmentSettingsDlg::EnvironmentSettingsDlg(wxWindow* parent, wxAuiDockArt* art)
: m_pArt(art)
{
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
ConfigManager *pcfg = Manager::Get()->GetConfigManager(_T("project_manager"));
ConfigManager *mcfg = Manager::Get()->GetConfigManager(_T("message_manager"));
ConfigManager *acfg = Manager::Get()->GetConfigManager(_T("an_dlg"));
wxXmlResource::Get()->LoadObject(this, parent, _T("dlgEnvironmentSettings"),_T("wxScrollingDialog"));
int sel = cfg->ReadInt(_T("/environment/settings_size"), 0);
wxListbook* lb = XRCCTRL(*this, "nbMain", wxListbook);
SetSettingsIconsStyle(lb->GetListView(), (SettingsIconsStyle)sel);
LoadListbookImages();
// this setting is not available under wxGTK
#ifndef __WXMSW__
XRCCTRL(*this, "rbSettingsIconsSize", wxRadioBox)->Enable(false);
#endif
// tab "General"
XRCCTRL(*this, "chkSingleInstance", wxCheckBox)->SetValue(cfg->ReadBool(_T("/environment/single_instance"), true));
#ifdef __WXMSW__
static_cast<wxStaticBoxSizer*>(XRCCTRL(*this, "chkUseIPC", wxCheckBox)->GetContainingSizer())->GetStaticBox()->SetLabel(_("Dynamic Data Exchange (will take place after restart)"));
#endif
bool useIpc = cfg->ReadBool(_T("/environment/use_ipc"), true);
XRCCTRL(*this, "chkUseIPC", wxCheckBox)->SetValue(useIpc);
XRCCTRL(*this, "chkRaiseViaIPC", wxCheckBox)->SetValue(cfg->ReadBool(_T("/environment/raise_via_ipc"), true));
XRCCTRL(*this, "chkRaiseViaIPC", wxCheckBox)->Enable(useIpc);
XRCCTRL(*this, "chkAssociations", wxCheckBox)->SetValue(cfg->ReadBool(_T("/environment/check_associations"), true));
XRCCTRL(*this, "chkModifiedFiles", wxCheckBox)->SetValue(cfg->ReadBool(_T("/environment/check_modified_files"), true));
XRCCTRL(*this, "chkInvalidTargets", wxCheckBox)->SetValue(cfg->ReadBool(_T("/environment/ignore_invalid_targets"), true));
XRCCTRL(*this, "rbAppStart", wxRadioBox)->SetSelection(cfg->ReadBool(_T("/environment/blank_workspace"), true) ? 1 : 0);
wxTextCtrl* txt = XRCCTRL(*this, "txtConsoleTerm", wxTextCtrl);
txt->SetValue(cfg->Read(_T("/console_terminal"), DEFAULT_CONSOLE_TERM));
#ifdef __WXMSW__
// under win32, this option is not needed, so disable it
txt->Enable(false);
#endif
txt = XRCCTRL(*this, "txtConsoleShell", wxTextCtrl);
txt->SetValue(cfg->Read(_T("/console_shell"), DEFAULT_CONSOLE_SHELL));
#ifdef __WXMSW__
// under win32, this option is not needed, so disable it
txt->Enable(false);
#endif
#if defined __WXMSW__
const wxString openFolderCmds = _T("explorer.exe /select,");
#elif defined __WXMAC__
const wxString openFolderCmds = _T("open -R");
#else
const wxString openFolderCmds = _T("xdg-open");
#endif
XRCCTRL(*this, "txtOpenFolder", wxTextCtrl)->SetValue(cfg->Read(_T("/open_containing_folder"), openFolderCmds));
// tab "View"
bool do_place = cfg->ReadBool(_T("/dialog_placement/do_place"), false);
XRCCTRL(*this, "chkDoPlace", wxCheckBox)->SetValue(do_place);
XRCCTRL(*this, "chkPlaceHead", wxCheckBox)->SetValue(cfg->ReadInt(_T("/dialog_placement/dialog_position"), 0) == pdlHead ? 1 : 0);
XRCCTRL(*this, "chkPlaceHead", wxCheckBox)->Enable(do_place);
XRCCTRL(*this, "rbProjectOpen", wxRadioBox)->SetSelection(pcfg->ReadInt(_T("/open_files"), 1));
XRCCTRL(*this, "rbSettingsIconsSize", wxRadioBox)->SetSelection(cfg->ReadInt(_T("/environment/settings_size"), 0));
XRCCTRL(*this, "spnLogFontSize", wxSpinCtrl)->SetValue(mcfg->ReadInt(_T("/log_font_size"), 8));
bool en = mcfg->ReadBool(_T("/auto_hide"), false);
XRCCTRL(*this, "chkAutoHideMessages", wxCheckBox)->SetValue(en);
XRCCTRL(*this, "chkAutoShowMessagesOnSearch", wxCheckBox)->SetValue(mcfg->ReadBool(_T("/auto_show_search"), true));
XRCCTRL(*this, "chkAutoShowMessagesOnWarn", wxCheckBox)->SetValue(mcfg->ReadBool(_T("/auto_show_build_warnings"), true));
XRCCTRL(*this, "chkAutoShowMessagesOnErr", wxCheckBox)->SetValue(mcfg->ReadBool(_T("/auto_show_build_errors"), true));
XRCCTRL(*this, "chkAutoShowMessagesOnSearch", wxCheckBox)->Enable(en);
XRCCTRL(*this, "chkAutoShowMessagesOnWarn", wxCheckBox)->Enable(en);
XRCCTRL(*this, "chkAutoShowMessagesOnErr", wxCheckBox)->Enable(en);
XRCCTRL(*this, "chkSaveSelectionChangeInMP", wxCheckBox)->SetValue(mcfg->ReadBool(_T("/save_selection_change_in_mp"), true));
en = cfg->ReadBool(_T("/environment/view/dbl_clk_maximize"), true);
XRCCTRL(*this, "chkDblClkMaximizes", wxCheckBox)->SetValue(en);
int idx = Manager::Get()->GetAppFrame()->GetMenuBar()->FindMenu(_("&View"));
if (idx != wxNOT_FOUND)
{
wxMenu* menuView = Manager::Get()->GetAppFrame()->GetMenuBar()->GetMenu(idx);
int sub_idx = menuView->FindItem(_("Perspectives"));
if (sub_idx != wxNOT_FOUND)
{
wxMenu* menuLayouts = menuView->FindItem(sub_idx)->GetSubMenu();
if (menuLayouts)
{
wxMenuItemList& items = menuLayouts->GetMenuItems();
for (size_t i = 0; i < items.GetCount() && ! items[i]->IsSeparator() ; ++i)
{
#if wxCHECK_VERSION(2,8,5)
XRCCTRL(*this, "choLayoutToToggle", wxChoice)->Append(items[i]->GetLabelText(items[i]->GetItemLabelText()));
#else
XRCCTRL(*this, "choLayoutToToggle", wxChoice)->Append(items[i]->GetLabelFromText(items[i]->GetLabel()));
#endif
}
}
}
}
sel = XRCCTRL(*this, "choLayoutToToggle", wxChoice)->FindString( cfg->Read(_T("/environment/view/layout_to_toggle"),cfg->Read(_T("/main_frame/layout/default"))));
XRCCTRL(*this, "choLayoutToToggle", wxChoice)->SetSelection(sel != wxNOT_FOUND ? sel : 0);
XRCCTRL(*this, "choLayoutToToggle", wxChoice)->Enable(en);
bool i18n=cfg->ReadBool(_T("/locale/enable"), false);
XRCCTRL(*this, "chkI18N", wxCheckBox)->SetValue(i18n);
wxDir locDir(ConfigManager::GetDataFolder() + _T("/locale"));
wxString locFName;
if(locDir.IsOpened() && locDir.GetFirst(&locFName/*, wxEmptyString, wxDIR_DIRS*/))
do
{
const wxLanguageInfo *info = wxLocale::FindLanguageInfo(locFName);
if(info)
{
XRCCTRL(*this, "cbxLanguage", wxComboBox)->Append(info->Description);
}
}while(locDir.GetNext(&locFName));
XRCCTRL(*this, "cbxLanguage", wxComboBox)->Enable(i18n);
const wxLanguageInfo *info = wxLocale::FindLanguageInfo(cfg->Read(_T("/locale/language")));
if(info)
XRCCTRL(*this, "cbxLanguage", wxComboBox)->SetStringSelection(info->Description);
// tab "Notebook"
XRCCTRL(*this, "chkStackedBasedTabSwitching", wxCheckBox)->SetValue(cfg->ReadBool(_T("/environment/tabs_stacked_based_switching"), 0));
bool enableTabMousewheel = cfg->ReadBool(_T("/environment/tabs_use_mousewheel"),true);
bool modToAdvance = cfg->ReadBool(_T("/environment/tabs_mousewheel_advance"),false);
XRCCTRL(*this, "chkNBUseMousewheel", wxCheckBox)->SetValue(enableTabMousewheel);
XRCCTRL(*this, "rbNBModToAdvance", wxRadioButton)->SetValue(modToAdvance);
XRCCTRL(*this, "rbNBModToMove", wxRadioButton)->SetValue(!modToAdvance);
XRCCTRL(*this, "chkNBInvertAdvance", wxCheckBox)->SetValue(cfg->ReadBool(_T("/environment/tabs_invert_advance"),false));
XRCCTRL(*this, "chkNBInvertMove", wxCheckBox)->SetValue(cfg->ReadBool(_T("/environment/tabs_invert_move"),false));
XRCCTRL(*this, "txtMousewheelModifier", wxTextCtrl)->SetValue(cfg->Read(_T("/environment/tabs_mousewheel_modifier"),_T("Ctrl")));
XRCCTRL(*this, "txtMousewheelModifier", wxTextCtrl)->Connect(wxEVT_KEY_DOWN, wxKeyEventHandler(EnvironmentSettingsDlg::OnMousewheelModifier));
XRCCTRL(*this, "rbNBModToAdvance", wxRadioButton)->Enable(enableTabMousewheel);
XRCCTRL(*this, "rbNBModToMove", wxRadioButton)->Enable(enableTabMousewheel);
XRCCTRL(*this, "chkNBInvertAdvance", wxCheckBox)->Enable(enableTabMousewheel);
XRCCTRL(*this, "chkNBInvertMove", wxCheckBox)->Enable(enableTabMousewheel);
XRCCTRL(*this, "txtMousewheelModifier", wxTextCtrl)->Enable(enableTabMousewheel);
bool useToolTips = cfg->ReadBool(_T("/environment/tabs_use_tooltips"),true);
XRCCTRL(*this, "chkNBUseToolTips", wxCheckBox)->SetValue(useToolTips);
XRCCTRL(*this, "spnNBDwellTime", wxSpinCtrl)->SetValue(cfg->ReadInt(_T("/environment/tabs_dwell_time"), 1000));
XRCCTRL(*this, "spnNBDwellTime", wxSpinCtrl)->Enable(useToolTips);
// tab "Docking"
/*
XRCCTRL(*this, "spnAuiBorder", wxSpinCtrl)->SetValue(cfg->ReadInt(_T("/environment/aui/border_size"), m_pArt->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE)));
XRCCTRL(*this, "spnAuiSash", wxSpinCtrl)->SetValue(cfg->ReadInt(_T("/environment/aui/sash_size"), m_pArt->GetMetric(wxAUI_DOCKART_SASH_SIZE)));
XRCCTRL(*this, "spnAuiCaption", wxSpinCtrl)->SetValue(cfg->ReadInt(_T("/environment/aui/caption_size"), m_pArt->GetMetric(wxAUI_DOCKART_CAPTION_SIZE)));
XRCCTRL(*this, "btnAuiActiveCaptionColour", wxButton)->SetBackgroundColour(cfg->ReadColour(_T("/environment/aui/active_caption_colour"), m_pArt->GetColour(wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR)));
XRCCTRL(*this, "btnAuiActiveCaptionGradientColour", wxButton)->SetBackgroundColour(cfg->ReadColour(_T("/environment/aui/active_caption_gradient_colour"), m_pArt->GetColour(wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR)));
XRCCTRL(*this, "btnAuiActiveCaptionTextColour", wxButton)->SetBackgroundColour(cfg->ReadColour(_T("/environment/aui/active_caption_text_colour"), m_pArt->GetColour(wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR)));
XRCCTRL(*this, "btnAuiInactiveCaptionColour", wxButton)->SetBackgroundColour(cfg->ReadColour(_T("/environment/aui/inactive_caption_colour"), m_pArt->GetColour(wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR)));
XRCCTRL(*this, "btnAuiInactiveCaptionGradientColour", wxButton)->SetBackgroundColour(cfg->ReadColour(_T("/environment/aui/inactive_caption_gradient_colour"), m_pArt->GetColour(wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR)));
XRCCTRL(*this, "btnAuiInactiveCaptionTextColour", wxButton)->SetBackgroundColour(cfg->ReadColour(_T("/environment/aui/inactive_caption_text_colour"), m_pArt->GetColour(wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR)));
*/
// tab "Dialogs"
wxCheckListBox* clb = XRCCTRL(*this, "chkDialogs", wxCheckListBox);
clb->Clear();
ConfigManagerContainer::StringSet dialogs = acfg->ReadSSet(_T("/disabled"));
for (ConfigManagerContainer::StringSet::iterator i = dialogs.begin(); i != dialogs.end(); ++i)
clb->Append(*i);
// tab "Network"
XRCCTRL(*this, "txtProxy", wxTextCtrl)->SetValue(cfg->Read(_T("/network_proxy")));
// disable some windows-only settings, in other platforms
#ifndef __WXMSW__
XRCCTRL(*this, "chkAssociations", wxCheckBox)->Enable(false);
XRCCTRL(*this, "btnSetAssocs", wxButton)->Enable(false);
XRCCTRL(*this, "btnManageAssocs", wxButton)->Enable(false);
#endif
// add all plugins configuration panels
AddPluginPanels();
// make sure everything is laid out properly
GetSizer()->SetSizeHints(this);
CentreOnParent();
}
wxsNewWindowDlg::wxsNewWindowDlg(wxWindow* parent,const wxString& ResType,wxsProject* Project):
m_SourceNotTouched(true),
m_HeaderNotTouched(true),
m_XrcNotTouched(true),
m_BlockText(false),
m_AdvOpsShown(true),
m_Type(ResType),
m_Project(Project)
{
//(*Initialize(wxsNewWindowDlg)
wxStaticText* StaticText10;
wxStaticText* StaticText9;
wxStaticText* StaticText2;
wxStaticText* StaticText6;
wxStaticText* StaticText8;
wxStaticText* StaticText11;
wxStaticText* StaticText1;
wxStaticText* StaticText3;
wxStaticText* StaticText5;
wxStaticText* StaticText7;
wxStaticText* StaticText4;
Create(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE, _T("wxID_ANY"));
m_RootSizer = new wxBoxSizer(wxVERTICAL);
StaticBoxSizer3 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Options"));
FlexGridSizer1 = new wxFlexGridSizer(0, 2, 5, 5);
FlexGridSizer1->AddGrowableCol(1);
StaticText1 = new wxStaticText(this, wxID_ANY, _("Class Name:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer1->Add(StaticText1, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_Class = new wxTextCtrl(this, ID_TEXTCTRL1, wxEmptyString, wxDefaultPosition, wxSize(80,-1), 0, wxDefaultValidator, _T("ID_TEXTCTRL1"));
FlexGridSizer1->Add(m_Class, 0, wxEXPAND|wxALIGN_LEFT|wxALIGN_TOP, 5);
StaticText2 = new wxStaticText(this, wxID_ANY, _("Header file:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer1->Add(StaticText2, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_Header = new wxTextCtrl(this, ID_TEXTCTRL2, wxEmptyString, wxDefaultPosition, wxSize(80,-1), 0, wxDefaultValidator, _T("ID_TEXTCTRL2"));
FlexGridSizer1->Add(m_Header, 0, wxEXPAND|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
StaticText3 = new wxStaticText(this, wxID_ANY, _("Source file:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer1->Add(StaticText3, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_Source = new wxTextCtrl(this, ID_TEXTCTRL3, wxEmptyString, wxDefaultPosition, wxSize(80,-1), 0, wxDefaultValidator, _T("ID_TEXTCTRL3"));
FlexGridSizer1->Add(m_Source, 0, wxEXPAND|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_UseXrc = new wxCheckBox(this, ID_CHECKBOX1, _("Xrc File:"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX1"));
m_UseXrc->SetValue(false);
FlexGridSizer1->Add(m_UseXrc, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_Xrc = new wxTextCtrl(this, ID_TEXTCTRL4, wxEmptyString, wxDefaultPosition, wxSize(80,-1), 0, wxDefaultValidator, _T("ID_TEXTCTRL4"));
FlexGridSizer1->Add(m_Xrc, 0, wxEXPAND|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer1->Add(10,6,1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_XRCAutoload = new wxCheckBox(this, ID_CHECKBOX3, _("Add XRC file to autoload list"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX3"));
m_XRCAutoload->SetValue(false);
m_XRCAutoload->Disable();
FlexGridSizer1->Add(m_XRCAutoload, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StaticBoxSizer3->Add(FlexGridSizer1, 1, wxALL|wxEXPAND|wxALIGN_LEFT|wxALIGN_TOP, 0);
m_RootSizer->Add(StaticBoxSizer3, 0, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
m_AdvOps = new wxButton(this, ID_BUTTON1, _("+ Advanced options"), wxDefaultPosition, wxDefaultSize, wxBU_LEFT|wxNO_BORDER, wxDefaultValidator, _T("ID_BUTTON1"));
m_RootSizer->Add(m_AdvOps, 0, wxLEFT|wxRIGHT|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
m_AdvancedOptionsSizer = new wxStaticBoxSizer(wxVERTICAL, this, wxEmptyString);
FlexGridSizer2 = new wxFlexGridSizer(0, 2, 5, 5);
FlexGridSizer2->AddGrowableCol(1);
m_UsePCH = new wxCheckBox(this, ID_CHECKBOX2, _("Use PCH:"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX2"));
m_UsePCH->SetValue(false);
FlexGridSizer2->Add(m_UsePCH, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_Pch = new wxComboBox(this, ID_COMBOBOX1, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, 0, 0, wxDefaultValidator, _T("ID_COMBOBOX1"));
FlexGridSizer2->Add(m_Pch, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
BoxSizer1 = new wxBoxSizer(wxHORIZONTAL);
BoxSizer1->Add(21,16,0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
StaticText11 = new wxStaticText(this, wxID_ANY, _("PCH guard define:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
BoxSizer1->Add(StaticText11, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 0);
FlexGridSizer2->Add(BoxSizer1, 0, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
m_PchGuard = new wxTextCtrl(this, ID_TEXTCTRL8, _("WX_PRECOMP"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL8"));
FlexGridSizer2->Add(m_PchGuard, 0, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
m_UseInitFunc = new wxCheckBox(this, ID_CHECKBOX4, _("Init code in function:"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX4"));
m_UseInitFunc->SetValue(false);
FlexGridSizer2->Add(m_UseInitFunc, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_InitFunc = new wxTextCtrl(this, ID_TEXTCTRL5, _("BuildContent"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL5"));
m_InitFunc->Disable();
FlexGridSizer2->Add(m_InitFunc, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StaticText4 = new wxStaticText(this, wxID_ANY, _("Base class name:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer2->Add(StaticText4, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_BaseClass = new wxTextCtrl(this, ID_TEXTCTRL6, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL6"));
FlexGridSizer2->Add(m_BaseClass, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StaticText7 = new wxStaticText(this, wxID_ANY, _("Scopes:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer2->Add(StaticText7, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 0);
FlexGridSizer4 = new wxFlexGridSizer(0, 3, 0, 5);
FlexGridSizer4->AddGrowableCol(0);
FlexGridSizer4->AddGrowableCol(1);
FlexGridSizer4->AddGrowableCol(2);
StaticText8 = new wxStaticText(this, wxID_ANY, _("IDs:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer4->Add(StaticText8, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StaticText9 = new wxStaticText(this, wxID_ANY, _("Members:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer4->Add(StaticText9, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StaticText10 = new wxStaticText(this, wxID_ANY, _("Handlers:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer4->Add(StaticText10, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_ScopeIds = new wxButton(this, ID_BUTTON2, _("Public"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON2"));
FlexGridSizer4->Add(m_ScopeIds, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_ScopeMembers = new wxButton(this, ID_BUTTON3, _("Public"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON3"));
FlexGridSizer4->Add(m_ScopeMembers, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_ScopeHandlers = new wxButton(this, ID_BUTTON4, _("Public"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON4"));
FlexGridSizer4->Add(m_ScopeHandlers, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer2->Add(FlexGridSizer4, 0, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
StaticText5 = new wxStaticText(this, wxID_ANY, _("Constructor arguments:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer2->Add(StaticText5, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer3 = new wxFlexGridSizer(0, 2, 0, 10);
FlexGridSizer3->AddGrowableCol(0);
m_CtorParent = new wxCheckBox(this, ID_CHECKBOX5, _("Parent"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX5"));
m_CtorParent->SetValue(true);
FlexGridSizer3->Add(m_CtorParent, 0, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_CtorParentDef = new wxCheckBox(this, ID_CHECKBOX9, _("Def. value"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX9"));
m_CtorParentDef->SetValue(false);
FlexGridSizer3->Add(m_CtorParentDef, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_CtorId = new wxCheckBox(this, ID_CHECKBOX6, _("Id"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX6"));
m_CtorId->SetValue(true);
FlexGridSizer3->Add(m_CtorId, 0, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_CtorIdDef = new wxCheckBox(this, ID_CHECKBOX10, _("Def. value"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX10"));
m_CtorIdDef->SetValue(true);
FlexGridSizer3->Add(m_CtorIdDef, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_CtorPos = new wxCheckBox(this, ID_CHECKBOX7, _("Position"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX7"));
m_CtorPos->SetValue(false);
FlexGridSizer3->Add(m_CtorPos, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_CtorPosDef = new wxCheckBox(this, ID_CHECKBOX11, _("Def. value"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX11"));
m_CtorPosDef->SetValue(true);
m_CtorPosDef->Disable();
FlexGridSizer3->Add(m_CtorPosDef, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_CtorSize = new wxCheckBox(this, ID_CHECKBOX8, _("Size"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX8"));
m_CtorSize->SetValue(false);
FlexGridSizer3->Add(m_CtorSize, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_CtorSizeDef = new wxCheckBox(this, ID_CHECKBOX12, _("Def. value"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX12"));
m_CtorSizeDef->SetValue(true);
m_CtorSizeDef->Disable();
FlexGridSizer3->Add(m_CtorSizeDef, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
FlexGridSizer2->Add(FlexGridSizer3, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StaticText6 = new wxStaticText(this, wxID_ANY, _("Custom arguments:"), wxDefaultPosition, wxDefaultSize, 0, _T("wxID_ANY"));
FlexGridSizer2->Add(StaticText6, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_CtorCustom = new wxTextCtrl(this, ID_TEXTCTRL7, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL7"));
FlexGridSizer2->Add(m_CtorCustom, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_AdvancedOptionsSizer->Add(FlexGridSizer2, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_UseFwdDecl = new wxCheckBox(this, ID_CHECKBOX14, _("Use forward declarations"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX14"));
m_UseFwdDecl->SetValue(false);
m_AdvancedOptionsSizer->Add(m_UseFwdDecl, 0, wxLEFT|wxRIGHT|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_UseI18n = new wxCheckBox(this, ID_CHECKBOX15, _("Use internationalize"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX15"));
m_UseI18n->SetValue(true);
m_AdvancedOptionsSizer->Add(m_UseI18n, 0, wxALL|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
m_AddWxs = new wxCheckBox(this, ID_CHECKBOX13, _("Add wxs file to project"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX13"));
m_AddWxs->SetValue(true);
m_AdvancedOptionsSizer->Add(m_AddWxs, 0, wxBOTTOM|wxLEFT|wxRIGHT|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_RootSizer->Add(m_AdvancedOptionsSizer, 0, wxLEFT|wxRIGHT|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_RootSizer->Add(300,5,0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
StdDialogButtonSizer1 = new wxStdDialogButtonSizer();
StdDialogButtonSizer1->AddButton(new wxButton(this, wxID_OK, wxEmptyString));
StdDialogButtonSizer1->AddButton(new wxButton(this, wxID_CANCEL, wxEmptyString));
StdDialogButtonSizer1->Realize();
m_RootSizer->Add(StdDialogButtonSizer1, 0, wxBOTTOM|wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
SetSizer(m_RootSizer);
m_RootSizer->Fit(this);
m_RootSizer->SetSizeHints(this);
Center();
Connect(ID_TEXTCTRL1,wxEVT_COMMAND_TEXT_UPDATED,(wxObjectEventFunction)&wxsNewWindowDlg::OnClassChanged);
Connect(ID_TEXTCTRL2,wxEVT_COMMAND_TEXT_UPDATED,(wxObjectEventFunction)&wxsNewWindowDlg::OnHeaderChanged);
Connect(ID_TEXTCTRL3,wxEVT_COMMAND_TEXT_UPDATED,(wxObjectEventFunction)&wxsNewWindowDlg::OnSourceChanged);
Connect(ID_CHECKBOX1,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnUseXrcChange);
Connect(ID_TEXTCTRL4,wxEVT_COMMAND_TEXT_UPDATED,(wxObjectEventFunction)&wxsNewWindowDlg::OnXrcChanged);
Connect(ID_BUTTON1,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnAdvOpsClick);
Connect(ID_CHECKBOX2,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnUsePCHClick);
Connect(ID_CHECKBOX4,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnUseInitFuncClick);
Connect(ID_BUTTON2,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnScopeIdsClick);
Connect(ID_BUTTON3,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnScopeMembersClick);
Connect(ID_BUTTON4,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnScopeHandlersClick);
Connect(ID_CHECKBOX5,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorParentClick);
Connect(ID_CHECKBOX9,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorParentDefClick);
Connect(ID_CHECKBOX6,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorIdClick);
Connect(ID_CHECKBOX10,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorIdDefClick);
Connect(ID_CHECKBOX7,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorPosClick);
Connect(ID_CHECKBOX11,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorPosDefClick);
Connect(ID_CHECKBOX8,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorSizeClick);
Connect(ID_CHECKBOX12,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorSizeDefClick);
//*)
ConfigManager* Cfg = Manager::Get()->GetConfigManager(_T("wxsmith"));
m_BlockText = true;
m_SourceDirectory = Cfg->Read(_T("/newresource/sourcedirectory"),_T(""));
wxString StrippedName = ResType.Mid(2);
wxString ResName = wxString::Format(_("New%s"),StrippedName.c_str());
m_Class->SetValue(ResName);
m_Source->SetValue(m_SourceDirectory + ResName+_T(".cpp"));
m_Header->SetValue(m_SourceDirectory + ResName+_T(".h"));
m_Xrc ->SetValue(m_SourceDirectory + ResName+_T(".xrc"));
m_Xrc->Disable();
SetTitle(wxString::Format(_("New %s resource"),ResType.c_str()));
DetectPchFile();
m_BaseClass->SetValue(ResType);
wxCommandEvent event;
OnAdvOpsClick(event);
Center();
m_AppManaged =
m_Project->GetGUI() &&
m_Project->GetGUI()->GetName()==_T("wxWidgets") &&
m_Project->GetGUI()->CheckIfApplicationManaged();
m_XRCAutoload->SetValue(m_AppManaged);
m_UseInitFunc->SetValue(Cfg->ReadBool(_T("/newresource/useinitfunc"),m_UseInitFunc->GetValue()));
m_InitFunc->Enable(m_UseInitFunc->GetValue());
m_InitFunc->SetValue(Cfg->Read(_T("/newresource/initfunc"),m_InitFunc->GetValue()));
m_CtorParent->SetValue(Cfg->ReadBool(_T("/newresource/ctorparent"),m_CtorParent->GetValue()));
m_CtorParentDef->Enable(m_CtorParent->GetValue());
m_CtorParentDef->SetValue(Cfg->ReadBool(_T("/newresource/ctorparentdef"),m_CtorParentDef->GetValue()));
m_CtorId->SetValue(Cfg->ReadBool(_T("/newresource/ctorid"),m_CtorId->GetValue()));
m_CtorIdDef->Enable(m_CtorId->GetValue());
m_CtorIdDef->SetValue(Cfg->ReadBool(_T("/newresource/ctorid"),m_CtorIdDef->GetValue()));
m_CtorPos->SetValue(Cfg->ReadBool(_T("/newresource/ctorpos"),m_CtorPos->GetValue()));
m_CtorPosDef->Enable(m_CtorPos->GetValue());
m_CtorPosDef->SetValue(Cfg->ReadBool(_T("/newresource/ctorpos"),m_CtorPosDef->GetValue()));
m_CtorSize->SetValue(Cfg->ReadBool(_T("/newresource/ctorsize"),m_CtorSize->GetValue()));
m_CtorSizeDef->Enable(m_CtorSize->GetValue());
m_CtorSizeDef->SetValue(Cfg->ReadBool(_T("/newresource/ctorsize"),m_CtorSizeDef->GetValue()));
m_UseXrc->SetValue(Cfg->ReadBool(_T("/newresource/usexrc"),m_UseXrc->GetValue()));
m_Xrc->Enable(m_UseXrc->GetValue());
m_XRCAutoload->SetValue(Cfg->ReadBool(_T("/newresource/xrcautoloag"),m_XRCAutoload->GetValue()));
m_AddWxs->SetValue(Cfg->ReadBool(_T("/newresource/addwxs"),m_AddWxs->GetValue()));
m_ScopeIdsVal = (wxsItemRes::NewResourceParams::Scope)Cfg->ReadInt(_T("/newresource/scopeids"),(int)wxsItemRes::NewResourceParams::Protected);
m_ScopeMembersVal = (wxsItemRes::NewResourceParams::Scope)Cfg->ReadInt(_T("/newresource/scopemembers"),(int)wxsItemRes::NewResourceParams::Public);
m_ScopeHandlersVal = (wxsItemRes::NewResourceParams::Scope)Cfg->ReadInt(_T("/newresource/scopehandlers"),(int)wxsItemRes::NewResourceParams::Private);
m_UseFwdDecl->SetValue(Cfg->ReadBool(_T("/newresource/usefwddecl"),m_UseFwdDecl->GetValue()));
m_UseI18n->SetValue(Cfg->ReadBool(_T("/newresource/usei18n"),m_UseI18n->GetValue()));
m_PchGuard->SetValue(Cfg->Read(_T("/newresource/pchguard"),m_PchGuard->GetValue()));
UpdateScopeButtons();
OnUseXrcChange(event);
m_BlockText = false;
}
void AstyleConfigDlg::LoadSettings()
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("astyle"));
int style = cfg->ReadInt(_T("/style"), 0);
XRCCTRL(*this, "spnIndentation", wxSpinCtrl)->SetValue(cfg->ReadInt(_T("/indentation"), 4));
XRCCTRL(*this, "chkUseTab", wxCheckBox)->SetValue(cfg->ReadBool(_T("/use_tabs"), false));
XRCCTRL(*this, "chkForceUseTabs", wxCheckBox)->SetValue(cfg->ReadBool(_T("/force_tabs"), false));
XRCCTRL(*this, "chkIndentClasses", wxCheckBox)->SetValue(cfg->ReadBool(_T("/indent_classes"), false));
XRCCTRL(*this, "chkIndentSwitches", wxCheckBox)->SetValue(cfg->ReadBool(_T("/indent_switches"), false));
XRCCTRL(*this, "chkIndentCase", wxCheckBox)->SetValue(cfg->ReadBool(_T("/indent_case"), false));
XRCCTRL(*this, "chkIndentBrackets", wxCheckBox)->SetValue(cfg->ReadBool(_T("/indent_brackets"), false));
XRCCTRL(*this, "chkIndentBlocks", wxCheckBox)->SetValue(cfg->ReadBool(_T("/indent_blocks"), false));
XRCCTRL(*this, "chkIndentNamespaces", wxCheckBox)->SetValue(cfg->ReadBool(_T("/indent_namespaces"), false));
XRCCTRL(*this, "chkIndentLabels", wxCheckBox)->SetValue(cfg->ReadBool(_T("/indent_labels"), false));
XRCCTRL(*this, "chkIndentPreprocessor", wxCheckBox)->SetValue(cfg->ReadBool(_T("/indent_preprocessor"), false));
XRCCTRL(*this, "chkIndentCol1Comments", wxCheckBox)->SetValue(cfg->ReadBool(_T("/indent_col1_comments"), false));
XRCCTRL(*this, "cmbPointerAlign", wxComboBox)->SetValue(cfg->Read(_T("/pointer_align"), _T("None")));
XRCCTRL(*this, "chkBreakClosing", wxCheckBox)->SetValue(cfg->ReadBool(_T("/break_closing"), false));
XRCCTRL(*this, "chkBreakBlocks", wxCheckBox)->SetValue(cfg->ReadBool(_T("/break_blocks"), false));
XRCCTRL(*this, "chkBreakElseIfs", wxCheckBox)->SetValue(cfg->ReadBool(_T("/break_elseifs"), false));
XRCCTRL(*this, "chkPadOperators", wxCheckBox)->SetValue(cfg->ReadBool(_T("/pad_operators"), false));
XRCCTRL(*this, "chkPadParensIn", wxCheckBox)->SetValue(cfg->ReadBool(_T("/pad_parentheses_in"), false));
XRCCTRL(*this, "chkPadParensOut", wxCheckBox)->SetValue(cfg->ReadBool(_T("/pad_parentheses_out"), false));
XRCCTRL(*this, "chkPadHeader", wxCheckBox)->SetValue(cfg->ReadBool(_T("/pad_header"), false));
XRCCTRL(*this, "chkUnpadParens", wxCheckBox)->SetValue(cfg->ReadBool(_T("/unpad_parentheses"), false));
XRCCTRL(*this, "chkDelEmptyLine", wxCheckBox)->SetValue(cfg->ReadBool(_T("/delete_empty_lines"), false));
XRCCTRL(*this, "chkKeepComplex", wxCheckBox)->SetValue(cfg->ReadBool(_T("/keep_complex"), false));
XRCCTRL(*this, "chkKeepBlocks", wxCheckBox)->SetValue(cfg->ReadBool(_T("/keep_blocks"), false));
XRCCTRL(*this, "chkConvertTabs", wxCheckBox)->SetValue(cfg->ReadBool(_T("/convert_tabs"), false));
XRCCTRL(*this, "chkFillEmptyLines", wxCheckBox)->SetValue(cfg->ReadBool(_T("/fill_empty_lines"), false));
XRCCTRL(*this, "chkAddBrackets", wxCheckBox)->SetValue(cfg->ReadBool(_T("/add_brackets"), false));
SetStyle((AStylePredefinedStyle)style);
}
CCOptionsDlg::CCOptionsDlg(wxWindow* parent, NativeParser* np, CodeCompletion* cc, DocumentationHelper* dh) :
m_NativeParser(np),
m_CodeCompletion(cc),
m_Parser(np->GetParser()),
m_Documentation(dh)
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("code_completion"));
wxXmlResource::Get()->LoadPanel(this, parent, _T("dlgCCSettings"));
// -----------------------------------------------------------------------
// Handle all options that are being directly applied from config
// -----------------------------------------------------------------------
// Page "Code Completion"
XRCCTRL(*this, "chkNoCC", wxCheckBox)->SetValue(!cfg->ReadBool(_T("/use_code_completion"), true));
XRCCTRL(*this, "chkNoSemantic", wxCheckBox)->SetValue(!cfg->ReadBool(_T("/semantic_keywords"), false));
XRCCTRL(*this, "chkEvalTooltip", wxCheckBox)->SetValue(cfg->ReadBool(_T("/eval_tooltip"), true));
XRCCTRL(*this, "chkAutoSelectOne", wxCheckBox)->SetValue(cfg->ReadBool(_T("/auto_select_one"), false));
XRCCTRL(*this, "chkAutoAddParentheses", wxCheckBox)->SetValue(cfg->ReadBool(_T("/auto_add_parentheses"), true));
XRCCTRL(*this, "chkDetectImpl", wxCheckBox)->SetValue(cfg->ReadBool(_T("/detect_implementation"),false));
XRCCTRL(*this, "chkAddDoxgenComment", wxCheckBox)->SetValue(cfg->ReadBool(_T("/add_doxgen_comment"), false));
XRCCTRL(*this, "chkEnableHeaders", wxCheckBox)->SetValue(cfg->ReadBool(_T("/enable_headers"), true));
XRCCTRL(*this, "chkAutoLaunch", wxCheckBox)->SetValue(cfg->ReadBool(_T("/auto_launch"), true));
XRCCTRL(*this, "spnAutoLaunchChars", wxSpinCtrl)->SetValue(cfg->ReadInt(_T("/auto_launch_chars"), 3));
XRCCTRL(*this, "spnMaxMatches", wxSpinCtrl)->SetValue(cfg->ReadInt(_T("/max_matches"), 16384));
XRCCTRL(*this, "txtFillupChars", wxTextCtrl)->SetValue(cfg->Read(_T("/fillup_chars"), wxEmptyString));
XRCCTRL(*this, "sldCCDelay", wxSlider)->SetValue(cfg->ReadInt(_T("/cc_delay"), 300) / 100);
UpdateCCDelayLabel();
XRCCTRL(*this, "chkKL_1", wxCheckBox)->SetValue(cfg->ReadBool(_T("/lexer_keywords_set1"), true));
XRCCTRL(*this, "chkKL_2", wxCheckBox)->SetValue(cfg->ReadBool(_T("/lexer_keywords_set2"), true));
XRCCTRL(*this, "chkKL_3", wxCheckBox)->SetValue(cfg->ReadBool(_T("/lexer_keywords_set3"), false));
XRCCTRL(*this, "chkKL_4", wxCheckBox)->SetValue(cfg->ReadBool(_T("/lexer_keywords_set4"), false));
XRCCTRL(*this, "chkKL_5", wxCheckBox)->SetValue(cfg->ReadBool(_T("/lexer_keywords_set5"), false));
XRCCTRL(*this, "chkKL_6", wxCheckBox)->SetValue(cfg->ReadBool(_T("/lexer_keywords_set6"), false));
XRCCTRL(*this, "chkKL_7", wxCheckBox)->SetValue(cfg->ReadBool(_T("/lexer_keywords_set7"), false));
XRCCTRL(*this, "chkKL_8", wxCheckBox)->SetValue(cfg->ReadBool(_T("/lexer_keywords_set8"), false));
XRCCTRL(*this, "chkKL_9", wxCheckBox)->SetValue(cfg->ReadBool(_T("/lexer_keywords_set9"), false));
// Page "C / C++ parser"
// NOTE (Morten#1#): Keep this in sync with files in the XRC file (settings.xrc) and nativeparser.cpp
XRCCTRL(*this, "spnThreadsNum", wxSpinCtrl)->SetValue(cfg->ReadInt(_T("/max_threads"), 1));
XRCCTRL(*this, "spnThreadsNum", wxSpinCtrl)->Enable(false);
XRCCTRL(*this, "spnParsersNum", wxSpinCtrl)->SetValue(cfg->ReadInt(_T("/max_parsers"), 5));
// Page "C / C++ parser (adv.)"
// NOTE (Morten#1#): Keep this in sync with files in the XRC file (settings.xrc) and parser.cpp
XRCCTRL(*this, "txtCCFileExtHeader", wxTextCtrl)->SetValue(cfg->Read(_T("/header_ext"), _T("h,hpp,tcc,xpm")));
XRCCTRL(*this, "chkCCFileExtEmpty", wxCheckBox)->SetValue(cfg->ReadBool(_T("/empty_ext"), true));
XRCCTRL(*this, "txtCCFileExtSource", wxTextCtrl)->SetValue(cfg->Read(_T("/source_ext"), _T("c,cpp,cxx,cc,c++")));
const wxStringHashMap& repl = Tokenizer::GetTokenReplacementsMap();
wxStringHashMap::const_iterator it = repl.begin();
while (it != repl.end())
{
XRCCTRL(*this, "lstRepl", wxListBox)->Append(it->first + _T(" -> ") + it->second);
++it;
}
// Page "Symbol browser"
XRCCTRL(*this, "chkNoSB", wxCheckBox)->SetValue(!cfg->ReadBool(_T("/use_symbols_browser"), true));
XRCCTRL(*this, "chkFloatCB", wxCheckBox)->SetValue(cfg->ReadBool(_T("/as_floating_window"), false));
XRCCTRL(*this, "chkScopeFilter", wxCheckBox)->SetValue(cfg->ReadBool(_T("/scope_filter"), true));
// -----------------------------------------------------------------------
// Handle all options that are being handled by m_Parser
// -----------------------------------------------------------------------
// Page "Code Completion"
XRCCTRL(*this, "chkUseSmartSense", wxCheckBox)->SetValue(!m_Parser.Options().useSmartSense);
XRCCTRL(*this, "chkWhileTyping", wxCheckBox)->SetValue(m_Parser.Options().whileTyping);
XRCCTRL(*this, "chkCaseSensitive", wxCheckBox)->SetValue(m_Parser.Options().caseSensitive);
// Page "C / C++ parser"
XRCCTRL(*this, "chkLocals", wxCheckBox)->SetValue(m_Parser.Options().followLocalIncludes);
XRCCTRL(*this, "chkGlobals", wxCheckBox)->SetValue(m_Parser.Options().followGlobalIncludes);
XRCCTRL(*this, "chkPreprocessor", wxCheckBox)->SetValue(m_Parser.Options().wantPreprocessor);
XRCCTRL(*this, "chkComplexMacros", wxCheckBox)->SetValue(m_Parser.Options().parseComplexMacros);
XRCCTRL(*this, "rdoOneParserPerWorkspace", wxRadioButton)->SetValue( m_NativeParser->IsParserPerWorkspace());
XRCCTRL(*this, "rdoOneParserPerProject", wxRadioButton)->SetValue(!m_NativeParser->IsParserPerWorkspace());
// Page "Symbol browser"
XRCCTRL(*this, "chkInheritance", wxCheckBox)->SetValue(m_Parser.ClassBrowserOptions().showInheritance);
XRCCTRL(*this, "chkExpandNS", wxCheckBox)->SetValue(m_Parser.ClassBrowserOptions().expandNS);
XRCCTRL(*this, "chkTreeMembers", wxCheckBox)->SetValue(m_Parser.ClassBrowserOptions().treeMembers);
// Page Documentation
XRCCTRL(*this, "chkDocumentation", wxCheckBox)->SetValue(m_Documentation->IsEnabled());
ColourManager *colours = Manager::Get()->GetColourManager();
XRCCTRL(*this, "btnDocBgColor", wxButton)->SetBackgroundColour(colours->GetColour(wxT("cc_docs_back")));
XRCCTRL(*this, "btnDocTextColor", wxButton)->SetBackgroundColour(colours->GetColour(wxT("cc_docs_fore")));
XRCCTRL(*this, "btnDocLinkColor", wxButton)->SetBackgroundColour(colours->GetColour(wxT("cc_docs_link")));
// m_Parser.ParseBuffer(g_SampleClasses, true);
// m_Parser.BuildTree(*XRCCTRL(*this, "treeClasses", wxTreeCtrl));
}
void Highlighter::HighlightOccurrencesOfSelection(cbEditor* ctrl)const
{
// chosen a high value for indicator, hoping not to interfere with the indicators used by some lexers
// if they get updated from deprecated oldstyle indicators somedays.
cbStyledTextCtrl *control = ctrl->GetControl();
const int theIndicator = 10;
std::pair<long, long> curr;
control->GetSelection(&curr.first, &curr.second);
control->SetIndicatorCurrent(theIndicator);
if (m_OldHighlightSelectionCtrl == control && m_HighlightSelectedOccurencesLastPos == curr) // whatever the current state is, we've already done it once
return;
m_HighlightSelectedOccurencesLastPos = curr;
m_OldHighlightSelectionCtrl = control;
int eof = control->GetLength();
// Set Styling:
// clear all style indications set in a previous run (is also done once after text gets unselected)
control->IndicatorClearRange(0, eof);
// if there is no text selected, it stops here and does not hog the cpu further
if (curr.first == curr.second)
return;
// check if the selected text has space, tab or new line in it
wxString selectedText(control->GetTextRange(curr.first, curr.second));
if (selectedText.find_first_of(wxT(" \t\n")) != wxString::npos)
return;
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("editor"));
// check if the feature is enabled
if (!cfg->ReadBool(_T("/highlight_occurrence/enabled"), true))
return;
// selected text has a minimal length of controlled by the user (by default it is 3)
wxString::size_type minLength = std::max(cfg->ReadInt(_T("/highlight_occurrence/min_length"), 3), 1);
if (selectedText.length() >= minLength)
{
wxColour highlightColour(Manager::Get()->GetColourManager()->GetColour(wxT("editor_highlight_occurrence")));
if ( ctrl->GetLeftSplitViewControl() )
{
ctrl->GetLeftSplitViewControl()->IndicatorSetStyle(theIndicator, wxSCI_INDIC_HIGHLIGHT);
ctrl->GetLeftSplitViewControl()->IndicatorSetForeground(theIndicator, highlightColour );
#ifndef wxHAVE_RAW_BITMAP
// If wxWidgets is build without rawbitmap-support, the indicators become opaque
// and hide the text, so we show them under the text.
// Not enabled as default, because the readability is a little bit worse.
ctrl->GetLeftSplitViewControl()->IndicatorSetUnder(theIndicator,true);
#endif
}
if ( ctrl->GetRightSplitViewControl() )
{
ctrl->GetRightSplitViewControl()->IndicatorSetStyle(theIndicator, wxSCI_INDIC_HIGHLIGHT);
ctrl->GetRightSplitViewControl()->IndicatorSetForeground(theIndicator, highlightColour );
#ifndef wxHAVE_RAW_BITMAP
ctrl->GetRightSplitViewControl()->IndicatorSetUnder(theIndicator,true);
#endif
}
int flag = 0;
if (cfg->ReadBool(_T("/highlight_occurrence/case_sensitive"), true))
{
flag |= wxSCI_FIND_MATCHCASE;
}
if (cfg->ReadBool(_T("/highlight_occurrence/whole_word"), true))
{
flag |= wxSCI_FIND_WHOLEWORD;
}
// list all selections and sort them
typedef std::vector<std::pair<long, long> > Selections;
Selections selections;
int count = control->GetSelections();
for (int ii = 0; ii < count; ++ii)
{
selections.push_back(Selections::value_type(control->GetSelectionNStart(ii),
control->GetSelectionNEnd(ii)));
}
std::sort(selections.begin(), selections.end());
Selections::const_iterator currSelection = selections.begin();
// search for every occurence
int lengthFound = 0; // we need this to work properly with multibyte characters
for ( int pos = control->FindText(0, eof, selectedText, flag, &lengthFound);
pos != wxSCI_INVALID_POSITION ;
pos = control->FindText(pos+=selectedText.Len(), eof, selectedText, flag, &lengthFound) )
{
// check if the found text is selected
// if it is don't add indicator for it, because it looks ugly
bool skip = false;
for (; currSelection != selections.end(); ++currSelection)
{
// the found text is after the current selection, go to the next one
if (currSelection->second < pos)
continue;
// if the end of the found text is not before the current selection start
// then it must match and it should be skipped
if (pos + lengthFound >= currSelection->first)
skip = true;
break;
}
if (skip)
continue;
// does not make sense anymore: check that the found occurrence is not the same as the selected,
// since it is not selected in the second view -> so highlight it
control->IndicatorFillRange(pos, lengthFound);
}
}
}
PythonCodeCtrl::PythonCodeCtrl(wxWindow *parent, PythonInterpCtrl *py)
: cbStyledTextCtrl(parent, wxID_ANY)
{
m_pyctrl = py;
EditorManager *em = Manager::Get()->GetEditorManager();
// Connect(wxEVT_KEY_DOWN, wxKeyEventHandler(PythonCodeCtrl::OnUserInput));
ConfigManager* mgr = Manager::Get()->GetConfigManager(_T("editor"));
//MOST OF THIS STUFF IS TAKEN FROM CB EDITOR
wxFont font(10, wxMODERN, wxNORMAL, wxNORMAL);
wxString fontstring = mgr->Read(_T("/font"), wxEmptyString);
if (!fontstring.IsEmpty())
{
wxNativeFontInfo nfi;
nfi.FromString(fontstring);
font.SetNativeFontInfo(nfi);
}
SetMouseDwellTime(1000);
SetScrollWidthTracking(true);
SetScrollWidth(5); //Hides horizontal scrollbar if text doesn't exceed the window width
int caretStyle = mgr->ReadInt(_T("/caret/style"), wxSCI_CARETSTYLE_LINE);
SetCaretStyle(caretStyle);
if (caretStyle == wxSCI_CARETSTYLE_LINE)
SetCaretWidth(mgr->ReadInt(_T("/caret/width"), 1));
else
SetCaretWidth(1);
ColourManager *colours = Manager::Get()->GetColourManager();
SetCaretForeground(colours->GetColour(wxT("editor_caret")));
SetCaretPeriod(mgr->ReadInt(_T("/caret/period"), 500));
SetCaretLineVisible(mgr->ReadBool(_T("/highlight_caret_line"), false));
SetCaretLineBackground(
Manager::Get()->GetConfigManager(_T("editor"))->ReadColour(_T("/highlight_caret_line_colour"), wxColour(0xFF, 0xFF, 0x00)));
SetFoldMarginColour(true, colours->GetColour(wxT("editor_margin_chrome")));
SetFoldMarginHiColour(true, colours->GetColour(wxT("editor_margin_chrome_highlight")));
// setup for "CamelCase selection"
if (mgr->ReadBool(_T("/camel_case"), false))
{
// consider CamelCase for both: cursor movement with CTRL and selection with CTRL+SHIFT:
CmdKeyAssign(wxSCI_KEY_LEFT, wxSCI_SCMOD_CTRL, wxSCI_CMD_WORDPARTLEFT);
CmdKeyAssign(wxSCI_KEY_RIGHT, wxSCI_SCMOD_CTRL, wxSCI_CMD_WORDPARTRIGHT);
CmdKeyAssign(wxSCI_KEY_LEFT, wxSCI_SCMOD_CTRL|wxSCI_SCMOD_SHIFT, wxSCI_CMD_WORDPARTLEFTEXTEND);
CmdKeyAssign(wxSCI_KEY_RIGHT, wxSCI_SCMOD_CTRL|wxSCI_SCMOD_SHIFT, wxSCI_CMD_WORDPARTRIGHTEXTEND);
}
else // else set default "none CamelCase" key behavior (also default scintilla behaviour, see scintilla docs)
{
CmdKeyAssign(wxSCI_KEY_LEFT, wxSCI_SCMOD_CTRL, wxSCI_CMD_WORDLEFT);
CmdKeyAssign(wxSCI_KEY_RIGHT, wxSCI_SCMOD_CTRL, wxSCI_CMD_WORDRIGHT);
CmdKeyAssign(wxSCI_KEY_LEFT, wxSCI_SCMOD_CTRL|wxSCI_SCMOD_SHIFT, wxSCI_CMD_WORDLEFTEXTEND);
CmdKeyAssign(wxSCI_KEY_RIGHT, wxSCI_SCMOD_CTRL|wxSCI_SCMOD_SHIFT, wxSCI_CMD_WORDRIGHTEXTEND);
}
SetUseTabs(mgr->ReadBool(_T("/use_tab"), false));
SetIndentationGuides(mgr->ReadBool(_T("/show_indent_guides"), false)?wxSCI_IV_LOOKBOTH:wxSCI_IV_NONE);
SetTabIndents(mgr->ReadBool(_T("/tab_indents"), true));
SetBackSpaceUnIndents(mgr->ReadBool(_T("/backspace_unindents"), true));
SetWrapMode(mgr->ReadBool(_T("/word_wrap"), false));
if (mgr->ReadBool(_T("/word_wrap_style_home_end"), true))
{
// in word wrap mode, home/end keys goto the wrap point if not already there,
// otherwise to the start/end of the entire line.
// alt+home/end go to start/end of the entire line.
// in unwrapped mode, there is no difference between home/end and alt+home/end
CmdKeyAssign(wxSCI_KEY_END, wxSCI_SCMOD_NORM, wxSCI_CMD_LINEENDWRAP);
CmdKeyAssign(wxSCI_KEY_END, wxSCI_SCMOD_ALT, wxSCI_CMD_LINEEND);
CmdKeyAssign(wxSCI_KEY_END, wxSCI_SCMOD_SHIFT, wxSCI_CMD_LINEENDWRAPEXTEND);
CmdKeyAssign(wxSCI_KEY_END, wxSCI_SCMOD_SHIFT|wxSCI_SCMOD_ALT, wxSCI_CMD_LINEENDEXTEND);
// if user wants "Home" key to set cursor to the very beginning of line
if (mgr->ReadBool(_T("/simplified_home"), false))
{
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_NORM,wxSCI_CMD_HOMEWRAP);
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_ALT,wxSCI_CMD_HOME);
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_SHIFT,wxSCI_CMD_HOMEWRAPEXTEND);
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_SHIFT|wxSCI_SCMOD_ALT,wxSCI_CMD_HOMEEXTEND);
}
else // else set default "Home" key behavior
{
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_NORM,wxSCI_CMD_VCHOMEWRAP);
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_ALT,wxSCI_CMD_VCHOME);
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_SHIFT,wxSCI_CMD_VCHOMEWRAPEXTEND);
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_SHIFT|wxSCI_SCMOD_ALT,wxSCI_CMD_VCHOMEEXTEND);
}
}
else
{ // in word wrap mode, home/end keys goto start/end of the entire line. alt+home/end goes to wrap points
CmdKeyAssign(wxSCI_KEY_END, wxSCI_SCMOD_ALT, wxSCI_CMD_LINEENDWRAP);
CmdKeyAssign(wxSCI_KEY_END, wxSCI_SCMOD_SHIFT|wxSCI_SCMOD_ALT, wxSCI_CMD_LINEENDWRAPEXTEND);
// if user wants "Home" key to set cursor to the very beginning of line
if (mgr->ReadBool(_T("/simplified_home"), false))
{
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_ALT,wxSCI_CMD_HOMEWRAP);
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_SHIFT|wxSCI_SCMOD_ALT,wxSCI_CMD_HOMEWRAPEXTEND);
}
else // else set default "Home" key behavior
{
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_ALT,wxSCI_CMD_VCHOMEWRAP);
CmdKeyAssign(wxSCI_KEY_HOME,wxSCI_SCMOD_SHIFT|wxSCI_SCMOD_ALT,wxSCI_CMD_VCHOMEWRAPEXTEND);
}
}
SetViewEOL(mgr->ReadBool(_T("/show_eol"), false));
SetViewWhiteSpace(mgr->ReadInt(_T("/view_whitespace"), 0));
// gutter
SetEdgeMode(mgr->ReadInt(_T("/gutter/mode"), 0));
SetEdgeColour(Manager::Get()->GetColourManager()->GetColour(wxT("editor_gutter")));
SetEdgeColumn(mgr->ReadInt(_T("/gutter/column"), 80));
StyleSetFont(wxSCI_STYLE_DEFAULT, font);
StyleClearAll();
SetTabWidth(mgr->ReadInt(_T("/tab_size"), 4));
SetIndent(mgr->ReadInt(_T("/tab_size"), 4)); //NEEDED FOR AUTO INDENTATION (NOT IN CB EDITOR)
em->GetColourSet()->Apply(_("Python"),this);
}
void Compiler::LoadSettings(const wxString& baseKey)
{
// before loading any compiler settings, keep the current settings safe
// so we can compare them when saving: this way we can only save what's
// different from the defaults
MirrorCurrentSettings();
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("compiler"));
// read settings version
wxString version = cfg->Read(_T("settings_version"));
bool versionMismatch = version != CompilerSettingsVersion;
wxString tmp;
// if using old-style keys (using integer IDs), notify user about the changes
static bool saidAboutCompilerIDs = false;
tmp.Printf(_T("%s/set%3.3d"), baseKey.c_str(), CompilerFactory::GetCompilerIndex(this) + 1);
if (cfg->Exists(tmp + _T("/name")))
{
if (!saidAboutCompilerIDs)
{
saidAboutCompilerIDs = true;
cbMessageBox(_("Compilers now use unique names instead of integer IDs.\n"
"Projects will be updated accordingly on load, mostly automatic."),
_("Information"),
wxICON_INFORMATION);
}
// at this point, we 'll be using the old style configuration to load settings
}
else // it's OK to use new style
tmp.Printf(_T("%s/%s"), baseKey.c_str(), m_ID.c_str());
if (!cfg->Exists(tmp + _T("/name")))
return;
wxString sep = wxFileName::GetPathSeparator();
m_Name = cfg->Read(tmp + _T("/name"), m_Name);
m_MasterPath = cfg->Read(tmp + _T("/master_path"), m_MasterPath);
m_ExtraPaths = MakeUniqueArray(GetArrayFromString(cfg->Read(tmp + _T("/extra_paths"), _T("")), _T(";")), true);
m_Programs.C = cfg->Read(tmp + _T("/c_compiler"), m_Programs.C);
m_Programs.CPP = cfg->Read(tmp + _T("/cpp_compiler"), m_Programs.CPP);
m_Programs.LD = cfg->Read(tmp + _T("/linker"), m_Programs.LD);
m_Programs.LIB = cfg->Read(tmp + _T("/lib_linker"), m_Programs.LIB);
m_Programs.WINDRES = cfg->Read(tmp + _T("/res_compiler"), m_Programs.WINDRES);
m_Programs.MAKE = cfg->Read(tmp + _T("/make"), m_Programs.MAKE);
m_Programs.DBG = cfg->Read(tmp + _T("/debugger"), m_Programs.DBG);
// set member variable containing the version string with the configurated toolchain executables, not only
// with the default ones, otherwise we might have an empty version-string
// Some MinGW installations do not includee "mingw32-gcc" !!
SetVersionString();
SetCompilerOptions (GetArrayFromString(cfg->Read(tmp + _T("/compiler_options"), wxEmptyString)));
SetLinkerOptions (GetArrayFromString(cfg->Read(tmp + _T("/linker_options"), wxEmptyString)));
SetIncludeDirs (GetArrayFromString(cfg->Read(tmp + _T("/include_dirs"), wxEmptyString)));
SetResourceIncludeDirs(GetArrayFromString(cfg->Read(tmp + _T("/res_include_dirs"), wxEmptyString)));
SetLibDirs (GetArrayFromString(cfg->Read(tmp + _T("/library_dirs"), wxEmptyString)));
SetLinkLibs (GetArrayFromString(cfg->Read(tmp + _T("/libraries"), wxEmptyString)));
SetCommandsBeforeBuild(GetArrayFromString(cfg->Read(tmp + _T("/commands_before"), wxEmptyString)));
SetCommandsAfterBuild (GetArrayFromString(cfg->Read(tmp + _T("/commands_after"), wxEmptyString)));
for (int i = 0; i < ctCount; ++i)
{
wxArrayString keys = cfg->EnumerateSubPaths(tmp + _T("/macros/") + CommandTypeDescriptions[i]);
for (size_t n = 0; n < keys.size(); ++n)
{
unsigned long index = 0;
if (keys[n].Mid(4).ToULong(&index)) // skip 'tool'
{
while (index >= m_Commands[i].size())
m_Commands[i].push_back(CompilerTool());
CompilerTool& tool = m_Commands[i][index];
wxString key = wxString::Format(_T("%s/macros/%s/tool%lu/"), tmp.c_str(), CommandTypeDescriptions[i].c_str(), index);
tool.command = cfg->Read(key + _T("command"));
tool.extensions = cfg->ReadArrayString(key + _T("extensions"));
tool.generatedFiles = cfg->ReadArrayString(key + _T("generatedFiles"));
}
}
}
// switches
m_Switches.includeDirs = cfg->Read(tmp + _T("/switches/includes"), m_Switches.includeDirs);
m_Switches.libDirs = cfg->Read(tmp + _T("/switches/libs"), m_Switches.libDirs);
m_Switches.linkLibs = cfg->Read(tmp + _T("/switches/link"), m_Switches.linkLibs);
m_Switches.defines = cfg->Read(tmp + _T("/switches/define"), m_Switches.defines);
m_Switches.genericSwitch = cfg->Read(tmp + _T("/switches/generic"), m_Switches.genericSwitch);
m_Switches.objectExtension = cfg->Read(tmp + _T("/switches/objectext"), m_Switches.objectExtension);
m_Switches.needDependencies = cfg->ReadBool(tmp + _T("/switches/deps"), m_Switches.needDependencies);
m_Switches.forceCompilerUseQuotes = cfg->ReadBool(tmp + _T("/switches/forceCompilerQuotes"), m_Switches.forceCompilerUseQuotes);
m_Switches.forceLinkerUseQuotes = cfg->ReadBool(tmp + _T("/switches/forceLinkerQuotes"), m_Switches.forceLinkerUseQuotes);
m_Switches.logging = (CompilerLoggingType)cfg->ReadInt(tmp + _T("/switches/logging"), m_Switches.logging);
m_Switches.libPrefix = cfg->Read(tmp + _T("/switches/libPrefix"), m_Switches.libPrefix);
m_Switches.libExtension = cfg->Read(tmp + _T("/switches/libExtension"), m_Switches.libExtension);
m_Switches.linkerNeedsLibPrefix = cfg->ReadBool(tmp + _T("/switches/linkerNeedsLibPrefix"), m_Switches.linkerNeedsLibPrefix);
m_Switches.linkerNeedsLibExtension = cfg->ReadBool(tmp + _T("/switches/linkerNeedsLibExtension"), m_Switches.linkerNeedsLibExtension);
m_Switches.forceFwdSlashes = cfg->ReadBool(tmp + _T("/switches/forceFwdSlashes"), m_Switches.forceFwdSlashes);
m_Switches.supportsPCH = cfg->ReadBool(tmp + _T("/switches/supportsPCH"), m_Switches.supportsPCH);
m_Switches.PCHExtension = cfg->Read(tmp + _T("/switches/pchExtension"), m_Switches.PCHExtension);
m_Switches.UseFlatObjects = cfg->ReadBool(tmp + _T("/switches/UseFlatObjects"), m_Switches.UseFlatObjects);
m_Switches.UseFullSourcePaths = cfg->ReadBool(tmp + _T("/switches/UseFullSourcePaths"), m_Switches.UseFullSourcePaths);
m_Switches.Use83Paths = cfg->ReadBool(tmp + _T("/switches/Use83Paths"), m_Switches.Use83Paths);
// regexes
// because we 're only saving changed regexes, we can't just iterate like before.
// instead, we must iterate all child-keys and deduce the regex index number from
// the key name
wxArrayString keys = cfg->EnumerateSubPaths(tmp + _T("/regex/"));
wxString group;
long index = 0;
for (size_t i = 0; i < keys.GetCount(); ++i)
{
wxString key = keys[i];
// reNNN
if (!key.StartsWith(_T("re")))
continue;
key.Remove(0, 2);
if (!key.ToLong(&index, 10))
continue;
// 'index' now holds the regex index.
// read everything and either assign it to an existing regex
// if the index exists, or add a new regex
group.Printf(_T("%s/regex/re%3.3ld"), tmp.c_str(), index);
if (!cfg->Exists(group+_T("/description")))
continue;
RegExStruct rs;
rs.desc = cfg->Read(group + _T("/description"));
rs.lt = (CompilerLineType)cfg->ReadInt(group + _T("/type"), 0);
rs.regex = cfg->Read(group + _T("/regex"));
rs.msg[0 ] = cfg->ReadInt(group + _T("/msg1"), 0);
rs.msg[1] = cfg->ReadInt(group + _T("/msg2"), 0);
rs.msg[2] = cfg->ReadInt(group + _T("/msg3"), 0);
rs.filename = cfg->ReadInt(group + _T("/filename"), 0);
rs.line = cfg->ReadInt(group + _T("/line"), 0);
if (index <= (long)m_RegExes.GetCount())
m_RegExes[index - 1] = rs;
else
m_RegExes.Add(rs);
}
// custom vars
wxString configpath = tmp + _T("/custom_variables/");
UnsetAllVars();
wxArrayString list = cfg->EnumerateKeys(configpath);
for (unsigned int i = 0; i < list.GetCount(); ++i)
SetVar(list[i], cfg->Read(configpath + _T('/') + list[i]), false);
if (versionMismatch)
{
wxString msg;
msg << _("Some compiler settings defaults have changed in this version.\n"
"It is recommended that you allow updating of your settings to the new defaults.\n"
"Only disallow this if you don't want to lose any customizations you have done to this compiler's settings.\n\n"
"Note that the only settings that are affected are those found in \"Advanced compiler options\"...\n\n"
"Do you want to update your current settings to the new defaults?");
// don't ask if the compiler is not valid (i.e. not installed), just update
if (!IsValid() || cbMessageBox(msg, m_Name, wxICON_QUESTION | wxYES_NO) == wxID_YES)
{
for (int i = 0; i < ctCount; ++i)
m_Commands[i] = m_Mirror.Commands[i];
m_Switches = m_Mirror.Switches;
m_Options = m_Mirror.Options;
m_RegExes = m_Mirror.RegExes;
}
}
}
void FormatterSettings::ApplyTo(astyle::ASFormatter& formatter)
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("astyle"));
int style = cfg->ReadInt(_T("/style"), 0);
switch (style)
{
case aspsAllman: // Allman (ANSI)
formatter.setFormattingStyle(astyle::STYLE_ALLMAN);
break;
case aspsJava: // Java
formatter.setFormattingStyle(astyle::STYLE_JAVA);
break;
case aspsKr: // K&R
formatter.setFormattingStyle(astyle::STYLE_KandR);
break;
case aspsStroustrup: // Stroustrup
formatter.setFormattingStyle(astyle::STYLE_STROUSTRUP);
break;
case aspsWhitesmith: // Whitesmith
formatter.setFormattingStyle(astyle::STYLE_WHITESMITH);
break;
case aspsBanner: // Banner
formatter.setFormattingStyle(astyle::STYLE_BANNER);
break;
case aspsGnu: // GNU
formatter.setFormattingStyle(astyle::STYLE_GNU);
break;
case aspsLinux: // Linux
formatter.setFormattingStyle(astyle::STYLE_LINUX);
break;
case aspsHorstmann: // Horstmann
formatter.setFormattingStyle(astyle::STYLE_HORSTMANN);
break;
default: // Custom
{
bool value = cfg->ReadBool(_T("/force_tabs"));
int spaceNum = cfg->ReadInt(_T("/indentation"), 4);
if (cfg->ReadBool(_T("/use_tabs")))
{
formatter.setTabIndentation(spaceNum, value);
}
else
{
formatter.setSpaceIndentation(spaceNum);
}
formatter.setClassIndent(cfg->ReadBool(_T("/indent_classes")));
formatter.setSwitchIndent(cfg->ReadBool(_T("/indent_switches")));
formatter.setCaseIndent(cfg->ReadBool(_T("/indent_case")));
formatter.setBracketIndent(cfg->ReadBool(_T("/indent_brackets")));
formatter.setBlockIndent(cfg->ReadBool(_T("/indent_blocks")));
formatter.setNamespaceIndent(cfg->ReadBool(_T("/indent_namespaces")));
formatter.setLabelIndent(cfg->ReadBool(_T("/indent_labels")));
formatter.setPreprocessorIndent(cfg->ReadBool(_T("/indent_preprocessor")));
wxString brackedFormatMode = cfg->Read(_T("/bracket_format_mode"));
if (brackedFormatMode == _T("Attach"))
{
formatter.setBracketFormatMode(astyle::ATTACH_MODE);
}
else if (brackedFormatMode == _T("Break"))
{
formatter.setBracketFormatMode(astyle::BREAK_MODE);
}
else if (brackedFormatMode == _T("Linux"))
{
formatter.setBracketFormatMode(astyle::LINUX_MODE);
}
else if (brackedFormatMode == _T("Stroustrup"))
{
formatter.setBracketFormatMode(astyle::STROUSTRUP_MODE);
}
else
{
formatter.setBracketFormatMode(astyle::NONE_MODE);
}
wxString pointerAlign = cfg->Read(_T("/pointer_align"));
if (pointerAlign == _T("Type"))
{
formatter.setPointerAlignment(astyle::ALIGN_TYPE);
}
else if (pointerAlign == _T("Middle"))
{
formatter.setPointerAlignment(astyle::ALIGN_MIDDLE);
}
else if (pointerAlign == _T("Name"))
{
formatter.setPointerAlignment(astyle::ALIGN_NAME);
}
else
{
formatter.setPointerAlignment(astyle::ALIGN_NONE);
}
formatter.setBreakClosingHeaderBracketsMode(cfg->ReadBool(_T("/break_closing")));
formatter.setBreakBlocksMode(cfg->ReadBool(_T("/break_blocks")));
formatter.setBreakElseIfsMode(cfg->ReadBool(_T("/break_elseifs")));
formatter.setOperatorPaddingMode(cfg->ReadBool(_T("/pad_operators")));
formatter.setParensOutsidePaddingMode(cfg->ReadBool(_T("/pad_parentheses_out")));
formatter.setParensInsidePaddingMode(cfg->ReadBool(_T("/pad_parentheses_in")));
formatter.setParensUnPaddingMode(cfg->ReadBool(_T("/unpad_parentheses")));
formatter.setSingleStatementsMode(!cfg->ReadBool(_T("/keep_complex")));
formatter.setBreakOneLineBlocksMode(!cfg->ReadBool(_T("/keep_blocks")));
formatter.setTabSpaceConversionMode(cfg->ReadBool(_T("/convert_tabs")));
formatter.setEmptyLineFill(cfg->ReadBool(_T("/fill_empty_lines")));
break;
}
}
}
void EnvironmentSettingsDlg::EndModal(int retCode)
{
if (retCode == wxID_OK)
{
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
ConfigManager *pcfg = Manager::Get()->GetConfigManager(_T("project_manager"));
ConfigManager *mcfg = Manager::Get()->GetConfigManager(_T("message_manager"));
ConfigManager *acfg = Manager::Get()->GetConfigManager(_T("an_dlg"));
// tab "General"
cfg->Write(_T("/environment/single_instance"), (bool) XRCCTRL(*this, "chkSingleInstance", wxCheckBox)->GetValue());
cfg->Write(_T("/environment/use_ipc"), (bool) XRCCTRL(*this, "chkUseIPC", wxCheckBox)->GetValue());
cfg->Write(_T("/environment/raise_via_ipc"), (bool) XRCCTRL(*this, "chkRaiseViaIPC", wxCheckBox)->GetValue());
cfg->Write(_T("/environment/check_associations"), (bool) XRCCTRL(*this, "chkAssociations", wxCheckBox)->GetValue());
cfg->Write(_T("/environment/check_modified_files"), (bool) XRCCTRL(*this, "chkModifiedFiles", wxCheckBox)->GetValue());
cfg->Write(_T("/environment/ignore_invalid_targets"),(bool) XRCCTRL(*this, "chkInvalidTargets", wxCheckBox)->GetValue());
cfg->Write(_T("/console_shell"), XRCCTRL(*this, "txtConsoleShell", wxTextCtrl)->GetValue());
cfg->Write(_T("/console_terminal"), XRCCTRL(*this, "txtConsoleTerm", wxTextCtrl)->GetValue());
// tab "View"
cfg->Write(_T("/environment/blank_workspace"), (bool) XRCCTRL(*this, "rbAppStart", wxRadioBox)->GetSelection() ? true : false);
pcfg->Write(_T("/open_files"), (int) XRCCTRL(*this, "rbProjectOpen", wxRadioBox)->GetSelection());
cfg->Write(_T("/environment/settings_size"), (int) XRCCTRL(*this, "rbSettingsIconsSize", wxRadioBox)->GetSelection());
mcfg->Write(_T("/auto_hide"), (bool) XRCCTRL(*this, "chkAutoHideMessages", wxCheckBox)->GetValue());
mcfg->Write(_T("/auto_show_search"), (bool) XRCCTRL(*this, "chkAutoShowMessagesOnSearch", wxCheckBox)->GetValue());
mcfg->Write(_T("/auto_show_build_warnings"), (bool) XRCCTRL(*this, "chkAutoShowMessagesOnWarn", wxCheckBox)->GetValue());
mcfg->Write(_T("/auto_show_build_errors"), (bool) XRCCTRL(*this, "chkAutoShowMessagesOnErr", wxCheckBox)->GetValue());
mcfg->Write(_T("/save_selection_change_in_mp"), (bool) XRCCTRL(*this, "chkSaveSelectionChangeInMP", wxCheckBox)->GetValue());
cfg->Write(_T("/open_containing_folder"), XRCCTRL(*this, "txtOpenFolder", wxTextCtrl)->GetValue());
cfg->Write(_T("/environment/view/dbl_clk_maximize"), (bool)XRCCTRL(*this, "chkDblClkMaximizes", wxCheckBox)->GetValue());
cfg->Write(_T("/environment/view/layout_to_toggle"), XRCCTRL(*this, "choLayoutToToggle", wxChoice)->GetStringSelection());
cfg->Write(_T("/locale/enable"), (bool) XRCCTRL(*this, "chkI18N", wxCheckBox)->GetValue());
const wxLanguageInfo *info = wxLocale::FindLanguageInfo(XRCCTRL(*this, "cbxLanguage", wxComboBox)->GetStringSelection());
if(info)
cfg->Write(_T("/locale/language"), info->CanonicalName);
else
cfg->Write(_T("/locale/language"), wxEmptyString);
mcfg->Write(_T("/log_font_size"), (int) XRCCTRL(*this, "spnLogFontSize", wxSpinCtrl)->GetValue());
cfg->Write(_T("/dialog_placement/do_place"), (bool) XRCCTRL(*this, "chkDoPlace", wxCheckBox)->GetValue());
cfg->Write(_T("/dialog_placement/dialog_position"), (int) XRCCTRL(*this, "chkPlaceHead", wxCheckBox)->GetValue() ? pdlHead : pdlCentre);
// tab "Appearence"
bool tab_switcher_mode = (bool) XRCCTRL(*this, "chkStackedBasedTabSwitching", wxCheckBox)->GetValue();
if (Manager::Get()->GetConfigManager(_T("app"))->ReadBool(_T("/environment/tabs_stacked_based_switching")) != tab_switcher_mode)
{
if (tab_switcher_mode)
Manager::Get()->GetEditorManager()->RebuildNotebookStack();
else
Manager::Get()->GetEditorManager()->DeleteNotebookStack();
}
cfg->Write(_T("/environment/tabs_stacked_based_switching"), tab_switcher_mode);
bool enableMousewheel = (bool) XRCCTRL(*this, "chkNBUseMousewheel",wxCheckBox)->GetValue();
cfg->Write(_T("/environment/tabs_use_mousewheel"), enableMousewheel);
wxString key = XRCCTRL(*this, "txtMousewheelModifier", wxTextCtrl)->GetValue();
cfg->Write(_T("/environment/tabs_mousewheel_modifier"), key.IsEmpty()?_T("Ctrl"):key);
cfg->Write(_T("/environment/tabs_mousewheel_advance"), (bool) XRCCTRL(*this, "rbNBModToAdvance", wxRadioButton)->GetValue());
cfg->Write(_T("/environment/tabs_invert_advance"), (bool) XRCCTRL(*this, "chkNBInvertAdvance", wxCheckBox)->GetValue());
cfg->Write(_T("/environment/tabs_invert_move"), (bool) XRCCTRL(*this, "chkNBInvertMove", wxCheckBox)->GetValue());
bool useToolTips = (bool)XRCCTRL(*this, "chkNBUseToolTips", wxCheckBox)->GetValue();
cfg->Write(_T("/environment/tabs_use_tooltips"),useToolTips);
cfg->Write(_T("/environment/tabs_dwell_time"), (int) XRCCTRL(*this, "spnNBDwellTime", wxSpinCtrl)->GetValue());
cbAuiNotebook::AllowScrolling(enableMousewheel);
cbAuiNotebook::UseToolTips(useToolTips);
cbAuiNotebook::SetDwellTime(cfg->ReadInt(_T("/environment/tabs_dwell_time"), 1000));
cbAuiNotebook::SetModKeys(cfg->Read(_T("/environment/tabs_mousewheel_modifier"),_T("Ctrl")));
cbAuiNotebook::UseModToAdvance(cfg->ReadBool(_T("/environment/tabs_mousewheel_advance"),false));
cbAuiNotebook::InvertAdvanceDirection(cfg->ReadBool(_T("/environment/tabs_invert_advance"),false));
cbAuiNotebook::InvertMoveDirection(cfg->ReadBool(_T("/environment/tabs_invert_move"),false));
/*
cfg->Write(_T("/environment/aui/border_size"), (int) XRCCTRL(*this, "spnAuiBorder", wxSpinCtrl)->GetValue());
cfg->Write(_T("/environment/aui/sash_size"), (int) XRCCTRL(*this, "spnAuiSash", wxSpinCtrl)->GetValue());
cfg->Write(_T("/environment/aui/caption_size"), (int) XRCCTRL(*this, "spnAuiCaption", wxSpinCtrl)->GetValue());
cfg->Write(_T("/environment/aui/active_caption_colour"), XRCCTRL(*this, "btnAuiActiveCaptionColour", wxButton)->GetBackgroundColour());
cfg->Write(_T("/environment/aui/active_caption_gradient_colour"), XRCCTRL(*this, "btnAuiActiveCaptionGradientColour", wxButton)->GetBackgroundColour());
cfg->Write(_T("/environment/aui/active_caption_text_colour"), XRCCTRL(*this, "btnAuiActiveCaptionTextColour", wxButton)->GetBackgroundColour());
cfg->Write(_T("/environment/aui/inactive_caption_colour"), XRCCTRL(*this, "btnAuiInactiveCaptionColour", wxButton)->GetBackgroundColour());
cfg->Write(_T("/environment/aui/inactive_caption_gradient_colour"), XRCCTRL(*this, "btnAuiInactiveCaptionGradientColour", wxButton)->GetBackgroundColour());
cfg->Write(_T("/environment/aui/inactive_caption_text_colour"), XRCCTRL(*this, "btnAuiInactiveCaptionTextColour", wxButton)->GetBackgroundColour());
m_pArt->SetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE, XRCCTRL(*this, "spnAuiBorder", wxSpinCtrl)->GetValue());
m_pArt->SetMetric(wxAUI_DOCKART_SASH_SIZE, XRCCTRL(*this, "spnAuiSash", wxSpinCtrl)->GetValue());
m_pArt->SetMetric(wxAUI_DOCKART_CAPTION_SIZE, XRCCTRL(*this, "spnAuiCaption", wxSpinCtrl)->GetValue());
m_pArt->SetColour(wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR, XRCCTRL(*this, "btnAuiActiveCaptionColour", wxButton)->GetBackgroundColour());
m_pArt->SetColour(wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR, XRCCTRL(*this, "btnAuiActiveCaptionGradientColour", wxButton)->GetBackgroundColour());
m_pArt->SetColour(wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR, XRCCTRL(*this, "btnAuiActiveCaptionTextColour", wxButton)->GetBackgroundColour());
m_pArt->SetColour(wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR, XRCCTRL(*this, "btnAuiInactiveCaptionColour", wxButton)->GetBackgroundColour());
m_pArt->SetColour(wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR,XRCCTRL(*this, "btnAuiInactiveCaptionGradientColour", wxButton)->GetBackgroundColour());
m_pArt->SetColour(wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR, XRCCTRL(*this, "btnAuiInactiveCaptionTextColour", wxButton)->GetBackgroundColour());
*/
// tab "Dialogs"
wxCheckListBox* lb = XRCCTRL(*this, "chkDialogs", wxCheckListBox);
ConfigManagerContainer::StringSet dialogs = acfg->ReadSSet(_T("/disabled"));
for (int i = 0; i < (int)lb->GetCount(); ++i)
{
if (lb->IsChecked(i))
dialogs.erase(lb->GetString(i));
}
acfg->Write(_T("/disabled"), dialogs);
// tab "Network"
cfg->Write(_T("/network_proxy"), XRCCTRL(*this, "txtProxy", wxTextCtrl)->GetValue());
// finally, apply settings in all plugins' panels
for (size_t i = 0; i < m_PluginPanels.GetCount(); ++i)
{
cbConfigurationPanel* panel = m_PluginPanels[i];
panel->OnApply();
}
}
else
{
// finally, cancel settings in all plugins' panels
for (size_t i = 0; i < m_PluginPanels.GetCount(); ++i)
{
cbConfigurationPanel* panel = m_PluginPanels[i];
panel->OnCancel();
}
}
wxScrollingDialog::EndModal(retCode);
}
void FormatterSettings::ApplyTo(astyle::ASFormatter& formatter)
{
// NOTE: Keep this in sync with DlgFormatterSettings::ApplyTo
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("astyle"));
int style = cfg->ReadInt(_T("/style"), 0);
switch (style)
{
case aspsAllman: // Allman (ANSI)
formatter.setFormattingStyle(astyle::STYLE_ALLMAN);
break;
case aspsJava: // Java
formatter.setFormattingStyle(astyle::STYLE_JAVA);
break;
case aspsKr: // K&R
formatter.setFormattingStyle(astyle::STYLE_KR);
break;
case aspsStroustrup: // Stroustrup
formatter.setFormattingStyle(astyle::STYLE_STROUSTRUP);
break;
case aspsWhitesmith: // Whitesmith
formatter.setFormattingStyle(astyle::STYLE_WHITESMITH);
break;
case aspsBanner: // Banner
formatter.setFormattingStyle(astyle::STYLE_BANNER);
break;
case aspsGnu: // GNU
formatter.setFormattingStyle(astyle::STYLE_GNU);
break;
case aspsLinux: // Linux
formatter.setFormattingStyle(astyle::STYLE_LINUX);
break;
case aspsHorstmann: // Horstmann
formatter.setFormattingStyle(astyle::STYLE_HORSTMANN);
break;
case asps1TBS: // 1TBS
formatter.setFormattingStyle(astyle::STYLE_1TBS);
break;
case aspsPico: // Pico
formatter.setFormattingStyle(astyle::STYLE_PICO);
break;
case aspsLisp: // Lisp
formatter.setFormattingStyle(astyle::STYLE_LISP);
break;
default: // Custom
break;
}
bool value = cfg->ReadBool(_T("/force_tabs"));
int spaceNum = cfg->ReadInt(_T("/indentation"), 4);
if (cfg->ReadBool(_T("/use_tabs")))
formatter.setTabIndentation(spaceNum, value);
else
formatter.setSpaceIndentation(spaceNum);
formatter.setClassIndent(cfg->ReadBool(_T("/indent_classes")));
formatter.setSwitchIndent(cfg->ReadBool(_T("/indent_switches")));
formatter.setCaseIndent(cfg->ReadBool(_T("/indent_case")));
formatter.setBracketIndent(cfg->ReadBool(_T("/indent_brackets")));
formatter.setBlockIndent(cfg->ReadBool(_T("/indent_blocks")));
formatter.setNamespaceIndent(cfg->ReadBool(_T("/indent_namespaces")));
formatter.setLabelIndent(cfg->ReadBool(_T("/indent_labels")));
formatter.setPreprocessorIndent(cfg->ReadBool(_T("/indent_preprocessor")));
formatter.setIndentCol1CommentsMode(cfg->ReadBool(_T("/indent_col1_comments")));
wxString pointerAlign = cfg->Read(_T("/pointer_align"));
if (pointerAlign == _T("Type"))
formatter.setPointerAlignment(astyle::PTR_ALIGN_TYPE);
else if (pointerAlign == _T("Middle"))
formatter.setPointerAlignment(astyle::PTR_ALIGN_MIDDLE);
else if (pointerAlign == _T("Name"))
formatter.setPointerAlignment(astyle::PTR_ALIGN_NAME);
else
formatter.setPointerAlignment(astyle::PTR_ALIGN_NONE);
formatter.setBreakClosingHeaderBracketsMode(cfg->ReadBool(_T("/break_closing")));
formatter.setBreakBlocksMode(cfg->ReadBool(_T("/break_blocks")));
formatter.setBreakElseIfsMode(cfg->ReadBool(_T("/break_elseifs")));
formatter.setOperatorPaddingMode(cfg->ReadBool(_T("/pad_operators")));
formatter.setParensOutsidePaddingMode(cfg->ReadBool(_T("/pad_parentheses_out")));
formatter.setParensInsidePaddingMode(cfg->ReadBool(_T("/pad_parentheses_in")));
formatter.setParensHeaderPaddingMode(cfg->ReadBool(_T("/pad_header")));
formatter.setParensUnPaddingMode(cfg->ReadBool(_T("/unpad_parentheses")));
formatter.setDeleteEmptyLinesMode(cfg->ReadBool(_T("/delete_empty_lines")));
formatter.setSingleStatementsMode(!cfg->ReadBool(_T("/keep_complex")));
formatter.setBreakOneLineBlocksMode(!cfg->ReadBool(_T("/keep_blocks")));
formatter.setTabSpaceConversionMode(cfg->ReadBool(_T("/convert_tabs")));
formatter.setEmptyLineFill(cfg->ReadBool(_T("/fill_empty_lines")));
formatter.setAddBracketsMode(cfg->ReadBool(_T("/add_brackets")));
}
void Highlighter::DoSetIndications(cbEditor* ctrl)const
{
cbStyledTextCtrl *stc = ctrl->GetLeftSplitViewControl();
//Returns a pointer to the left (or top) split-view cbStyledTextCtrl. This function always returns a valid pointer.
cbStyledTextCtrl *stcr =ctrl->GetRightSplitViewControl();
if (m_AlreadyChecked && m_OldCtrl == ctrl)
{
if ( m_InvalidatedRangesStart.GetCount() == 0)
return;
}
else
{
//clear:
m_InvalidatedRangesStart.Clear();
m_InvalidatedRangesEnd.Clear();
//add whole document
m_InvalidatedRangesStart.Add(0);
m_InvalidatedRangesEnd.Add(stc->GetLength());
}
m_AlreadyChecked = true;
// Set Styling:
stc->SetIndicatorCurrent(GetIndicator());
//if(stc->SelectionIsRectangle() || (stcr && stcr->SelectionIsRectangle())) return;
if (m_OldCtrl != ctrl)
{
stc->IndicatorSetStyle(GetIndicator(), wxSCI_INDIC_HIGHLIGHT);
stc->IndicatorSetForeground(GetIndicator(), GetIndicatorColor() );
#ifndef wxHAVE_RAW_BITMAP
// If wxWidgets is build without rawbitmap-support, the indicators become opaque
// and hide the text, so we show them under the text.
// Not enabled as default, because the readability is a little bit worse.
stc->IndicatorSetUnder(theIndicator,true);
#endif
}
if (stcr)
{
if (m_OldCtrl != ctrl)
{
stcr->SetIndicatorCurrent(GetIndicator());
stcr->IndicatorSetStyle(GetIndicator(), wxSCI_INDIC_HIGHLIGHT);
stcr->IndicatorSetForeground(GetIndicator(), GetIndicatorColor() );
#ifndef wxHAVE_RAW_BITMAP
stcr->IndicatorSetUnder(theIndicator,true);
#endif
}
}
m_OldCtrl = ctrl;
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("editor"));
int flag = 0;
if (cfg->ReadBool(_T("/highlight_occurrence/case_sensitive_permanently"), true))
flag |= wxSCI_FIND_MATCHCASE;
if (cfg->ReadBool(_T("/highlight_occurrence/whole_word_permanently"), true))
flag |= wxSCI_FIND_WHOLEWORD;
for (int i = 0; i < (int)m_InvalidatedRangesStart.GetCount(); i++)
{
int start = m_InvalidatedRangesStart[i];
int end = m_InvalidatedRangesEnd[i];
//bound:
if (start < 0) start = 0;
if (end < 0) end = 0;
if (start >= stc->GetLength()) start = stc->GetLength() - 1;
if (end > stc->GetLength()) end = stc->GetLength();
if (start != end)
{
//remove styling:
stc->IndicatorClearRange(start, end - start);
for (std::set<wxString>::iterator it = m_Texts.begin();
it != m_Texts.end(); it++ )
{
wxString text = *it;
// search for occurrences
int startpos = start;
int endpos = end;
int lengthFound = 0; // we need this to work properly with multibyte characters
for ( int pos = stc->FindText(startpos, endpos, text, flag, &lengthFound);
pos != wxSCI_INVALID_POSITION ;
pos = stc->FindText(pos+=text.Len(), endpos, text, flag, &lengthFound) )
{
stc->IndicatorFillRange(pos, lengthFound);
}
}
}
}
m_InvalidatedRangesStart.Clear();
m_InvalidatedRangesEnd.Clear();
}
void PlaceWindow(wxTopLevelWindow *w, cbPlaceDialogMode mode, bool enforce)
{
if (!w)
cbThrow(_T("Passed NULL pointer to PlaceWindow."));
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
if (!enforce && cfg->ReadBool(_T("/dialog_placement/do_place")) == false)
return;
wxWindow* referenceWindow = Manager::Get()->GetAppWindow();
if (!referenceWindow) // no application window available, so this is as good as we can get
referenceWindow = w;
int the_mode;
if (mode == pdlBest)
the_mode = cfg->ReadInt(_T("/dialog_placement/dialog_position"), (int) pdlCentre);
else
the_mode = (int) mode;
wxRect monitorRect;
if (wxDisplay::GetCount() > 0)
{
int displayIdx = wxDisplay::GetFromWindow(referenceWindow);
if (displayIdx == wxNOT_FOUND)
displayIdx = 0;
wxDisplay display(displayIdx);
monitorRect = display.GetClientArea();
// This is needed because on Linux the client area returned for the first monitor in a twin
// monitor setup with nVidia card is spanning the two monitors.
// The intersection function will return just the client for the specified monitor.
monitorRect = display.GetGeometry().Intersect(monitorRect);
}
else
{
int width, height;
wxDisplaySize(&width, &height);
monitorRect = wxRect(0, 0, width, height);
}
wxRect windowRect = w->GetRect();
switch(the_mode)
{
case pdlCentre:
{
windowRect.x = monitorRect.x + (monitorRect.width - windowRect.width)/2;
windowRect.y = monitorRect.y + (monitorRect.height - windowRect.height)/2;
}
break;
case pdlHead:
{
windowRect.x = monitorRect.x + (monitorRect.width - windowRect.width)/2;
windowRect.y = monitorRect.y + (monitorRect.height - windowRect.height)/3;
}
break;
case pdlConstrain:
{
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
if (windowRect.width > monitorRect.width) // cannot place without clipping, so centre it
{
x1 = monitorRect.x + (monitorRect.width - windowRect.width)/2;
x2 = x1 + windowRect.width;
}
else
{
x2 = std::min(monitorRect.GetRight(), windowRect.GetRight());
x1 = std::max(x2 - windowRect.width, monitorRect.x);
x2 = x1 + windowRect.width;
}
if (windowRect.height > monitorRect.height) // cannot place without clipping, so centre it
{
y1 = monitorRect.y + (monitorRect.height - windowRect.height)/2;
y2 = y1 + windowRect.height;
}
else
{
y2 = std::min(monitorRect.GetBottom(), windowRect.GetBottom());
y1 = std::max(y2 - windowRect.height, monitorRect.y);
y2 = y1 + windowRect.height;
}
windowRect = wxRect(x1, y1, x2-x1, y2-y1);
}
break;
case pdlClip:
{
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
x1 = std::max(x1, monitorRect.x);
x2 = std::min(x2, monitorRect.GetRight());
y1 = std::max(y1, monitorRect.y);
y2 = std::min(y2, monitorRect.GetBottom());
windowRect = wxRect(x1, y1, x2-x1, y2-y1);
}
break;
}
w->SetSize(windowRect.x, windowRect.y, windowRect.width, windowRect.height, wxSIZE_ALLOW_MINUS_ONE);
}
bool EncodingDetector::ConvertToWxString(const wxByte* buffer, size_t size)
{
LogManager* logmgr = Manager::Get()->GetLogManager();
wxString logmsg;
if (!buffer || size == 0)
{
if (m_UseLog)
{
logmsg.Printf(_T("Encoding conversion has failed (buffer is empty)!"));
logmgr->DebugLog(logmsg);
}
return false; // Nothing we can do...
}
if (m_BOMSizeInBytes > 0)
{
for (int i = 0; i < m_BOMSizeInBytes; ++i)
buffer++;
}
size_t outlen = 0;
/* NOTE (Biplab#5#): FileManager returns a buffer with 4 extra NULL chars appended.
But the buffer size is returned sans the NULL chars */
wxWCharBuffer wideBuff;
// if possible use the special conversion-routines, they are much faster than wxCSCov (at least on linux)
if ( m_Encoding == wxFONTENCODING_UTF7 )
{
wxMBConvUTF7 conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF8 )
{
wxMBConvUTF8 conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF16BE )
{
wxMBConvUTF16BE conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF16LE )
{
wxMBConvUTF16LE conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF32BE )
{
wxMBConvUTF32BE conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF32LE )
{
wxMBConvUTF32LE conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else
{
// try wxEncodingConverter first, even it it only works for
// wxFONTENCODING_ISO8859_1..15, wxFONTENCODING_CP1250..1257 and wxFONTENCODING_KOI8
// but it's much, much faster than wxCSConv (at least on Linux)
wxEncodingConverter conv;
wchar_t* tmp = new wchar_t[size + 4 - m_BOMSizeInBytes];
if ( conv.Init(m_Encoding, wxFONTENCODING_UNICODE)
&& conv.Convert((const char*)buffer, tmp) )
{
wideBuff = tmp;
outlen = size + 4 - m_BOMSizeInBytes; // should be correct, because Convert has returned true
if (m_UseLog && outlen>0)
{
logmsg.Printf(_T("Conversion succeeded using wxEncodingConverter "
"(buffer size = %lu, converted size = %lu."), static_cast<unsigned long>(size), static_cast<unsigned long>(outlen));
logmgr->DebugLog(logmsg);
}
}
else
{
// try wxCSConv, if nothing else works
wxCSConv csconv(m_Encoding);
if (csconv.IsOk())
{
wideBuff = csconv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
if (m_UseLog && outlen>0)
{
logmsg.Printf(_T("Conversion succeeded using wxCSConv "
"(buffer size = %lu, converted size = %lu."), static_cast<unsigned long>(size), static_cast<unsigned long>(outlen));
logmgr->DebugLog(logmsg);
}
}
}
delete [] tmp;
}
if (outlen>0)
{
m_ConvStr = wxString(wideBuff);
return true; // Done.
}
// Here, outlen == 0, so an error occurred during conversion.
if (m_UseLog)
{
logmsg.Printf(_T("Encoding conversion using settings has failed!\n"
"Encoding chosen was: %s (ID: %d)"),
wxFontMapper::Get()->GetEncodingDescription(m_Encoding).wx_str(),
m_Encoding);
logmgr->DebugLog(logmsg);
}
// Try system locale as fall-back (if requested by the settings)
ConfigManager* cfgMgr = Manager::Get()->GetConfigManager(_T("editor"));
if (cfgMgr->ReadBool(_T("/default_encoding/use_system"), true))
{
if (platform::windows)
{
if (m_UseLog)
logmgr->DebugLog(_T("Trying system locale as fallback..."));
m_Encoding = wxLocale::GetSystemEncoding();
}
else
{
// We can rely on the UTF-8 detection code ;-)
if (m_UseLog)
logmgr->DebugLog(_T("Trying ISO-8859-1 as fallback..."));
m_Encoding = wxFONTENCODING_ISO8859_1;
}
wxCSConv conv_system(m_Encoding);
wideBuff = conv_system.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
m_ConvStr = wxString(wideBuff);
if (outlen == 0)
{
if (m_UseLog)
{
logmsg.Printf(_T("Encoding conversion using system locale fallback has failed!\n"
"Last encoding choosen was: %s (ID: %d)\n"
"Don't know what to do."),
wxFontMapper::Get()->GetEncodingDescription(m_Encoding).c_str(),
m_Encoding);
logmgr->DebugLog(logmsg);
}
return false; // Nothing we can do...
}
}
else
{
if (m_UseLog)
{
logmgr->DebugLog(_T("Encoding conversion has seriously failed!\n"
"Don't know what to do."));
}
return false; // Nothing we can do...
}
return true;
}
void PlaceWindow(wxTopLevelWindow *w, cbPlaceDialogMode mode, bool enforce)
{
HMONITOR hMonitor;
MONITORINFO mi;
RECT r;
int the_mode;
if(!w)
cbThrow(_T("Passed NULL pointer to PlaceWindow."));
wxWindow* referenceWindow = Manager::Get()->GetAppWindow();
if(!referenceWindow) // no application window available, so this is as good as we can get
referenceWindow = w;
wxRect windowRect = w->GetRect();
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
if(!enforce && cfg->ReadBool(_T("/dialog_placement/do_place")) == false)
return;
if(mode == pdlBest)
the_mode = cfg->ReadInt(_T("/dialog_placement/dialog_position"), (int) pdlCentre);
else
the_mode = (int) mode;
static MonitorFromWindow_t MonitorFromWindowProc = (MonitorFromWindow_t) GetProcAddress(GetModuleHandle(_T("user32.dll")), "MonitorFromWindow");
static GetMonitorInfo_t GetMonitorInfoProc = (GetMonitorInfo_t) GetProcAddress(GetModuleHandle(_T("user32.dll")), "GetMonitorInfoA");
int monitorWidth;
int monitorHeight;
if(GetMonitorInfoProc)
{
hMonitor = MonitorFromWindowProc((HWND) referenceWindow->GetHandle(), MONITOR_DEFAULTTONEAREST);
mi.cbSize = sizeof(mi);
GetMonitorInfoProc(hMonitor, &mi);
r = mi.rcWork;
monitorWidth = r.right - r.left;
monitorHeight = r.bottom - r. top;
}
else // Win95, NT4: support only single monitor
{
wxDisplaySize(&monitorWidth, &monitorHeight);
r.left = r.top = 0;
}
switch(the_mode)
{
case pdlCentre:
{
windowRect.x = r.left + (monitorWidth - windowRect.width)/2;
windowRect.y = r.top + (monitorHeight - windowRect.height)/2;
}
break;
case pdlHead:
{
windowRect.x = r.left + (monitorWidth - windowRect.width)/2;
windowRect.y = r.top + (monitorHeight - windowRect.height)/3;
}
break;
case pdlConstrain:
{
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
if(windowRect.width > monitorWidth) // cannot place without clipping, so centre it
{
x1 = r.left + (monitorWidth - windowRect.width)/2;
x2 = x1 + windowRect.width;
}
else
{
x2 = std::min((int) r.right, windowRect.GetRight());
x1 = std::max(x2 - windowRect.width, (int) r.left);
x2 = x1 + windowRect.width;
}
if(windowRect.height > monitorHeight) // cannot place without clipping, so centre it
{
y1 = r.top + (monitorHeight - windowRect.height)/2;
y2 = y1 + windowRect.height;
}
else
{
y2 = std::min((int) r.bottom, windowRect.GetBottom());
y1 = std::max(y2 - windowRect.height, (int) r.top);
y2 = y1 + windowRect.height;
}
windowRect = wxRect(x1, y1, x2-x1, y2-y1);
}
break;
case pdlClip:
{
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
x1 = std::max(x1, (int) r.left);
x2 = std::min(x2, (int) r.right);
y1 = std::max(y1, (int) r.top);
y2 = std::min(y2, (int) r.bottom);
windowRect = wxRect(x1, y1, x2-x1, y2-y1);
}
break;
}
w->SetSize(windowRect.x, windowRect.y, windowRect.width, windowRect.height, wxSIZE_ALLOW_MINUS_ONE);
}
void EditorColourSet::Load()
{
// no need for syntax highlighting if batch building
if (Manager::IsBatchBuild())
return;
static bool s_notifiedUser = false;
wxString key;
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("editor"));
// read the theme name
m_Name = cfg->Read(_T("/colour_sets/") + m_Name + _T("/name"), m_Name);
int x = 0;
for (OptionSetsMap::iterator it = m_Sets.begin(); it != m_Sets.end(); ++it)
{
if (it->first == HL_NONE || it->first == HL_AUTO)
continue;
// look for old-style configuration
key.Clear();
key << _T("/colour_sets/") << m_Name << _T("/set") << wxString::Format(_T("%d"), x++);
if (cfg->Exists(key + _T("/name")))
{
// old-style configuration
// delete it and tell the user about it
cfg->DeleteSubPath(key);
if (!s_notifiedUser)
{
cbMessageBox(_("The way editor syntax highlighting configuration is saved, has changed.\n"
"Syntax highlighting for all supported languages will revert to defaults now.\n"
"We 're sorry for the inconvenience..."),
_("Information"),
wxICON_INFORMATION);
s_notifiedUser = true;
}
continue;
}
// make sure we didn't create it accidentally
cfg->DeleteSubPath(key);
// new-style configuration key
key.Clear();
key << _T("/colour_sets/") << m_Name << _T('/') << it->first;
if (!cfg->Exists(key + _T("/name")))
{
// make sure we didn't create it accidentally
cfg->DeleteSubPath(key);
continue;
}
for (unsigned int i = 0; i < it->second.m_Colours.GetCount(); ++i)
{
wxString tmpKey;
tmpKey << key << _T("/style") << wxString::Format(_T("%u"), i);
if (!cfg->Exists(tmpKey + _T("/name")))
{
// make sure we didn't create it accidentally
cfg->DeleteSubPath(tmpKey);
continue;
}
wxString name = cfg->Read(tmpKey + _T("/name"));
for (size_t j = 0; j < it->second.m_Colours.GetCount(); ++j)
{
OptionColour* opt = it->second.m_Colours.Item(j);
if (!opt || opt->name != name)
continue;
if (cfg->Exists(tmpKey + _T("/fore")))
opt->fore = cfg->ReadColour(tmpKey + _T("/fore"), opt->fore);
if (cfg->Exists(tmpKey + _T("/back")))
opt->back = cfg->ReadColour(tmpKey + _T("/back"), opt->back);
if (cfg->Exists(tmpKey + _T("/bold")))
opt->bold = cfg->ReadBool(tmpKey + _T("/bold"), opt->bold);
if (cfg->Exists(tmpKey + _T("/italics")))
opt->italics = cfg->ReadBool(tmpKey + _T("/italics"), opt->italics);
if (cfg->Exists(tmpKey + _T("/underlined")))
opt->underlined = cfg->ReadBool(tmpKey + _T("/underlined"), opt->underlined);
if (cfg->Exists(tmpKey + _T("/isStyle")))
opt->isStyle = cfg->ReadBool(tmpKey + _T("/isStyle"), opt->isStyle);
}
}
wxString tmpkey;
for (int i = 0; i <= wxSCI_KEYWORDSET_MAX; ++i)
{
tmpkey.Printf(_T("%s/editor/keywords/set%d"), key.c_str(), i);
if (cfg->Exists(tmpkey))
it->second.m_Keywords[i] = cfg->Read(tmpkey, wxEmptyString);
}
tmpkey.Printf(_T("%s/editor/filemasks"), key.c_str());
if (cfg->Exists(tmpkey))
it->second.m_FileMasks = GetArrayFromString(cfg->Read(tmpkey, wxEmptyString), _T(","));
}
}
void EnvVarsConfigDlg::LoadSettings()
{
#if defined(TRACE_ENVVARS)
Manager::Get()->GetLogManager()->DebugLog(F(_T("LoadSettings")));
#endif
wxChoice* choSet = XRCCTRL(*this, "choSet", wxChoice);
if (!choSet)
return;
wxCheckListBox* lstEnvVars = XRCCTRL(*this, "lstEnvVars", wxCheckListBox);
if (!lstEnvVars)
return;
wxCheckBox* chkDebugLog = XRCCTRL(*this, "chkDebugLog", wxCheckBox);
if (!chkDebugLog)
return;
// load and apply configuration (to application and GUI)
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("envvars"));
if (!cfg)
return;
choSet->Clear();
lstEnvVars->Clear();
chkDebugLog->SetValue(cfg->ReadBool(_T("/debug_log")));
// Read the currently active envvar set
wxString active_set = nsEnvVars::GetActiveSetName();
int active_set_idx = 0;
// Read all envvar sets available
wxArrayString set_names = nsEnvVars::GetEnvvarSetNames();
unsigned int num_sets = set_names.GetCount();
EV_DBGLOG(_T("EnvVars: Found %u envvar sets in config."), num_sets);
unsigned int num_sets_applied = 0;
for (unsigned int i=0; i<num_sets; ++i)
{
choSet->Append(set_names[i]);
if (active_set.IsSameAs(set_names[i]))
active_set_idx = i;
num_sets_applied++;
}
EV_DBGLOG(_T("EnvVars: Setup %u/%u envvar sets from config."), num_sets_applied, num_sets);
if ((int)choSet->GetCount()>active_set_idx) // Select the last active set (from config)
choSet->SetSelection(active_set_idx);
// Show currently activated set in debug log (for reference)
wxString active_set_path = nsEnvVars::GetSetPathByName(active_set);
EV_DBGLOG(_T("EnvVars: Active envvar set is '%s' at index %d, config path '%s'."),
active_set.wx_str(), active_set_idx, active_set_path.wx_str());
// NOTE: Keep this in sync with nsEnvVars::EnvvarSetApply
// Read and show all envvars from currently active set in listbox
wxArrayString vars = nsEnvVars::GetEnvvarsBySetPath(active_set_path);
size_t envvars_total = vars.GetCount();
size_t envvars_applied = 0;
for (unsigned int i=0; i<envvars_total; ++i)
{
// Format: [checked?]|[key]|[value]
wxArrayString var_array = nsEnvVars::EnvvarStringTokeniser(vars[i]);
if (nsEnvVars::EnvvarArrayApply(var_array, lstEnvVars))
envvars_applied++;
else
{
EV_DBGLOG(_T("EnvVars: Invalid envvar in '%s' at position #%u."),
active_set_path.wx_str(), i);
}
}// for
if (envvars_total>0)
{
EV_DBGLOG(_T("EnvVars: %lu/%lu envvars applied within C::B focus."),
static_cast<unsigned long>(envvars_applied), static_cast<unsigned long>(envvars_total));
}
}// LoadSettings
