inline void ClearData() { for(UINT i=0; i<windowData.Num(); i++) windowData[i].strClass.Clear(); windowData.Clear(); adminWindows.Clear(); opposingBitWindows.Clear(); }
void STDCALL TraceCrashEnd() { String strStackTrace = TEXT("\r\nException Fault - Stack Trace:"); for(unsigned int i=0; i<TraceFuncList.Num(); i++) { if(i) strStackTrace << TEXT(" -> "); if(!(i%10)) strStackTrace << TEXT("\r\n "); strStackTrace << TraceFuncList[i]; } if(TraceFuncList.Num() == MAX_STACK_TRACE) strStackTrace << TEXT(" -> ..."); String strOut = FormattedString(TEXT("%s\r\n"), strStackTrace.Array()); OpenLogFile(); LogFile.WriteAsUTF8(strOut, strOut.Length()); LogFile.WriteAsUTF8(TEXT("\r\n")); CloseLogFile(); OSMessageBox(TEXT("Error: Exception fault - More info in the log file.\r\n\r\nMake sure you're using the latest verison, otherwise send your log to [email protected]")); TraceFuncList.Clear(); CriticalExit(); }
size_t StringList::AutoComplete (const char *s, StringList &matches, size_t &exact_idx) const { matches.Clear(); exact_idx = SIZE_MAX; if (s && s[0]) { const size_t s_len = strlen (s); const size_t num_strings = m_strings.size(); for (size_t i=0; i<num_strings; ++i) { if (m_strings[i].find(s) == 0) { if (exact_idx == SIZE_MAX && m_strings[i].size() == s_len) exact_idx = matches.GetSize(); matches.AppendString (m_strings[i]); } } } else { // No string, so it matches everything matches = *this; } return matches.GetSize(); }
size_t OptionValue::AutoComplete(CommandInterpreter &interpreter, const char *s, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { word_complete = false; matches.Clear(); return matches.GetSize(); }
int CommandObjectRegexCommand::HandleCompletion (Args &input, int &cursor_index, int &cursor_char_position, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { if (m_completion_type_mask) { std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, m_completion_type_mask, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } else { matches.Clear(); word_complete = false; } return 0; }
size_t OptionValueEnumeration::AutoComplete (CommandInterpreter &interpreter, const char *s, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { word_complete = false; matches.Clear(); const uint32_t num_enumerators = m_enumerations.GetSize(); if (s && s[0]) { const size_t s_len = strlen(s); for (size_t i=0; i<num_enumerators; ++i) { const char *name = m_enumerations.GetCStringAtIndex(i); if (::strncmp(s, name, s_len) == 0) matches.AppendString(name); } } else { // only suggest "true" or "false" by default for (size_t i=0; i<num_enumerators; ++i) matches.AppendString(m_enumerations.GetCStringAtIndex(i)); } return matches.GetSize(); }
inline void ClearData() { for(UINT i=0; i<windowData.Num(); i++) { windowData[i].strClass.Clear(); windowData[i].strExecutable.Clear(); } windowData.Clear(); adminWindows.Clear(); }
int CommandObjectProxy::HandleArgumentCompletion( Args &input, int &cursor_index, int &cursor_char_position, OptionElementVector &opt_element_vector, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { CommandObject *proxy_command = GetProxyCommandObject(); if (proxy_command) return proxy_command->HandleArgumentCompletion( input, cursor_index, cursor_char_position, opt_element_vector, match_start_point, max_return_elements, word_complete, matches); matches.Clear(); return 0; }
int REPL::IOHandlerComplete(IOHandler &io_handler, const char *current_line, const char *cursor, const char *last_char, int skip_first_n_matches, int max_matches, StringList &matches) { matches.Clear(); llvm::StringRef line(current_line, cursor - current_line); // Complete an LLDB command if the first character is a colon... if (!line.empty() && line[0] == ':') { Debugger &debugger = m_target.GetDebugger(); // auto complete LLDB commands const char *lldb_current_line = line.substr(1).data(); return debugger.GetCommandInterpreter().HandleCompletion( lldb_current_line, cursor, last_char, skip_first_n_matches, max_matches, matches); } // Strip spaces from the line and see if we had only spaces line = line.ltrim(); if (line.empty()) { // Only spaces on this line, so just indent matches.AppendString(m_indent_str); return 1; } std::string current_code; current_code.append(m_code.CopyList()); IOHandlerEditline &editline = static_cast<IOHandlerEditline &>(io_handler); const StringList *current_lines = editline.GetCurrentLines(); if (current_lines) { const uint32_t current_line_idx = editline.GetCurrentLineIndex(); if (current_line_idx < current_lines->GetSize()) { for (uint32_t i = 0; i < current_line_idx; ++i) { const char *line_cstr = current_lines->GetStringAtIndex(i); if (line_cstr) { current_code.append("\n"); current_code.append(line_cstr); } } } } if (cursor > current_line) { current_code.append("\n"); current_code.append(current_line, cursor - current_line); } return CompleteCode(current_code, matches); }
StringList For::Evaluate(EvaluationContext& context) { // get the loop variable -- we ignore all but the first element of the // variable list const StringList& variables = fVariable->Evaluate(context); if (variables.IsEmpty()) return StringList::False(); // look for a local variable StringList* variableValue = context.LocalScope()->Lookup(variables.Head()); if (variableValue == NULL) { // no local variable -- check for a global one variableValue = context.GlobalVariables()->Lookup(variables.Head()); if (variableValue == NULL) { // no existing global variable either -- create one variableValue = &context.GlobalVariables()->LookupOrCreate( variables.Head()); } } // perform the for loop StringList result; const StringList& list = fList->Evaluate(context); for (StringList::Iterator it = list.GetIterator(); it.HasNext();) { // assign the variable variableValue->Clear(); variableValue->Append(it.Next()); // execute the block result = fBlock->Evaluate(context); // handle jump conditions switch (context.GetJumpCondition()) { case JUMP_CONDITION_NONE: break; case JUMP_CONDITION_BREAK: context.SetJumpCondition(JUMP_CONDITION_NONE); return result; case JUMP_CONDITION_CONTINUE: context.SetJumpCondition(JUMP_CONDITION_NONE); break; case JUMP_CONDITION_RETURN: case JUMP_CONDITION_JUMP_TO_EOF: case JUMP_CONDITION_EXIT: return result; } } return result; }
void XElement::GetStringList(CTSTR lpName, StringList &stringList) const { assert(lpName); stringList.Clear(); for(DWORD i=0; i<SubItems.Num(); i++) { if(!SubItems[i]->IsData()) continue; XDataItem *item = static_cast<XDataItem*>(SubItems[i]); if(item->strName.CompareI(lpName)) stringList << item->strData; } }
size_t OptionValueUUID::AutoComplete (CommandInterpreter &interpreter, const char *s, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { word_complete = false; matches.Clear(); ExecutionContext exe_ctx(interpreter.GetExecutionContext()); Target *target = exe_ctx.GetTargetPtr(); if (target) { const size_t num_modules = target->GetImages().GetSize(); if (num_modules > 0) { UUID::ValueType uuid_bytes; const size_t num_bytes_decoded = UUID::DecodeUUIDBytesFromCString(s, uuid_bytes, NULL); for (size_t i=0; i<num_modules; ++i) { ModuleSP module_sp (target->GetImages().GetModuleAtIndex(i)); if (module_sp) { const UUID &module_uuid = module_sp->GetUUID(); if (module_uuid.IsValid()) { bool add_uuid = false; if (num_bytes_decoded == 0) add_uuid = true; else add_uuid = ::memcmp(module_uuid.GetBytes(), uuid_bytes, num_bytes_decoded) == 0; if (add_uuid) { std::string uuid_str; uuid_str = module_uuid.GetAsString(); if (!uuid_str.empty()) matches.AppendString(uuid_str.c_str()); } } } } } } return matches.GetSize(); }
size_t Host::GetEnvironment(StringList &env) { // The environment block on Windows is a contiguous buffer of NULL terminated strings, // where the end of the environment block is indicated by two consecutive NULLs. LPCH environment_block = ::GetEnvironmentStrings(); env.Clear(); while (*environment_block != '\0') { llvm::StringRef current_var(environment_block); if (current_var[0] != '=') env.AppendString(current_var); environment_block += current_var.size()+1; } return env.GetSize(); }
size_t OptionValueBoolean::AutoComplete (CommandInterpreter &interpreter, const char *s, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { word_complete = false; matches.Clear(); struct StringEntry { const char *string; const size_t length; }; static const StringEntry g_autocomplete_entries[] = { { "true" , 4 }, { "false", 5 }, { "on" , 2 }, { "off" , 3 }, { "yes" , 3 }, { "no" , 2 }, { "1" , 1 }, { "0" , 1 }, }; const size_t k_num_autocomplete_entries = llvm::array_lengthof(g_autocomplete_entries); if (s && s[0]) { const size_t s_len = strlen(s); for (size_t i=0; i<k_num_autocomplete_entries; ++i) { if (s_len <= g_autocomplete_entries[i].length) if (::strncasecmp(s, g_autocomplete_entries[i].string, s_len) == 0) matches.AppendString(g_autocomplete_entries[i].string); } } else { // only suggest "true" or "false" by default for (size_t i=0; i<2; ++i) matches.AppendString(g_autocomplete_entries[i].string); } return matches.GetSize(); }
size_t OptionValueFileSpec::AutoComplete (CommandInterpreter &interpreter, const char *s, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { word_complete = false; matches.Clear(); CommandCompletions::InvokeCommonCompletionCallbacks (interpreter, m_completion_mask, s, match_start_point, max_return_elements, NULL, word_complete, matches); return matches.GetSize(); }
size_t OptionValueArch::AutoComplete (CommandInterpreter &interpreter, const char *s, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { word_complete = false; matches.Clear(); CommandCompletions::InvokeCommonCompletionCallbacks (interpreter, CommandCompletions::eArchitectureCompletion, s, match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); }
void OBS::GetProfiles(StringList &profileList) { String strProfilesWildcard; OSFindData ofd; HANDLE hFind; profileList.Clear(); strProfilesWildcard << lpAppDataPath << TEXT("\\profiles\\*.ini"); if(hFind = OSFindFirstFile(strProfilesWildcard, ofd)) { do { if(ofd.bDirectory) continue; profileList << GetPathWithoutExtension(ofd.fileName); } while(OSFindNextFile(hFind, ofd)); OSFindClose(hFind); } }
size_t StringList::AutoComplete(llvm::StringRef s, StringList &matches, size_t &exact_idx) const { matches.Clear(); exact_idx = SIZE_MAX; if (s.empty()) { // No string, so it matches everything matches = *this; return matches.GetSize(); } const size_t s_len = s.size(); const size_t num_strings = m_strings.size(); for (size_t i = 0; i < num_strings; ++i) { if (m_strings[i].find(s) == 0) { if (exact_idx == SIZE_MAX && m_strings[i].size() == s_len) exact_idx = matches.GetSize(); matches.AppendString(m_strings[i]); } } return matches.GetSize(); }
bool CommandObjectHelp::Execute (Args& command, CommandReturnObject &result) { CommandObject::CommandMap::iterator pos; CommandObject *cmd_obj; const int argc = command.GetArgumentCount (); // 'help' doesn't take any options or arguments, other than command names. If argc is 0, we show the user // all commands and aliases. Otherwise every argument must be the name of a command or a sub-command. if (argc == 0) { result.SetStatus (eReturnStatusSuccessFinishNoResult); m_interpreter.GetHelp (result); // General help, for ALL commands. } else { // Get command object for the first command argument. Only search built-in command dictionary. StringList matches; cmd_obj = m_interpreter.GetCommandObject (command.GetArgumentAtIndex (0), &matches); bool is_alias_command = m_interpreter.AliasExists (command.GetArgumentAtIndex (0)); std::string alias_name = command.GetArgumentAtIndex(0); if (cmd_obj != NULL) { StringList matches; bool all_okay = true; CommandObject *sub_cmd_obj = cmd_obj; // Loop down through sub_command dictionaries until we find the command object that corresponds // to the help command entered. for (int i = 1; i < argc && all_okay; ++i) { std::string sub_command = command.GetArgumentAtIndex(i); matches.Clear(); if (! sub_cmd_obj->IsMultiwordObject ()) { all_okay = false; } else { CommandObject *found_cmd; found_cmd = ((CommandObjectMultiword *) sub_cmd_obj)->GetSubcommandObject(sub_command.c_str(), &matches); if (found_cmd == NULL) all_okay = false; else if (matches.GetSize() > 1) all_okay = false; else sub_cmd_obj = found_cmd; } } if (!all_okay || (sub_cmd_obj == NULL)) { std::string cmd_string; command.GetCommandString (cmd_string); if (matches.GetSize() < 2) { result.AppendErrorWithFormat("'%s' is not a known command.\n" "Try 'help' to see a current list of commands.\n", cmd_string.c_str()); } else { StreamString s; s.Printf ("ambiguous command %s", cmd_string.c_str()); size_t num_matches = matches.GetSize(); for (size_t match_idx = 0; match_idx < num_matches; match_idx++) { s.Printf ("\n\t%s", matches.GetStringAtIndex(match_idx)); } s.Printf ("\n"); result.AppendError(s.GetData()); } result.SetStatus (eReturnStatusFailed); } else { Stream &output_strm = result.GetOutputStream(); if (sub_cmd_obj->GetOptions() != NULL) { if (sub_cmd_obj->WantsRawCommandString()) { std::string help_text (sub_cmd_obj->GetHelp()); help_text.append (" This command takes 'raw' input (no need to quote stuff)."); m_interpreter.OutputFormattedHelpText (output_strm, "", "", help_text.c_str(), 1); } else m_interpreter.OutputFormattedHelpText (output_strm, "", "", sub_cmd_obj->GetHelp(), 1); output_strm.Printf ("\nSyntax: %s\n", sub_cmd_obj->GetSyntax()); sub_cmd_obj->GetOptions()->GenerateOptionUsage (m_interpreter, output_strm, sub_cmd_obj); const char *long_help = sub_cmd_obj->GetHelpLong(); if ((long_help != NULL) && (strlen (long_help) > 0)) output_strm.Printf ("\n%s", long_help); // Mark this help command with a success status. if (sub_cmd_obj->WantsRawCommandString()) { m_interpreter.OutputFormattedHelpText (output_strm, "", "", "\nIMPORTANT NOTE: Because this command takes 'raw' input, if you use any command options you must use ' -- ' between the end of the command options and the beginning of the raw input.", 1); } result.SetStatus (eReturnStatusSuccessFinishNoResult); } else if (sub_cmd_obj->IsMultiwordObject()) { if (sub_cmd_obj->WantsRawCommandString()) { std::string help_text (sub_cmd_obj->GetHelp()); help_text.append (" This command takes 'raw' input (no need to quote stuff)."); m_interpreter.OutputFormattedHelpText (output_strm, "", "", help_text.c_str(), 1); } else m_interpreter.OutputFormattedHelpText (output_strm, "", "", sub_cmd_obj->GetHelp(), 1); ((CommandObjectMultiword *) sub_cmd_obj)->GenerateHelpText (result); } else { const char *long_help = sub_cmd_obj->GetHelpLong(); if ((long_help != NULL) && (strlen (long_help) > 0)) output_strm.Printf ("\n%s", long_help); else if (sub_cmd_obj->WantsRawCommandString()) { std::string help_text (sub_cmd_obj->GetHelp()); help_text.append (" This command takes 'raw' input (no need to quote stuff)."); m_interpreter.OutputFormattedHelpText (output_strm, "", "", help_text.c_str(), 1); } else m_interpreter.OutputFormattedHelpText (output_strm, "", "", sub_cmd_obj->GetHelp(), 1); output_strm.Printf ("\nSyntax: %s\n", sub_cmd_obj->GetSyntax()); // Mark this help command with a success status. result.SetStatus (eReturnStatusSuccessFinishNoResult); } } if (is_alias_command) { StreamString sstr; m_interpreter.GetAliasHelp (alias_name.c_str(), cmd_obj->GetCommandName(), sstr); result.GetOutputStream().Printf ("\n'%s' is an abbreviation for %s\n", alias_name.c_str(), sstr.GetData()); } } else if (matches.GetSize() > 0) { Stream &output_strm = result.GetOutputStream(); output_strm.Printf("Help requested with ambiguous command name, possible completions:\n"); const uint32_t match_count = matches.GetSize(); for (uint32_t i = 0; i < match_count; i++) { output_strm.Printf("\t%s\n", matches.GetStringAtIndex(i)); } } else { // Maybe the user is asking for help about a command argument rather than a command. const CommandArgumentType arg_type = CommandObject::LookupArgumentName (command.GetArgumentAtIndex (0)); if (arg_type != eArgTypeLastArg) { Stream &output_strm = result.GetOutputStream (); CommandObject::GetArgumentHelp (output_strm, arg_type, m_interpreter); result.SetStatus (eReturnStatusSuccessFinishNoResult); } else { result.AppendErrorWithFormat ("'%s' is not a known command.\nTry 'help' to see a current list of commands.\n", command.GetArgumentAtIndex(0)); result.SetStatus (eReturnStatusFailed); } } } return result.Succeeded(); }
static int DiskFilesOrDirectories(const llvm::Twine &partial_name, bool only_directories, StringList &matches, TildeExpressionResolver &Resolver) { matches.Clear(); llvm::SmallString<256> CompletionBuffer; llvm::SmallString<256> Storage; partial_name.toVector(CompletionBuffer); if (CompletionBuffer.size() >= PATH_MAX) return matches.GetSize(); namespace path = llvm::sys::path; llvm::StringRef SearchDir; llvm::StringRef PartialItem; if (CompletionBuffer.startswith("~")) { llvm::StringRef Buffer(CompletionBuffer); size_t FirstSep = Buffer.find_if([](char c) { return path::is_separator(c); }); llvm::StringRef Username = Buffer.take_front(FirstSep); llvm::StringRef Remainder; if (FirstSep != llvm::StringRef::npos) Remainder = Buffer.drop_front(FirstSep + 1); llvm::SmallString<256> Resolved; if (!Resolver.ResolveExact(Username, Resolved)) { // We couldn't resolve it as a full username. If there were no slashes // then this might be a partial username. We try to resolve it as such // but after that, we're done regardless of any matches. if (FirstSep == llvm::StringRef::npos) { llvm::StringSet<> MatchSet; Resolver.ResolvePartial(Username, MatchSet); for (const auto &S : MatchSet) { Resolved = S.getKey(); path::append(Resolved, path::get_separator()); matches.AppendString(Resolved); } } return matches.GetSize(); } // If there was no trailing slash, then we're done as soon as we resolve // the expression to the correct directory. Otherwise we need to continue // looking for matches within that directory. if (FirstSep == llvm::StringRef::npos) { // Make sure it ends with a separator. path::append(CompletionBuffer, path::get_separator()); matches.AppendString(CompletionBuffer); return matches.GetSize(); } // We want to keep the form the user typed, so we special case this to // search in the fully resolved directory, but CompletionBuffer keeps the // unmodified form that the user typed. Storage = Resolved; llvm::StringRef RemainderDir = path::parent_path(Remainder); if (!RemainderDir.empty()) { // Append the remaining path to the resolved directory. Storage.append(path::get_separator()); Storage.append(RemainderDir); } SearchDir = Storage; } else { SearchDir = path::parent_path(CompletionBuffer); } size_t FullPrefixLen = CompletionBuffer.size(); PartialItem = path::filename(CompletionBuffer); // path::filename() will return "." when the passed path ends with a // directory separator. We have to filter those out, but only when the // "." doesn't come from the completion request itself. if (PartialItem == "." && path::is_separator(CompletionBuffer.back())) PartialItem = llvm::StringRef(); if (SearchDir.empty()) { llvm::sys::fs::current_path(Storage); SearchDir = Storage; } assert(!PartialItem.contains(path::get_separator())); // SearchDir now contains the directory to search in, and Prefix contains the // text we want to match against items in that directory. FileSystem &fs = FileSystem::Instance(); std::error_code EC; llvm::vfs::directory_iterator Iter = fs.DirBegin(SearchDir, EC); llvm::vfs::directory_iterator End; for (; Iter != End && !EC; Iter.increment(EC)) { auto &Entry = *Iter; llvm::ErrorOr<llvm::vfs::Status> Status = fs.GetStatus(Entry.path()); if (!Status) continue; auto Name = path::filename(Entry.path()); // Omit ".", ".." if (Name == "." || Name == ".." || !Name.startswith(PartialItem)) continue; bool is_dir = Status->isDirectory(); // If it's a symlink, then we treat it as a directory as long as the target // is a directory. if (Status->isSymlink()) { FileSpec symlink_filespec(Entry.path()); FileSpec resolved_filespec; auto error = fs.ResolveSymbolicLink(symlink_filespec, resolved_filespec); if (error.Success()) is_dir = fs.IsDirectory(symlink_filespec); } if (only_directories && !is_dir) continue; // Shrink it back down so that it just has the original prefix the user // typed and remove the part of the name which is common to the located // item and what the user typed. CompletionBuffer.resize(FullPrefixLen); Name = Name.drop_front(PartialItem.size()); CompletionBuffer.append(Name); if (is_dir) { path::append(CompletionBuffer, path::get_separator()); } matches.AppendString(CompletionBuffer); } return matches.GetSize(); }
ConvolutionFilterCodeDialog::ConvolutionFilterCodeDialog( String mode, const Filter& _filter ) : Dialog(), filter( _filter ) { // ### TextBox FilterCode_TextBox.SetScaledMinSize( 700, 300 ); FilterCode_TextBox.OnCaretPositionUpdated( (TextBox::caret_event_handler)&ConvolutionFilterCodeDialog::__TextBox_CaretPosition, *this ); if ( mode == "Edit" ) { FilterCode_TextBox.SetReadWrite(); FilterCode_TextBox.SetText( filter.ToSource() ); } tableRow = 0; String s; String html( "<html style=\"white-space:pre;text-align:right;\">" "<table border=\"0\" cellspacing=\"0\" cellpadding=\"0\">" ); StringList cols; UpdateTableColors(); if ( mode == "View" ) { FilterCode_TextBox.SetReadOnly(); if ( filter.IsSeparable() ) { SeparableFilter fs( filter.Separable() ); float element; // Rows for ( int i = 0; i < fs.Size(); ++i ) { // Cols for ( int j = 0; j < fs.Size(); ++j ) { // Calculus of each coefficient of the separable filter element = Round( fs.ColFilter()[i] * fs.RowFilter()[j], 6 ); cols.Add( String().Format( "%10.6f", element ) ); } html += TR( cols ); cols.Clear(); } } else { KernelFilter k( filter.Kernel() ); for ( int i = 0; i < k.Size(); ++i ) { for ( int j = 0; j < k.Size(); ++j ) { float element = Round( k.Coefficients()[i][j], 6 ); // The elements of the KernelFilter can be accessed directly God thanks and the [] operator. cols.Add( String().Format( "%10.6f", element ) ); } html += TR( cols ); cols.Clear(); } } html += "</table></html>"; // We got it!! we set the TextBox text by passing the composed String s. FilterCode_TextBox.SetText( html ); UpdateTableColors(); } if ( mode == "View" ) LineCol_Label.Hide(); else LineCol_Label.Show(); LineCol_Sizer.SetSpacing( 4 ); LineCol_Sizer.Add( LineCol_Label ); LineCol_Sizer.AddStretch(); // ### Save PushButton Save_PushButton.SetText( "Save" ); Save_PushButton.SetCursor( StdCursor::Checkmark ); Save_PushButton.OnClick( (Button::click_event_handler)&ConvolutionFilterCodeDialog::__Button_Click, *this ); if ( mode == "View" ) Save_PushButton.Hide(); else Save_PushButton.SetDefault(); if ( mode == "View" ) { Cancel_PushButton.SetText( "Close" ); Cancel_PushButton.SetCursor( StdCursor::Checkmark ); Cancel_PushButton.SetDefault(); } else { Cancel_PushButton.SetText( "Cancel" ); Cancel_PushButton.SetCursor( StdCursor::Crossmark ); } Cancel_PushButton.OnClick( (Button::click_event_handler)&ConvolutionFilterCodeDialog::__Button_Click, *this ); DialogButtons_Sizer.SetSpacing( 8 ); DialogButtons_Sizer.AddStretch(); DialogButtons_Sizer.Add( Save_PushButton ); DialogButtons_Sizer.Add( Cancel_PushButton ); DialogButtons_Sizer.AddStretch(); Global_Sizer.SetMargin( 4 ); Global_Sizer.SetSpacing( 4 ); Global_Sizer.Add( FilterCode_TextBox ); Global_Sizer.Add( LineCol_Sizer ); Global_Sizer.Add( DialogButtons_Sizer ); SetSizer( Global_Sizer ); EnableUserResizing(); AdjustToContents(); BringToFront(); //SetFixedSize(); if ( mode == "View" ) SetWindowTitle( '\"' + filter.Name() + '\"' + " filter elements" ); else if ( mode == "Edit" ) SetWindowTitle( '\"' + filter.Name() + '\"' + " edit" ); else if ( mode == "New" ) SetWindowTitle( "New filter" ); else throw Error( "Internal error: Invalid dialog operation mode in ConvolutionFilterCodeDialog" ); }
int CommandObject::HandleCompletion ( Args &input, int &cursor_index, int &cursor_char_position, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches ) { // Default implmentation of WantsCompletion() is !WantsRawCommandString(). // Subclasses who want raw command string but desire, for example, // argument completion should override WantsCompletion() to return true, // instead. if (WantsRawCommandString() && !WantsCompletion()) { // FIXME: Abstract telling the completion to insert the completion character. matches.Clear(); return -1; } else { // Can we do anything generic with the options? Options *cur_options = GetOptions(); CommandReturnObject result; OptionElementVector opt_element_vector; if (cur_options != NULL) { // Re-insert the dummy command name string which will have been // stripped off: input.Unshift ("dummy-string"); cursor_index++; // I stick an element on the end of the input, because if the last element is // option that requires an argument, getopt_long will freak out. input.AppendArgument ("<FAKE-VALUE>"); input.ParseArgsForCompletion (*cur_options, opt_element_vector, cursor_index); input.DeleteArgumentAtIndex(input.GetArgumentCount() - 1); bool handled_by_options; handled_by_options = cur_options->HandleOptionCompletion (input, opt_element_vector, cursor_index, cursor_char_position, match_start_point, max_return_elements, word_complete, matches); if (handled_by_options) return matches.GetSize(); } // If we got here, the last word is not an option or an option argument. return HandleArgumentCompletion (input, cursor_index, cursor_char_position, opt_element_vector, match_start_point, max_return_elements, word_complete, matches); } }
bool CommandObjectHelp::DoExecute (Args& command, CommandReturnObject &result) { CommandObject::CommandMap::iterator pos; CommandObject *cmd_obj; const size_t argc = command.GetArgumentCount (); // 'help' doesn't take any arguments, other than command names. If argc is 0, we show the user // all commands (aliases and user commands if asked for). Otherwise every argument must be the name of a command or a sub-command. if (argc == 0) { uint32_t cmd_types = CommandInterpreter::eCommandTypesBuiltin; if (m_options.m_show_aliases) cmd_types |= CommandInterpreter::eCommandTypesAliases; if (m_options.m_show_user_defined) cmd_types |= CommandInterpreter::eCommandTypesUserDef; if (m_options.m_show_hidden) cmd_types |= CommandInterpreter::eCommandTypesHidden; result.SetStatus (eReturnStatusSuccessFinishNoResult); m_interpreter.GetHelp (result, cmd_types); // General help } else { // Get command object for the first command argument. Only search built-in command dictionary. StringList matches; cmd_obj = m_interpreter.GetCommandObject (command.GetArgumentAtIndex (0), &matches); bool is_alias_command = m_interpreter.AliasExists (command.GetArgumentAtIndex (0)); std::string alias_name = command.GetArgumentAtIndex(0); if (cmd_obj != nullptr) { StringList matches; bool all_okay = true; CommandObject *sub_cmd_obj = cmd_obj; // Loop down through sub_command dictionaries until we find the command object that corresponds // to the help command entered. std::string sub_command; for (size_t i = 1; i < argc && all_okay; ++i) { sub_command = command.GetArgumentAtIndex(i); matches.Clear(); if (sub_cmd_obj->IsAlias()) sub_cmd_obj = ((CommandAlias*)sub_cmd_obj)->GetUnderlyingCommand().get(); if (! sub_cmd_obj->IsMultiwordObject ()) { all_okay = false; } else { CommandObject *found_cmd; found_cmd = sub_cmd_obj->GetSubcommandObject(sub_command.c_str(), &matches); if (found_cmd == nullptr) all_okay = false; else if (matches.GetSize() > 1) all_okay = false; else sub_cmd_obj = found_cmd; } } if (!all_okay || (sub_cmd_obj == nullptr)) { std::string cmd_string; command.GetCommandString (cmd_string); if (matches.GetSize() >= 2) { StreamString s; s.Printf ("ambiguous command %s", cmd_string.c_str()); size_t num_matches = matches.GetSize(); for (size_t match_idx = 0; match_idx < num_matches; match_idx++) { s.Printf ("\n\t%s", matches.GetStringAtIndex(match_idx)); } s.Printf ("\n"); result.AppendError(s.GetData()); result.SetStatus (eReturnStatusFailed); return false; } else if (!sub_cmd_obj) { StreamString error_msg_stream; GenerateAdditionalHelpAvenuesMessage(&error_msg_stream, cmd_string.c_str(), m_interpreter.GetCommandPrefix(), sub_command.c_str()); result.AppendErrorWithFormat("%s",error_msg_stream.GetData()); result.SetStatus (eReturnStatusFailed); return false; } else { GenerateAdditionalHelpAvenuesMessage(&result.GetOutputStream(), cmd_string.c_str(), m_interpreter.GetCommandPrefix(), sub_command.c_str()); result.GetOutputStream().Printf("\nThe closest match is '%s'. Help on it follows.\n\n", sub_cmd_obj->GetCommandName()); } } sub_cmd_obj->GenerateHelpText(result); if (is_alias_command) { StreamString sstr; m_interpreter.GetAlias(alias_name.c_str())->GetAliasExpansion(sstr); result.GetOutputStream().Printf ("\n'%s' is an abbreviation for %s\n", alias_name.c_str(), sstr.GetData()); } } else if (matches.GetSize() > 0) { Stream &output_strm = result.GetOutputStream(); output_strm.Printf("Help requested with ambiguous command name, possible completions:\n"); const size_t match_count = matches.GetSize(); for (size_t i = 0; i < match_count; i++) { output_strm.Printf("\t%s\n", matches.GetStringAtIndex(i)); } } else { // Maybe the user is asking for help about a command argument rather than a command. const CommandArgumentType arg_type = CommandObject::LookupArgumentName (command.GetArgumentAtIndex (0)); if (arg_type != eArgTypeLastArg) { Stream &output_strm = result.GetOutputStream (); CommandObject::GetArgumentHelp (output_strm, arg_type, m_interpreter); result.SetStatus (eReturnStatusSuccessFinishNoResult); } else { StreamString error_msg_stream; GenerateAdditionalHelpAvenuesMessage(&error_msg_stream, command.GetArgumentAtIndex(0), m_interpreter.GetCommandPrefix()); result.AppendErrorWithFormat("%s",error_msg_stream.GetData()); result.SetStatus (eReturnStatusFailed); } } } return result.Succeeded(); }
void CompletionResult::GetDescriptions(StringList &descriptions) const { descriptions.Clear(); for (const Completion &completion : m_results) descriptions.AppendString(completion.m_descripton); }
void CompletionResult::GetMatches(StringList &matches) const { matches.Clear(); for (const Completion &completion : m_results) matches.AppendString(completion.m_completion); }
size_t Platform::GetEnvironment (StringList &environment) { environment.Clear(); return false; }
int CommandInterpreter::HandleCompletion (const char *current_line, const char *cursor, const char *last_char, int match_start_point, int max_return_elements, StringList &matches) { // We parse the argument up to the cursor, so the last argument in parsed_line is // the one containing the cursor, and the cursor is after the last character. Args parsed_line(current_line, last_char - current_line); Args partial_parsed_line(current_line, cursor - current_line); int num_args = partial_parsed_line.GetArgumentCount(); int cursor_index = partial_parsed_line.GetArgumentCount() - 1; int cursor_char_position; if (cursor_index == -1) cursor_char_position = 0; else cursor_char_position = strlen (partial_parsed_line.GetArgumentAtIndex(cursor_index)); int num_command_matches; matches.Clear(); // Only max_return_elements == -1 is supported at present: assert (max_return_elements == -1); bool word_complete; num_command_matches = HandleCompletionMatches (parsed_line, cursor_index, cursor_char_position, match_start_point, max_return_elements, word_complete, matches); if (num_command_matches <= 0) return num_command_matches; if (num_args == 0) { // If we got an empty string, insert nothing. matches.InsertStringAtIndex(0, ""); } else { // Now figure out if there is a common substring, and if so put that in element 0, otherwise // put an empty string in element 0. std::string command_partial_str; if (cursor_index >= 0) command_partial_str.assign(parsed_line.GetArgumentAtIndex(cursor_index), parsed_line.GetArgumentAtIndex(cursor_index) + cursor_char_position); std::string common_prefix; matches.LongestCommonPrefix (common_prefix); int partial_name_len = command_partial_str.size(); // If we matched a unique single command, add a space... // Only do this if the completer told us this was a complete word, however... if (num_command_matches == 1 && word_complete) { char quote_char = parsed_line.GetArgumentQuoteCharAtIndex(cursor_index); if (quote_char != '\0') common_prefix.push_back(quote_char); common_prefix.push_back(' '); } common_prefix.erase (0, partial_name_len); matches.InsertStringAtIndex(0, common_prefix.c_str()); } return num_command_matches; }
void RefreshWindowList(HWND hwndCombobox, StringList &classList) { SendMessage(hwndCombobox, CB_RESETCONTENT, 0, 0); classList.Clear(); BOOL bCurrentProcessIsWow64 = FALSE; IsWow64Process(GetCurrentProcess(), &bCurrentProcessIsWow64); HWND hwndCurrent = GetWindow(GetDesktopWindow(), GW_CHILD); do { if(IsWindowVisible(hwndCurrent)) { RECT clientRect; GetClientRect(hwndCurrent, &clientRect); HWND hwndParent = GetParent(hwndCurrent); DWORD exStyles = (DWORD)GetWindowLongPtr(hwndCurrent, GWL_EXSTYLE); DWORD styles = (DWORD)GetWindowLongPtr(hwndCurrent, GWL_STYLE); if( (exStyles & WS_EX_TOOLWINDOW) == 0 && (styles & WS_CHILD) == 0 && hwndParent == NULL) { String strWindowName; strWindowName.SetLength(GetWindowTextLength(hwndCurrent)); GetWindowText(hwndCurrent, strWindowName, strWindowName.Length()+1); //------- DWORD processID; GetWindowThreadProcessId(hwndCurrent, &processID); if(processID == GetCurrentProcessId()) continue; TCHAR fileName[MAX_PATH+1]; scpy(fileName, TEXT("unknown")); HANDLE hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, processID); if(hProcess) { BOOL bTargetProcessIsWow64 = FALSE; IsWow64Process(hProcess, &bTargetProcessIsWow64); DWORD dwSize = MAX_PATH; QueryFullProcessImageName(hProcess, 0, fileName, &dwSize); CloseHandle(hProcess); if(bCurrentProcessIsWow64 != bTargetProcessIsWow64) continue; } //------- String strFileName = fileName; strFileName.FindReplace(TEXT("\\"), TEXT("/")); String strText; strText << TEXT("[") << GetPathFileName(strFileName) << TEXT("]: ") << strWindowName; int id = (int)SendMessage(hwndCombobox, CB_ADDSTRING, 0, (LPARAM)strWindowName.Array()); SendMessage(hwndCombobox, CB_SETITEMDATA, id, (LPARAM)hwndCurrent); String strClassName; strClassName.SetLength(256); GetClassName(hwndCurrent, strClassName.Array(), 255); strClassName.SetLength(slen(strClassName)); classList << strClassName; } } } while (hwndCurrent = GetNextWindow(hwndCurrent, GW_HWNDNEXT)); }