void EditorSettingsLocal::DisplayHigherValues(const OptionsConfigPtr options)
{
// There should be 'global' (or workspace if this will be a project setting) values for each setting
// Insert them all, but leave the enabling checkboxes ticked, so the items will be disabled
m_indentsUsesTabs->SetValue(options->GetIndentUsesTabs());
m_indentWidth->SetValue(options->GetIndentWidth());
m_tabWidth->SetValue(options->GetTabWidth());
m_displayLineNumbers->SetValue(options->GetDisplayLineNumbers());
m_showIndentationGuideLines->SetValue(options->GetShowIndentationGuidelines());
m_highlightCaretLine->SetValue(options->GetHighlightCaretLine());
m_checkBoxTrimLine->SetValue(options->GetTrimLine());
m_checkBoxAppendLF->SetValue(options->GetAppendLF());
m_checkBoxHideChangeMarkerMargin->SetValue(options->GetHideChangeMarkerMargin());
m_checkBoxDisplayFoldMargin->SetValue(options->GetDisplayFoldMargin());
m_displayBookmarkMargin->SetValue(options->GetDisplayBookmarkMargin());
const wxString WhitespaceStyle[] = { wxTRANSLATE("Invisible"), wxTRANSLATE("Visible always"),
wxTRANSLATE("Visible after indentation"), wxTRANSLATE("Indentation only") };
wxString currentWhitespace;
switch(options->GetShowWhitspaces()) {
case wxSTC_WS_VISIBLEALWAYS:
currentWhitespace = wxT("Visible always");
break;
case wxSTC_WS_VISIBLEAFTERINDENT:
currentWhitespace = wxT("Visible after indentation");
break;
default:
currentWhitespace = wxT("Invisible");
break;
}
m_WSstringManager.AddStrings(
sizeof(WhitespaceStyle) / sizeof(wxString), WhitespaceStyle, currentWhitespace, m_whitespaceStyle);
const wxString EOLChoices[] = { wxTRANSLATE("Default"), wxT("Mac (CR)"), wxT("Windows (CRLF)"), wxT("Unix (LF)") };
m_EOLstringManager.AddStrings(
sizeof(EOLChoices) / sizeof(wxString), EOLChoices, options->GetEolMode(), m_choiceEOL);
wxArrayString astrEncodings;
wxFontEncoding fontEnc;
int iCurrSelId = 0;
size_t iEncCnt = wxFontMapper::GetSupportedEncodingsCount();
for(size_t i = 0; i < iEncCnt; i++) {
fontEnc = wxFontMapper::GetEncoding(i);
if(wxFONTENCODING_SYSTEM == fontEnc) { // skip system, it is changed to UTF-8 in optionsconfig
continue;
}
astrEncodings.Add(wxFontMapper::GetEncodingName(fontEnc));
if(fontEnc == options->GetFileFontEncoding()) {
iCurrSelId = i;
}
}
m_fileEncoding->Append(astrEncodings);
m_fileEncoding->SetSelection(iCurrSelId);
}
void FindResultsTab::SetStyles(wxStyledTextCtrl* sci)
{
LexerConf::Ptr_t lexer = ColoursAndFontsManager::Get().GetLexer("c++");
if(!lexer) {
lexer = ColoursAndFontsManager::Get().GetLexer("text");
}
const StyleProperty& defaultStyle = lexer->GetProperty(0);
wxFont defaultFont = lexer->GetFontForSyle(0);
for(size_t i = 0; i < wxSTC_STYLE_MAX; ++i) {
sci->StyleSetForeground(i, defaultStyle.GetFgColour());
sci->StyleSetBackground(i, defaultStyle.GetBgColour());
sci->StyleSetFont(i, defaultFont);
}
// Show/hide whitespace
sci->SetViewWhiteSpace(EditorConfigST::Get()->GetOptions()->GetShowWhitspaces());
StyleProperty::Map_t& props = lexer->GetLexerProperties();
// Set the whitespace colours
sci->SetWhitespaceForeground(true, props[WHITE_SPACE_ATTR_ID].GetFgColour());
sci->StyleSetForeground(LEX_FIF_HEADER, props[11].GetFgColour());
sci->StyleSetBackground(LEX_FIF_HEADER, props[11].GetBgColour());
// 33 is the style for line numbers
sci->StyleSetForeground(LEX_FIF_LINE_NUMBER, props[33].GetFgColour());
// 11 is the style number for "identifier"
sci->StyleSetForeground(LEX_FIF_MATCH, props[11].GetFgColour());
// 16 is the stule for colouring classes
sci->StyleSetForeground(LEX_FIF_SCOPE, props[16].GetFgColour());
sci->StyleSetForeground(LEX_FIF_MATCH_COMMENT, props[wxSTC_C_COMMENTLINE].GetFgColour());
sci->StyleSetForeground(LEX_FIF_FILE, props[wxSTC_C_WORD].GetFgColour());
sci->StyleSetEOLFilled(LEX_FIF_FILE, true);
sci->StyleSetForeground(LEX_FIF_DEFAULT, props[11].GetFgColour());
sci->StyleSetBackground(LEX_FIF_DEFAULT, props[11].GetBgColour());
sci->StyleSetHotSpot(LEX_FIF_MATCH, true);
sci->StyleSetHotSpot(LEX_FIF_FILE, true);
sci->StyleSetHotSpot(LEX_FIF_MATCH_COMMENT, true);
sci->SetHotspotActiveForeground(true, lexer->IsDark() ? "WHITE" : "BLACK");
sci->SetHotspotActiveUnderline(false);
sci->MarkerDefine(7, wxSTC_MARK_ARROW);
#if wxVERSION_NUMBER < 3100
// On GTK we dont have the wxSTC_INDIC_TEXTFORE symbol yet (old wx version)
sci->MarkerDefine(7, wxSTC_MARK_ARROW);
sci->MarkerSetBackground(7, lexer->IsDark() ? "CYAN" : "ORANGE");
sci->MarkerSetForeground(7, lexer->IsDark() ? "CYAN" : "ORANGE");
sci->IndicatorSetForeground(1, lexer->IsDark() ? "CYAN" : "ORANGE");
sci->IndicatorSetStyle(1, wxSTC_INDIC_ROUNDBOX);
#else
sci->MarkerDefine(7, wxSTC_MARK_ARROW);
sci->MarkerSetBackground(7, lexer->IsDark() ? "#FFD700" : "#FF4500");
sci->MarkerSetForeground(7, lexer->IsDark() ? "#FFD700" : "#FF4500");
sci->IndicatorSetForeground(1, lexer->IsDark() ? "#FFD700" : "#FF4500");
sci->IndicatorSetStyle(1, wxSTC_INDIC_TEXTFORE);
#endif
sci->IndicatorSetUnder(1, true);
sci->SetMarginWidth(0, 0);
sci->SetMarginWidth(1, 16);
sci->SetMarginWidth(2, 0);
sci->SetMarginWidth(3, 0);
sci->SetMarginWidth(4, 0);
sci->SetMarginSensitive(1, true);
sci->HideSelection(true);
// Indentation
OptionsConfigPtr options = EditorConfigST::Get()->GetOptions();
sci->SetUseTabs(options->GetIndentUsesTabs());
sci->SetTabWidth(options->GetIndentWidth());
sci->SetIndent(options->GetIndentWidth());
sci->Refresh();
}
void LexerConf::Apply(wxStyledTextCtrl* ctrl, bool applyKeywords)
{
ctrl->SetLexer(GetLexerId());
ctrl->StyleClearAll();
ctrl->SetStyleBits(ctrl->GetStyleBitsNeeded());
OptionsConfigPtr options = EditorConfigST::Get()->GetOptions();
bool tooltip(false);
const StyleProperty::Map_t& styles = GetLexerProperties();
ctrl->SetProperty(wxT("styling.within.preprocessor"), this->GetStyleWithinPreProcessor() ? wxT("1") : wxT("0"));
// turn off PP tracking/updating by default
ctrl->SetProperty(wxT("lexer.cpp.track.preprocessor"), wxT("0"));
ctrl->SetProperty(wxT("lexer.cpp.update.preprocessor"), wxT("0"));
if(GetName() == "scss") {
// Enable SCSS property (will tell the lexer to search for variables)
ctrl->SetProperty("lexer.css.scss.language", "1");
}
ctrl->SetUseAntiAliasing(true);
// Find the default style
wxFont defaultFont;
bool foundDefaultStyle = false;
int nDefaultFontSize = DEFAULT_FONT_SIZE;
StyleProperty defaultStyle;
StyleProperty::Map_t::const_iterator iter = styles.begin();
for(; iter != styles.end(); ++iter) {
const StyleProperty& prop = iter->second;
if(prop.GetId() == 0) {
defaultStyle = prop;
wxString fontFace = prop.GetFaceName().IsEmpty() ? DEFAULT_FACE_NAME : prop.GetFaceName();
if(!prop.GetFaceName().IsEmpty()) {
nDefaultFontSize = prop.GetFontSize();
}
defaultFont = wxFont(nDefaultFontSize,
wxFONTFAMILY_TELETYPE,
prop.GetItalic() ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL,
prop.IsBold() ? wxFONTWEIGHT_BOLD : wxFONTWEIGHT_NORMAL,
prop.GetUnderlined(),
fontFace);
foundDefaultStyle = true;
break;
}
}
// Reset all colours to use the default style colour
if(foundDefaultStyle) {
for(int i = 0; i < 256; i++) {
ctrl->StyleSetBackground(i, defaultStyle.GetBgColour());
ctrl->StyleSetForeground(i, defaultStyle.GetFgColour());
}
}
if(foundDefaultStyle && defaultFont.IsOk()) {
for(int i = 0; i < 256; i++) {
ctrl->StyleSetFont(i, defaultFont);
}
}
iter = styles.begin();
for(; iter != styles.end(); ++iter) {
StyleProperty sp = iter->second;
int size = nDefaultFontSize;
wxString face = sp.GetFaceName();
bool bold = sp.IsBold();
bool italic = sp.GetItalic();
bool underline = sp.GetUnderlined();
// int alpha = sp.GetAlpha();
// handle special cases
switch(sp.GetId()) {
case WHITE_SPACE_ATTR_ID: {
// whitespace colour. We dont allow changing the background colour, only the foreground colour
wxColour whitespaceColour = sp.GetFgColour();
if(whitespaceColour.IsOk()) {
ctrl->SetWhitespaceForeground(true, whitespaceColour);
}
break;
}
case FOLD_MARGIN_ATTR_ID:
// fold margin foreground colour
ctrl->SetFoldMarginColour(true, sp.GetBgColour());
ctrl->SetFoldMarginHiColour(true, sp.GetFgColour());
break;
case SEL_TEXT_ATTR_ID: {
// selection colour
if(wxColour(sp.GetBgColour()).IsOk()) {
ctrl->SetSelBackground(true, sp.GetBgColour());
}
if(IsUseCustomTextSelectionFgColour() && wxColour(sp.GetFgColour()).IsOk()) {
ctrl->SetSelForeground(true, sp.GetFgColour());
} else {
// provide a "dummy" selection colour (we pass 'false' so it does not matter
// which colour we use here)
ctrl->SetSelForeground(false, wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
}
break;
}
case CARET_ATTR_ID: {
// caret colour
wxColour caretColour = sp.GetFgColour();
if(!caretColour.IsOk()) {
caretColour = *wxBLACK;
}
ctrl->SetCaretForeground(caretColour);
break;
}
default: {
wxString faceName = face;
int fontSize(size);
if(face.IsEmpty()) {
// defaults
fontSize = nDefaultFontSize;
faceName = DEFAULT_FACE_NAME;
}
wxFontInfo fontInfo = wxFontInfo(fontSize)
.Family(wxFONTFAMILY_TELETYPE)
.Italic(italic)
.Bold(bold)
.Underlined(underline)
.FaceName(faceName.IsEmpty() ? DEFAULT_FACE_NAME : faceName);
wxFont font(fontInfo);
if(sp.GetId() == 0) { // default
ctrl->StyleSetFont(wxSTC_STYLE_DEFAULT, font);
ctrl->StyleSetSize(wxSTC_STYLE_DEFAULT, size);
ctrl->StyleSetForeground(wxSTC_STYLE_DEFAULT, iter->second.GetFgColour());
// Set the inactive state colours
// Inactive state is greater by 64 from its counterpart
wxColor inactiveColor = GetInactiveColor(defaultStyle);
ctrl->StyleSetForeground(wxSTC_STYLE_DEFAULT + 64, inactiveColor);
ctrl->StyleSetFont(wxSTC_STYLE_DEFAULT + 64, font);
ctrl->StyleSetSize(wxSTC_STYLE_DEFAULT + 64, size);
ctrl->StyleSetBackground(wxSTC_STYLE_DEFAULT + 64, iter->second.GetBgColour());
ctrl->StyleSetBackground(wxSTC_STYLE_DEFAULT, iter->second.GetBgColour());
ctrl->StyleSetSize(wxSTC_STYLE_LINENUMBER, size);
} else if(sp.GetId() == wxSTC_STYLE_CALLTIP) {
tooltip = true;
if(sp.GetFaceName().IsEmpty()) {
font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
fontSize = font.GetPointSize();
}
}
ctrl->StyleSetFont(sp.GetId(), font);
ctrl->StyleSetSize(sp.GetId(), fontSize);
ctrl->StyleSetEOLFilled(sp.GetId(), iter->second.GetEolFilled());
if(iter->second.GetId() == LINE_NUMBERS_ATTR_ID) {
// Set the line number colours only if requested
// otherwise, use default colours provided by scintilla
if(sp.GetBgColour().IsEmpty() == false) ctrl->StyleSetBackground(sp.GetId(), sp.GetBgColour());
if(sp.GetFgColour().IsEmpty() == false)
ctrl->StyleSetForeground(sp.GetId(), sp.GetFgColour());
else
ctrl->StyleSetForeground(sp.GetId(), wxT("BLACK"));
} else {
ctrl->StyleSetForeground(sp.GetId(), sp.GetFgColour());
// Inactive state is greater by 64 from its counterpart
wxColor inactiveColor = GetInactiveColor(sp);
ctrl->StyleSetForeground(sp.GetId() + 64, inactiveColor);
ctrl->StyleSetFont(sp.GetId() + 64, font);
ctrl->StyleSetSize(sp.GetId() + 64, size);
ctrl->StyleSetBackground(sp.GetId() + 64, defaultStyle.GetBgColour());
ctrl->StyleSetBackground(sp.GetId(), sp.GetBgColour());
}
break;
}
} // switch
}
// set the calltip font
if(!tooltip) {
wxFont font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
ctrl->StyleSetFont(wxSTC_STYLE_CALLTIP, font);
}
if(applyKeywords) {
ctrl->SetKeyWords(0, GetKeyWords(0));
ctrl->SetKeyWords(1, GetKeyWords(1));
ctrl->SetKeyWords(2, GetKeyWords(2));
ctrl->SetKeyWords(3, GetKeyWords(3));
ctrl->SetKeyWords(4, GetKeyWords(4));
}
// by default indicators are set to be opaque rounded box
if(DrawingUtils::IsDark(defaultStyle.GetBgColour())) {
ctrl->IndicatorSetStyle(1, wxSTC_INDIC_BOX);
ctrl->IndicatorSetStyle(2, wxSTC_INDIC_BOX);
} else {
ctrl->IndicatorSetStyle(1, wxSTC_INDIC_ROUNDBOX);
ctrl->IndicatorSetStyle(2, wxSTC_INDIC_ROUNDBOX);
}
// Annotations markers
// Warning style
wxColour textColour = IsDark() ? *wxWHITE : *wxBLACK;
ctrl->StyleSetBackground(ANNOTATION_STYLE_WARNING, defaultStyle.GetBgColour());
ctrl->StyleSetForeground(ANNOTATION_STYLE_WARNING, textColour);
ctrl->StyleSetSizeFractional(ANNOTATION_STYLE_WARNING, (ctrl->StyleGetSizeFractional(wxSTC_STYLE_DEFAULT) * 4) / 5);
// Error style
ctrl->StyleSetBackground(ANNOTATION_STYLE_ERROR, defaultStyle.GetBgColour());
ctrl->StyleSetForeground(ANNOTATION_STYLE_ERROR, textColour);
ctrl->StyleSetSizeFractional(ANNOTATION_STYLE_ERROR, (ctrl->StyleGetSizeFractional(wxSTC_STYLE_DEFAULT) * 4) / 5);
// Code completion errors
ctrl->StyleSetBackground(ANNOTATION_STYLE_CC_ERROR, defaultStyle.GetBgColour());
ctrl->StyleSetForeground(ANNOTATION_STYLE_CC_ERROR, textColour);
ctrl->StyleSetSizeFractional(ANNOTATION_STYLE_CC_ERROR,
(ctrl->StyleGetSizeFractional(wxSTC_STYLE_DEFAULT) * 4) / 5);
// annotation style 'boxed'
ctrl->AnnotationSetVisible(wxSTC_ANNOTATION_BOXED);
// Define the styles for the editing margin
ctrl->StyleSetBackground(CL_LINE_SAVED_STYLE, wxColour(wxT("FOREST GREEN")));
ctrl->StyleSetBackground(CL_LINE_MODIFIED_STYLE, wxColour(wxT("ORANGE")));
// Indentation
ctrl->SetUseTabs(options->GetIndentUsesTabs());
ctrl->SetTabWidth(options->GetIndentWidth());
ctrl->SetIndent(options->GetIndentWidth());
}
void WizardsPlugin::CreateClass(const NewClassInfo &info)
{
// Start by finding the best choice for tabs/spaces.
// Use the preference for the target VirtualDir, not the active project, in case the user perversely adds to an inactive one.
OptionsConfigPtr options = EditorConfigST::Get()->GetOptions(); // Globals first
wxString TargetProj = info.virtualDirectory.BeforeFirst(wxT(':'));
if (!TargetProj.empty()) {
LocalWorkspaceST::Get()->GetOptions(options, TargetProj); // Then override with any local ones
}
wxString separator(wxT("\t"));
if (!options->GetIndentUsesTabs()) {
separator = wxString(wxT(' '), wxMax(1, options->GetTabWidth()));
}
wxString macro(info.blockGuard);
if( macro.IsEmpty() ) {
// use the name instead
macro = info.name;
macro.MakeUpper();
macro << (info.hppHeader ? wxT("_HPP") : wxT("_H"));
}
wxString headerExt = (info.hppHeader ? wxT(".hpp") : wxT(".h"));
wxString srcFile;
srcFile << info.path << wxFileName::GetPathSeparator() << info.fileName << wxT(".cpp");
wxString hdrFile;
hdrFile << info.path << wxFileName::GetPathSeparator() << info.fileName << headerExt;
//create cpp + h file
wxString cpp;
wxString header;
//----------------------------------------------------
// header file
//----------------------------------------------------
header << wxT("#ifndef ") << macro << wxT("\n");
header << wxT("#define ") << macro << wxT("\n");
header << wxT("\n");
wxString closeMethod;
if (info.isInline)
closeMethod << wxT('\n') << separator << wxT("{\n") << separator << wxT("}\n");
else
closeMethod = wxT(";\n");
// Add include for base classes
if (info.parents.empty() == false) {
for (size_t i=0; i< info.parents.size(); i++) {
ClassParentInfo pi = info.parents.at(i);
// Include the header name only (no paths)
wxFileName includeFileName(pi.fileName);
header << wxT("#include \"") << includeFileName.GetFullName() << wxT("\" // Base class: ") << pi.name << wxT("\n");
}
header << wxT("\n");
}
// Open namespace
if (!info.namespacesList.IsEmpty()) {
WriteNamespacesDeclaration (info.namespacesList, header);
}
header << wxT("class ") << info.name;
if (info.parents.empty() == false) {
header << wxT(" : ");
for (size_t i=0; i< info.parents.size(); i++) {
ClassParentInfo pi = info.parents.at(i);
header << pi.access << wxT(" ") << pi.name << wxT(", ");
}
header = header.BeforeLast(wxT(','));
}
header << wxT("\n{\n");
if (info.isSingleton) {
header << separator << wxT("static ") << info.name << wxT("* ms_instance;\n\n");
}
if (info.isAssingable == false) {
//declare copy constructor & assingment operator as private
header << wxT("private:\n");
header << separator << info.name << wxT("(const ") << info.name << wxT("& rhs)") << closeMethod;
header << separator << info.name << wxT("& operator=(const ") << info.name << wxT("& rhs)") << closeMethod;
header << wxT("\n");
}
if (info.isSingleton) {
header << wxT("public:\n");
header << separator << wxT("static ") << info.name << wxT("* Instance();\n");
header << separator << wxT("static void Release();\n\n");
header << wxT("private:\n");
header << separator << info.name << wxT("();\n");
if (info.isVirtualDtor) {
header << separator << wxT("virtual ~") << info.name << wxT("();\n\n");
} else {
header << separator << wxT('~') << info.name << wxT("();\n\n");
}
} else {
header << wxT("public:\n");
header << separator << info.name << wxT("()") << closeMethod;
if (info.isVirtualDtor) {
header << separator << wxT("virtual ~") << info.name << wxT("()") << closeMethod << wxT("\n");
} else {
header << separator << wxT('~') << info.name << wxT("()") << closeMethod << wxT("\n");
}
}
//add virtual function declaration
wxString v_decl = DoGetVirtualFuncDecl(info, separator);
if (v_decl.IsEmpty() == false) {
header << wxT("public:\n");
header << v_decl;
}
header << wxT("};\n\n");
// Close namespaces
for (unsigned int i = 0; i < info.namespacesList.Count(); i++) {
header << wxT("}\n\n");
}
header << wxT("#endif // ") << macro << wxT("\n");
wxFFile file;
file.Open(hdrFile, wxT("w+b"));
file.Write(header);
file.Close();
//if we have a selected virtual folder, add the files to it
wxArrayString paths;
paths.Add(hdrFile);
//----------------------------------------------------
// source file
//----------------------------------------------------
if (!info.isInline) {
cpp << wxT("#include \"") << info.fileName << headerExt << wxT("\"\n\n");
// Open namespace
if (!info.namespacesList.IsEmpty()) {
WriteNamespacesDeclaration (info.namespacesList, cpp);
}
if (info.isSingleton) {
cpp << info.name << wxT("* ") << info.name << wxT("::ms_instance = 0;\n\n");
}
//ctor/dtor
cpp << info.name << wxT("::") << info.name << wxT("()\n");
cpp << wxT("{\n}\n\n");
cpp << info.name << wxT("::~") << info.name << wxT("()\n");
cpp << wxT("{\n}\n\n");
if (info.isSingleton) {
cpp << info.name << wxT("* ") << info.name << wxT("::Instance()\n");
cpp << wxT("{\n");
cpp << separator << wxT("if (ms_instance == 0) {\n");
cpp << separator << separator << wxT("ms_instance = new ") << info.name << wxT("();\n");
cpp << separator << wxT("}\n");
cpp << separator << wxT("return ms_instance;\n");
cpp << wxT("}\n\n");
cpp << wxT("void ") << info.name << wxT("::Release()\n");
cpp << wxT("{\n");
cpp << separator << wxT("if (ms_instance) {\n");
cpp << separator << separator << wxT("delete ms_instance;\n");
cpp << separator << wxT("}\n");
cpp << separator << wxT("ms_instance = 0;\n");
cpp << wxT("}\n\n");
}
cpp << DoGetVirtualFuncImpl(info);
// Close namespaces
if (info.namespacesList.Count()) {
cpp << wxT('\n'); // Thow in an initial \n to separate the first namespace '}' from the previous function's one
}
for (unsigned int i = 0; i < info.namespacesList.Count(); i++) {
cpp << wxT("}\n\n");
}
file.Open(srcFile, wxT("w+b"));
file.Write(cpp);
file.Close();
paths.Add(srcFile);
}
// We have a .cpp and an .h file, and there may well be a :src and an :include folder available
// So try to place the files appropriately. If that fails, dump both in the selected folder
bool smartAddFiles = EditorConfigST::Get()->GetOptions()->GetOptions() & OptionsConfig::Opt_SmartAddFiles;
if (!smartAddFiles || ! m_mgr->AddFilesToVirtualFolderIntelligently(info.virtualDirectory, paths) )
m_mgr->AddFilesToVirtualFolder(info.virtualDirectory, paths);
// Open the newly created classes in codelite
for(size_t i=0; i<paths.GetCount(); i++) {
m_mgr->OpenFile(paths.Item(i));
}
// Notify codelite to parse the files
wxCommandEvent parseEvent(wxEVT_COMMAND_MENU_SELECTED, XRCID("retag_workspace"));
EventNotifier::Get()->TopFrame()->GetEventHandler()->AddPendingEvent(parseEvent);
}
