//Standard contructor DeviceToolBar::DeviceToolBar() : ToolBar(DeviceBarID, _("Device"), wxT("Device"), true) { mPlayBitmap = NULL; mRecordBitmap = NULL; }
bool wxGenericDirDialog::Create(wxWindow* parent, const wxString& title, const wxString& defaultPath, long style, const wxPoint& pos, const wxSize& sz, const wxString& name) { wxBusyCursor cursor; parent = GetParentForModalDialog(parent, style); if (!wxDirDialogBase::Create(parent, title, defaultPath, style, pos, sz, name)) return false; m_path = defaultPath; if (m_path == wxT("~")) wxGetHomeDir(&m_path); if (m_path == wxT(".")) m_path = wxGetCwd(); wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL ); // smartphones does not support or do not waste space for wxButtons #if defined(__SMARTPHONE__) wxMenu *dirMenu = new wxMenu; dirMenu->Append(ID_GO_HOME, _("Home")); if (!HasFlag(wxDD_DIR_MUST_EXIST)) { dirMenu->Append(ID_NEW, _("New directory")); } dirMenu->AppendCheckItem(ID_SHOW_HIDDEN, _("Show hidden directories")); dirMenu->AppendSeparator(); dirMenu->Append(wxID_CANCEL, _("Cancel")); #else // 0) 'New' and 'Home' Buttons wxSizer* buttonsizer = new wxBoxSizer( wxHORIZONTAL ); // VS: 'Home directory' concept is unknown to MS-DOS #if !defined(__DOS__) wxBitmapButton* homeButton = new wxBitmapButton(this, ID_GO_HOME, wxArtProvider::GetBitmap(wxART_GO_HOME, wxART_BUTTON)); buttonsizer->Add( homeButton, 0, wxLEFT|wxRIGHT, 10 ); #endif // I'm not convinced we need a New button, and we tend to get annoying // accidental-editing with label editing enabled. if (!HasFlag(wxDD_DIR_MUST_EXIST)) { wxBitmapButton* newButton = new wxBitmapButton(this, ID_NEW, wxArtProvider::GetBitmap(wxART_NEW_DIR, wxART_BUTTON)); buttonsizer->Add( newButton, 0, wxRIGHT, 10 ); #if wxUSE_TOOLTIPS newButton->SetToolTip(_("Create new directory")); #endif } #if wxUSE_TOOLTIPS homeButton->SetToolTip(_("Go to home directory")); #endif topsizer->Add( buttonsizer, 0, wxTOP | wxALIGN_RIGHT, 10 ); #endif // __SMARTPHONE__/!__SMARTPHONE__ // 1) dir ctrl m_dirCtrl = NULL; // this is necessary, event handler called from // wxGenericDirCtrl would crash otherwise! long dirStyle = wxDIRCTRL_DIR_ONLY | wxDEFAULT_CONTROL_BORDER; #ifdef __WXMSW__ if (!HasFlag(wxDD_DIR_MUST_EXIST)) { // Only under Windows do we need the wxTR_EDIT_LABEL tree control style // before we can call EditLabel (required for "New directory") dirStyle |= wxDIRCTRL_EDIT_LABELS; } #endif m_dirCtrl = new wxGenericDirCtrl(this, ID_DIRCTRL, m_path, wxDefaultPosition, wxSize(300, 200), dirStyle); wxSizerFlags flagsBorder2; flagsBorder2.DoubleBorder(wxTOP | wxLEFT | wxRIGHT); topsizer->Add(m_dirCtrl, wxSizerFlags(flagsBorder2).Proportion(1).Expand()); #ifndef __SMARTPHONE__ // TODO: Make this an option depending on a flag? wxCheckBox * check = new wxCheckBox(this, ID_SHOW_HIDDEN, _("Show &hidden directories")); topsizer->Add(check, wxSizerFlags(flagsBorder2).Right()); #endif // !__SMARTPHONE__ // 2) text ctrl m_input = new wxTextCtrl( this, ID_TEXTCTRL, m_path, wxDefaultPosition ); topsizer->Add(m_input, wxSizerFlags(flagsBorder2).Expand()); // 3) buttons if any wxSizer *buttonSizer = CreateSeparatedButtonSizer(wxOK | wxCANCEL); if ( buttonSizer ) { topsizer->Add(buttonSizer, wxSizerFlags().Expand().DoubleBorder()); } #ifdef __SMARTPHONE__ // overwrite menu set by CreateSeparatedButtonSizer() call above SetRightMenu(wxID_ANY, _("Options"), dirMenu); #endif m_input->SetFocus(); SetAutoLayout( true ); SetSizer( topsizer ); topsizer->SetSizeHints( this ); topsizer->Fit( this ); Centre( wxBOTH ); return true; }
#include "wx/valgen.h" #include "wx/valtext.h" #include "wx/valnum.h" #ifndef wxHAS_IMAGES_IN_RESOURCES #include "../sample.xpm" #endif // ---------------------------------------------------------------------------- // Global data // ---------------------------------------------------------------------------- MyData g_data; wxString g_listbox_choices[] = {wxT("one"), wxT("two"), wxT("three")}; wxString g_combobox_choices[] = {wxT("yes"), wxT("no (doesn't validate)"), wxT("maybe (doesn't validate)")}; wxString g_radiobox_choices[] = {wxT("green"), wxT("yellow"), wxT("red")}; // ---------------------------------------------------------------------------- // MyData // ---------------------------------------------------------------------------- MyData::MyData() { // This string will be passed to an alpha-only validator, which // will complain because spaces aren't alpha. Note that validation
DlgPass::DlgPass() : wxDialog(DlgPass::Parent, -1, wxT("Nau - Pass"),wxDefaultPosition,wxDefaultSize,wxRESIZE_BORDER|wxDEFAULT_DIALOG_STYLE), m_Name("Pass Dialog") { m_Parent = DlgPass::Parent; wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL); /* ---------------------------------------------------------------- Toolbar -----------------------------------------------------------------*/ // load the image wanted on the toolbar //wxBitmap newImage(wxT("bitmaps/new.bmp"), wxBITMAP_TYPE_BMP); //wxBitmap cutImage(wxT("bitmaps/cut.bmp"), wxBITMAP_TYPE_BMP); // wxBitmap aboutImage = wxBITMAP(help) ; // create the toolbar and add our 1 tool to it /* m_toolbar = new wxToolBar(this,TOOLBAR_ID); long tstyle = m_toolbar->GetWindowStyle(); tstyle |= wxTB_TEXT; m_toolbar->SetWindowStyle(tstyle); m_toolbar->AddTool(PIPELINE_NEW, _("New"), newImage, _("New Pipeline")); m_toolbar->AddTool(PIPELINE_REMOVE, _("Remove"), cutImage, _("Remove Pipeline")); m_toolbar->AddSeparator(); m_toolbar->AddTool(PASS_NEW, _("New"), newImage, _("New Pass")); m_toolbar->AddTool(PASS_REMOVE, _("Remove"), cutImage, _("Remove Pass")); m_toolbar->EnableTool(PIPELINE_REMOVE, FALSE); m_toolbar->Realize(); sizer->Add(m_toolbar,0,wxGROW |wxALL, 1); */ /* ---------------------------------------------------------------- Pipelines and Passes -----------------------------------------------------------------*/ m_PipelineList = new wxComboBox(this,DLG_MI_COMBO_PIPELINE,wxT(""),wxDefaultPosition,wxDefaultSize,0,NULL,wxCB_READONLY ); m_PassList = new wxComboBox(this,DLG_MI_COMBO_PASS,wxT(""),wxDefaultPosition,wxDefaultSize,0,NULL,wxCB_READONLY ); wxBoxSizer *sizer1 = new wxBoxSizer(wxHORIZONTAL); wxStaticText *stg1 = new wxStaticText(this,-1,wxT("Pipeline: ")); sizer1->Add(stg1,0,wxGROW |wxALL, 5); sizer1->Add(m_PipelineList,0,wxGROW |wxALL,5); wxStaticText *stg2 = new wxStaticText(this,-1,wxT("Pass: "******"Pass Properties")); wxSizer *sizerS = new wxStaticBoxSizer(sb,wxVERTICAL); m_PG = new wxPropertyGridManager(this, DLG_MI_PG, wxDefaultPosition, wxDefaultSize, // These and other similar styles are automatically // passed to the embedded wxPropertyGrid. wxPG_BOLD_MODIFIED|wxPG_SPLITTER_AUTO_CENTER| // Plus defaults. wxPGMAN_DEFAULT_STYLE ); // dummy prop m_PG->AddPage(wxT("Properties")); m_PG->Append(new wxPGProperty(wxT("Parameters"), wxPG_LABEL)); m_PG->Append(new wxFloatProperty(wxT("alpha"),wxPG_LABEL, 0.0f)); sizerS->Add(m_PG, 1, wxGROW | wxALL, 5); /* ---------------------------------------------------------------- Activate button -----------------------------------------------------------------*/ wxBoxSizer *sizH3 = new wxBoxSizer(wxHORIZONTAL); m_BActivate = new wxButton(this, DLG_BUTTON_ACTIVATE, wxT("Activate Pipeline")); m_ActivePipText = new wxStaticText(this, wxID_ANY, wxT("...")); sizH3->Add(m_BActivate, 0, wxALL | wxGROW | wxHORIZONTAL , 5); sizH3->Add(m_ActivePipText, 0, wxALL | wxGROW | wxHORIZONTAL , 5); /* ---------------------------------------------------------------- End -----------------------------------------------------------------*/ sizer->Add(sizerS,1,wxGROW | wxALL,5); sizer->Add(sizH3, 0, wxALL | wxGROW | wxHORIZONTAL, 15); //sizer->Add(5,5,0, wxGROW | wxALL,5); SetAutoLayout(TRUE); SetSizer(sizer); sizer->SetSizeHints(this); sizer->Fit(this); }
void RadarCanvas::Render(wxPaintEvent &evt) { int w, h; if (!IsShown() || !m_pi->m_initialized) { return; } GetClientSize(&w, &h); wxPaintDC(this); // only to be used in paint events. use wxClientDC to paint // outside the paint event if (!m_pi->m_opengl_mode) { LOG_DIALOG(wxT("BR24radar_pi: %s cannot render non-OpenGL mode"), m_ri->m_name.c_str()); return; } if (!m_pi->m_opencpn_gl_context && !m_pi->m_opencpn_gl_context_broken) { LOG_DIALOG(wxT("BR24radar_pi: %s skip render as no context known yet"), m_ri->m_name.c_str()); return; } LOG_DIALOG(wxT("BR24radar_pi: %s render OpenGL canvas %d by %d "), m_ri->m_name.c_str(), w, h); SetCurrent(*m_context); glPushMatrix(); glPushAttrib(GL_ALL_ATTRIB_BITS); wxFont font = GetOCPNGUIScaledFont_PlugIn(_T("StatusBar")); m_FontNormal.Build(font); wxFont bigFont = GetOCPNGUIScaledFont_PlugIn(_T("Dialog")); bigFont.SetPointSize(bigFont.GetPointSize() + 2); bigFont.SetWeight(wxFONTWEIGHT_BOLD); m_FontBig.Build(bigFont); bigFont.SetPointSize(bigFont.GetPointSize() + 2); bigFont.SetWeight(wxFONTWEIGHT_NORMAL); m_FontMenu.Build(bigFont); bigFont.SetPointSize(bigFont.GetPointSize() + 10); bigFont.SetWeight(wxFONTWEIGHT_BOLD); m_FontMenuBold.Build(bigFont); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Black Background glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the canvas glEnable(GL_TEXTURE_2D); // Enable textures glEnable(GL_COLOR_MATERIAL); glEnable(GL_BLEND); // glDisable(GL_DEPTH_TEST); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); // Next two operations on the project matrix stack glLoadIdentity(); // Reset projection matrix stack glOrtho(0, w, h, 0, -1, 1); glMatrixMode(GL_MODELVIEW); // Reset matrick stack target back to GL_MODELVIEW RenderRangeRingsAndHeading(w, h); Render_EBL_VRM(w, h); glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); // Next two operations on the project matrix stack glLoadIdentity(); // Reset projection matrix stack if (w >= h) { glScaled(1.0, (float)-w / h, 1.0); } else { glScaled((float)h / w, -1.0, 1.0); } glMatrixMode(GL_MODELVIEW); // Reset matrick stack target back to GL_MODELVIEW m_ri->RenderRadarImage(wxPoint(0, 0), 1.0, 0.0, false); glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); // Next two operations on the project matrix stack glLoadIdentity(); // Reset projection matrix stack glOrtho(0, w, h, 0, -1, 1); glMatrixMode(GL_MODELVIEW); // Reset matrick stack target back to GL_MODELVIEW glEnable(GL_TEXTURE_2D); RenderTexts(w, h); RenderCursor(w, h); #ifdef NEVER glDisable(GL_TEXTURE_2D); glMatrixMode(GL_PROJECTION); // Next two operations on the project matrix stack glLoadIdentity(); // Reset projection matrix stack glMatrixMode(GL_MODELVIEW); // Reset matrick stack target back to GL_MODELVIEW #endif glPopAttrib(); glPopMatrix(); glFlush(); glFinish(); SwapBuffers(); if (m_pi->m_opencpn_gl_context) { SetCurrent(*m_pi->m_opencpn_gl_context); } else { SetCurrent(*m_zero_context); // Make sure OpenCPN -at least- doesn't overwrite our context info } }
wxString GroupCell::ToTeX(bool all, wxString imgDir, wxString filename, int *imgCounter) { wxString str; // pagebreak if (m_groupType == GC_TYPE_PAGEBREAK) { str = wxT("\\pagebreak\n"); } // IMAGE CELLS else if (m_groupType == GC_TYPE_IMAGE && imgDir != wxEmptyString) { MathCell *copy = m_output->Copy(false); (*imgCounter)++; wxString image = filename + wxString::Format(wxT("_%d.png"), *imgCounter); wxString file = imgDir + wxT("/") + image; Bitmap bmp; bmp.SetData(copy); if (!wxDirExists(imgDir)) wxMkdir(imgDir); if (bmp.ToFile(file)) { str << wxT("\\begin{figure}[htb]\n") << wxT(" \\begin{center}\n") << wxT(" \\includegraphics{") << filename << wxT("_img/") << image << wxT("}\n") << wxT(" \\caption{") << PrepareForTeX(m_input->m_next->GetValue()) << wxT("}\n") << wxT(" \\end{center}\n") << wxT("\\end{figure}"); } } else if (m_groupType == GC_TYPE_IMAGE) str << wxT("\n\\vert|<<GRAPHICS>>|\n"); // CODE CELLS else if (m_groupType == GC_TYPE_CODE) { // Input cells str = wxT("\n\\noindent\n%%%%%%%%%%%%%%%\n") wxT("%%% INPUT:\n") wxT("\\begin{minipage}[t]{8ex}{\\color{red}\\bf\n") wxT("\\begin{verbatim}\n") + m_input->ToString(false) + wxT("\n\\end{verbatim}}\n\\end{minipage}"); if (m_input->m_next!=NULL) { str += wxT("\n\\begin{minipage}[t]{\\textwidth}{\\color{blue}\n\\begin{verbatim}\n") + m_input->m_next->ToString(true) + wxT("\n\\end{verbatim}}\n\\end{minipage}"); } str += wxT("\n"); if (m_output != NULL) { str += wxT("%%% OUTPUT:\n"); // Need to define labelcolor if this is Copy as LaTeX! if (imgCounter == NULL) str += wxT("\\definecolor{labelcolor}{RGB}{100,0,0}\n"); str += wxT("\\begin{math}\\displaystyle\n"); MathCell *tmp = m_output; while (tmp != NULL) { if (tmp->GetType() == MC_TYPE_IMAGE || tmp->GetType() == MC_TYPE_SLIDE) { if (imgDir != wxEmptyString) { MathCell *copy = tmp->Copy(false); (*imgCounter)++; wxString image = filename + wxString::Format(wxT("_%d.png"), *imgCounter); wxString file = imgDir + wxT("/") + image; Bitmap bmp; bmp.SetData(copy); if (!wxDirExists(imgDir)) if (!wxMkdir(imgDir)) continue; if (bmp.ToFile(file)) str += wxT("\\includegraphics[width=9cm]{") + filename + wxT("_img/") + image + wxT("}"); } else str << wxT("\n\\verb|<<GRAPHICS>>|\n"); } else if (tmp->GetStyle() == TS_LABEL) { if (str.Right(13) != wxT("displaystyle\n")) str += wxT("\n\\end{math}\n\n\\begin{math}\\displaystyle\n"); str += wxT("\\parbox{8ex}{\\color{labelcolor}") + tmp->ToTeX(false) + wxT("}\n"); } else str += tmp->ToTeX(false); tmp = tmp->m_nextToDraw; } str += wxT("\n\\end{math}\n%%%%%%%%%%%%%%%\n"); } } // TITLES, SECTIONS, SUBSECTIONS, TEXT else if (GetEditable() != NULL && !m_hide) { str = GetEditable()->ToTeX(true); switch (GetEditable()->GetStyle()) { case TS_TITLE: str = wxT("\n\\pagebreak{}\n{\\Huge {\\sc ") + PrepareForTeX(str) + wxT("}}\n"); str += wxT("\\setcounter{section}{0}\n\\setcounter{subsection}{0}\n"); str += wxT("\\setcounter{figure}{0}\n\n"); break; case TS_SECTION: str = wxT("\n\\section{") + PrepareForTeX(str) + wxT("}\n\n"); break; case TS_SUBSECTION: str = wxT("\n\\subsection{") + PrepareForTeX(str) + wxT("}\n\n"); break; default: if (str.StartsWith(wxT("TeX:"))) str = str.Mid(5, str.Length()); else { str = PrepareForTeX(str); } break; } } return str + MathCell::ToTeX(all); }
void DlgPass::updatePipelines() { std::vector<std::string> pips; RENDERMANAGER->getPipelineNames(&pips); std::vector<std::string>::iterator iter; //wxString sel = m_PipelineList->GetStringSelection(); wxString sel = wxString(RENDERMANAGER->getActivePipelineName()); m_PipelineList->Clear(); for (iter = pips.begin(); iter != pips.end(); ++iter) m_PipelineList->Append(wxString(iter->c_str())); if (! m_PipelineList->SetStringSelection(sel)) m_PipelineList->SetSelection(0); sel = m_PipelineList->GetStringSelection(); m_ActivePipText->SetLabelText(sel); std::string pipName = std::string(sel.mb_str()); std::shared_ptr<Pipeline> &pip = RENDERMANAGER->getPipeline(pipName); std::vector<std::string> passes; pip->getPassNames(&passes); sel = m_PassList->GetStringSelection(); m_PassList->Clear(); for (auto &name:passes) m_PassList->Append(wxString(name.c_str())); if (! m_PassList->SetStringSelection(sel)) m_PassList->SetSelection(0); Pass *p = getPass(); m_PG->ClearPage(0); m_PG->Append(new wxStringProperty(wxT("Class"), wxPG_LABEL, wxT(""))); m_PG->DisableProperty(wxT("Class")); m_pgCamList.Add(wxT("dummy")); m_pgPropCam = new wxEnumProperty(wxT("Camera"),wxPG_LABEL,m_pgCamList); m_PG->Append(m_pgPropCam); m_pgViewportList.Add(wxT("From Camera")); m_pgPropViewport = new wxEnumProperty(wxT("Viewport"),wxPG_LABEL,m_pgViewportList); m_PG->Append(m_pgPropViewport); m_PG->Append(new wxBoolProperty(wxT("Use Render Target"), wxPG_LABEL, true)); m_PG->SetPropertyAttribute( wxT("Use Render Target"), wxPG_BOOL_USE_CHECKBOX, true ); m_pgRenderTargetList.Add(wxT("None")); m_pgPropRenderTarget = new wxEnumProperty(wxT("Render Target"),wxPG_LABEL,m_pgRenderTargetList); m_PG->Append(m_pgPropRenderTarget); updateLists(p); setupGrid(); updateProperties(p) ; }
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxST_NO_AUTORESIZE) wxFLAGS_MEMBER(wxALIGN_LEFT) wxFLAGS_MEMBER(wxALIGN_RIGHT) wxFLAGS_MEMBER(wxALIGN_CENTRE) wxEND_FLAGS( wxStaticTextStyle ) IMPLEMENT_DYNAMIC_CLASS_XTI(wxStaticText, wxControl,"wx/stattext.h") wxBEGIN_PROPERTIES_TABLE(wxStaticText) wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) wxPROPERTY_FLAGS( WindowStyle , wxStaticTextStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style wxEND_PROPERTIES_TABLE() wxBEGIN_HANDLERS_TABLE(wxStaticText) wxEND_HANDLERS_TABLE() wxCONSTRUCTOR_6( wxStaticText , wxWindow* , Parent , wxWindowID , Id , wxString , Label , wxPoint , Position , wxSize , Size , long , WindowStyle ) #else IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl) #endif bool wxStaticText::Create(wxWindow *parent, wxWindowID id, const wxString& label, const wxPoint& pos,
wxIcon* IconGetter::GetDocumentIcon(const wxString& filePath, int iconSize) { #ifdef __WINDOWS__ // Get the file type from the file extension wxFileType* fileType = NULL; wxFileName filename = wxFileName(filePath); wxString fileExtension = filename.GetExt(); if (fileExtension != wxEmptyString) { fileType = wxTheMimeTypesManager->GetFileTypeFromExtension(fileExtension); } if (!fileType) { // The file type is not registered on the system, so try to get the default // icon from shell32.dll (works on Windows XP - not sure on Vista) // LPTSTR is wchar_t if UNICODE is enabled, or a char otherwise LPTSTR buffer = new TCHAR[MAX_PATH]; int success = GetSystemDirectory(buffer, MAX_PATH); // Convert the LPTSTR to a char* char cString[MAX_PATH]; wcstombs(cString, buffer, MAX_PATH); wxDELETE(buffer); wxString shell32Path; if (success) { shell32Path = wxString::FromAscii(cString); shell32Path += wxT("\\SHELL32.DLL"); } else { // If we couldn't get the system directory, try to guess it. // If the file doesn't exist, GetExecutableIcon() will return wxNullIcon shell32Path = wxT("C:\\WINDOWS\\SYSTEM32\\SHELL32.DLL"); } return GetExecutableIcon(shell32Path, iconSize); } // Try to get the icon location from the file type wxIconLocation iconLocation; bool success = fileType->GetIcon(&iconLocation); // Fixes a bug in wxWidgets: Sometime the icon is negative, in which case the wxIconLocation will be invalid if (iconLocation.GetIndex() < 0) iconLocation.SetIndex(0); // Fixes a bug in wxWidgets: The filename is sometime surrounded by quotes, and so the wxIconLocation will // again be invalid. We remove the quotes below: wxString iconLocFile = iconLocation.GetFileName(); while (iconLocFile[0] == _T('"')) iconLocFile = iconLocFile.Mid(1, iconLocFile.Len()); while (iconLocFile[iconLocFile.Len() - 1] == _T('"')) iconLocFile = iconLocFile.Mid(0, iconLocFile.Len() - 1); iconLocation.SetFileName(iconLocFile); wxDELETE(fileType); if (success) { wxIcon* icon = new wxIcon(iconLocation); icon->SetSize(iconSize, iconSize); return icon; } else { // If we couldn't find the icon at this stage, look for it in the registry. The icon file path // may be stored in many different places. We need to look in: // // HKEY_CLASSES_ROOT\.<extension>\DefaultIcon\<defaultValue> // HKEY_CLASSES_ROOT\<documentType>\DefaultIcon\<defaultValue> // HKEY_CLASSES_ROOT\CLSID\<classId>\DefaultIcon\<defaultValue> // // The document type can be read at HKEY_CLASSES_ROOT\.<extension>\<defaultValue> // The class ID is (sometime) at HKEY_CLASSES_ROOT\<documentType>\CLSID\<defaultValue> // // Note: all the DefaultIcon values already seem to be handled by wxWidgets so we // only care about the CLSID case below. // // If there is no class ID, we could also look in: // HKEY_CLASSES_ROOT\<documentType>\shell\open\command // then get the associated executable from there and, finally, get the icon. // This is currently not implemented. // // Finally, some icons are displayed using an icon handler that can be found at: // HKEY_CLASSES_ROOT\<documentType>\ShellEx\IconHandler\<defaultValue> // This is a special module which displays the icon depending on the file content. It // may actually display two different icons for the same file extension. For example, // a C# .sln file is going to be displayed differently than a C++ .sln file. These cases // are hopefully rare enough to ignore them. wxRegKey* regKey = new wxRegKey(_T("HKEY_CLASSES_ROOT\\.") + fileExtension); wxString iconPath; if (regKey->Exists()) { wxString extensionLink = regKey->QueryDefaultValue(); if (extensionLink != wxEmptyString) { wxDELETE(regKey); regKey = new wxRegKey(_T("HKEY_CLASSES_ROOT\\") + extensionLink + _T("\\CLSID")); if (regKey->Exists()) { wxString classIdLink = regKey->QueryDefaultValue(); if (classIdLink != wxEmptyString) { wxDELETE(regKey); regKey = new wxRegKey(_T("HKEY_CLASSES_ROOT\\CLSID\\") + classIdLink + _T("\\DefaultIcon")); if (regKey->Exists()) { iconPath = regKey->QueryDefaultValue(); } } } } } wxDELETE(regKey); if (iconPath != wxEmptyString) { // The icon path may be specified with coma or followed by the icon index, as in: // c:\WINDOWS\Installer\{AC76BA86-7AD7-1033-7B44-A90000000001}\PDFFile_8.ico,0 // So we need to split the string and extract the file path and index. wxArrayString splitted; if (iconPath.Find(_T(';')) != wxNOT_FOUND) { StringUtil::Split(iconPath, splitted, _T(";")); } else { StringUtil::Split(iconPath, splitted, _T(",")); } iconPath = splitted[0]; long iconIndex = 0; // If the conversion to long fails, we default to "0" which should be safe if (splitted.Count() > 1) splitted[1].ToLong(&iconIndex); // Sometime, the icon index is negative, for example for .resx files. Not sure // why since the icon actually displayed by Windows is at index 0. if (iconIndex < 0) iconIndex = 0; wxFileName f(iconPath); wxString e = f.GetExt().Lower(); // Normally, it shouldn't be anything other than ico, exe or dll. If it is, we just return NULL for now. if (e == _T("ico") || e == _T("exe") || e == _T("dll")) return IconGetter::GetExecutableIcon(iconPath, iconSize, iconIndex); } } #endif // __WINDOWS__ return NULL; }
wxString wxStandardPaths::GetDataDir() const { return GetInstallPrefix() + wxT("\\data"); }
wxString wxStandardPaths::GetUserDataDir() const { return AppendAppInfo(wxFileName::GetHomeDir() + wxT("\\.")); }
/* Read a gerber file, RS274D or RS274X format. */ bool GERBVIEW_FRAME::Read_GERBER_File( const wxString& GERBER_FullFileName, const wxString& D_Code_FullFileName ) { int G_command = 0; // command number for G commands like G04 int D_commande = 0; // command number for D commands like D02 char line[GERBER_BUFZ]; wxString msg; char* text; int layer; // current layer used in GerbView layer = getActiveLayer(); if( g_GERBER_List[layer] == NULL ) { g_GERBER_List[layer] = new GERBER_IMAGE( this, layer ); } GERBER_IMAGE* gerber = g_GERBER_List[layer]; ClearMessageList( ); /* Set the gerber scale: */ gerber->ResetDefaultValues(); /* Read the gerber file */ gerber->m_Current_File = wxFopen( GERBER_FullFileName, wxT( "rt" ) ); if( gerber->m_Current_File == 0 ) { msg.Printf( _( "File <%s> not found" ), GetChars( GERBER_FullFileName ) ); DisplayError( this, msg, 10 ); return false; } gerber->m_FileName = GERBER_FullFileName; wxString path = wxPathOnly( GERBER_FullFileName ); if( path != wxEmptyString ) wxSetWorkingDirectory( path ); SetLocaleTo_C_standard(); while( true ) { if( fgets( line, sizeof(line), gerber->m_Current_File ) == NULL ) { if( gerber->m_FilesPtr == 0 ) break; fclose( gerber->m_Current_File ); gerber->m_FilesPtr--; gerber->m_Current_File = gerber->m_FilesList[gerber->m_FilesPtr]; continue; } text = StrPurge( line ); while( text && *text ) { switch( *text ) { case ' ': case '\r': case '\n': text++; break; case '*': // End command gerber->m_CommandState = END_BLOCK; text++; break; case 'M': // End file gerber->m_CommandState = CMD_IDLE; while( *text ) text++; break; case 'G': /* Line type Gxx : command */ G_command = gerber->GCodeNumber( text ); gerber->Execute_G_Command( text, G_command ); break; case 'D': /* Line type Dxx : Tool selection (xx > 0) or * command if xx = 0..9 */ D_commande = gerber->DCodeNumber( text ); gerber->Execute_DCODE_Command( text, D_commande ); break; case 'X': case 'Y': /* Move or draw command */ gerber->m_CurrentPos = gerber->ReadXYCoord( text ); if( *text == '*' ) // command like X12550Y19250* { gerber->Execute_DCODE_Command( text, gerber->m_Last_Pen_Command ); } break; case 'I': case 'J': /* Auxiliary Move command */ gerber->m_IJPos = gerber->ReadIJCoord( text ); if( *text == '*' ) // command like X35142Y15945J504* { gerber->Execute_DCODE_Command( text, gerber->m_Last_Pen_Command ); } break; case '%': if( gerber->m_CommandState != ENTER_RS274X_CMD ) { gerber->m_CommandState = ENTER_RS274X_CMD; gerber->ReadRS274XCommand( line, text ); } else //Error { ReportMessage( wxT("Expected RS274X Command") ); gerber->m_CommandState = CMD_IDLE; text++; } break; default: text++; msg.Printf( wxT("Unexpected symbol <%c>"), *text ); ReportMessage( msg ); break; } } } fclose( gerber->m_Current_File ); SetLocaleTo_Default(); gerber->m_InUse = true; // Display errors list if( m_Messages.size() > 0 ) { HTML_MESSAGE_BOX dlg( this, _("Errors") ); dlg.ListSet(m_Messages); dlg.ShowModal(); } /* if the gerber file is only a RS274D file * (i.e. without any aperture information), wran the user: */ if( !gerber->m_Has_DCode ) { msg = _("Warning: this file has no D-Code definition\n" "It is perhaps an old RS274D file\n" "Therefore the size of items is undefined"); wxMessageBox( msg ); } return true; }
void PCB_EDIT_FRAME::OnUpdateShowMicrowaveToolbar( wxUpdateUIEvent& aEvent ) { aEvent.Check( m_auimgr.GetPane( wxT( "m_microWaveToolBar" ) ).IsShown() ); }
void PCB_EDIT_FRAME::OnUpdateShowLayerManager( wxUpdateUIEvent& aEvent ) { aEvent.Check( m_auimgr.GetPane( wxT( "m_LayersManagerToolBar" ) ).IsShown() ); }
GroupCell::GroupCell(int groupType, wxString initString) : MathCell() { m_input = NULL; m_output = NULL; m_hiddenTree = NULL; m_outputRect.x = -1; m_outputRect.y = -1; m_outputRect.width = 0; m_outputRect.height = 0; m_group = this; m_forceBreakLine = true; m_breakLine = true; m_type = MC_TYPE_GROUP; m_indent = MC_GROUP_LEFT_INDENT; m_hide = false; m_working = false; m_groupType = groupType; m_lastInOutput = NULL; m_appendedCells = NULL; // set up cell depending on groupType, so we have a working cell if (groupType != GC_TYPE_PAGEBREAK) { if (groupType == GC_TYPE_CODE) m_input = new TextCell(EMPTY_INPUT_LABEL); else m_input = new TextCell(wxT(" ")); m_input->SetType(MC_TYPE_MAIN_PROMPT); } bool match = true; wxConfig::Get()->Read(wxT("matchParens"), &match); EditorCell *editor = new EditorCell(); editor->SetMatchParens(match); switch (groupType) { case GC_TYPE_CODE: editor->SetType(MC_TYPE_INPUT); AppendInput(editor); break; case GC_TYPE_TEXT: m_input->SetType(MC_TYPE_TEXT); editor->SetType(MC_TYPE_TEXT); AppendInput(editor); break; case GC_TYPE_TITLE: m_input->SetType(MC_TYPE_TITLE); editor->SetType(MC_TYPE_TITLE); AppendInput(editor); break; case GC_TYPE_SECTION: m_input->SetType(MC_TYPE_SECTION); editor->SetType(MC_TYPE_SECTION); AppendInput(editor); break; case GC_TYPE_SUBSECTION: m_input->SetType(MC_TYPE_SUBSECTION); editor->SetType(MC_TYPE_SUBSECTION); AppendInput(editor); break; case GC_TYPE_IMAGE: m_input->SetType(MC_TYPE_TEXT); editor->SetType(MC_TYPE_TEXT); editor->SetValue(wxEmptyString); AppendInput(editor); break; default: delete editor; editor = NULL; break; } if (editor != NULL) editor->SetValue(initString); // when creating an image cell, if a string is provided // it loads an image (without deleting it) if ((groupType == GC_TYPE_IMAGE) && (initString.Length() > 0)) { ImgCell *ic = new ImgCell(initString, false); AppendOutput(ic); } SetParent(this, false); }
void wxHIDJoystick::MakeCookies(CFArrayRef Array) { int i, nUsage, nPage; for (i = 0; i < CFArrayGetCount(Array); ++i) { const void* ref = CFDictionaryGetValue( (CFDictionaryRef)CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementKey) ); if (ref != NULL) { MakeCookies((CFArrayRef) ref); } else { CFNumberGetValue( (CFNumberRef) CFDictionaryGetValue( (CFDictionaryRef) CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementUsageKey) ), kCFNumberIntType, &nUsage ); CFNumberGetValue( (CFNumberRef) CFDictionaryGetValue( (CFDictionaryRef) CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementUsagePageKey) ), kCFNumberIntType, &nPage ); #if 0 wxLogSysError(wxT("[%i][%i]"), nUsage, nPage); #endif if (nPage == kHIDPage_Button && nUsage <= 40) AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), nUsage-1 ); else if (nPage == kHIDPage_GenericDesktop) { //axis... switch(nUsage) { case kHIDUsage_GD_X: AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_X); wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementMaxKey), &m_nXMax); wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementMinKey), &m_nXMin); break; case kHIDUsage_GD_Y: AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_Y); wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementMaxKey), &m_nYMax); wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementMinKey), &m_nYMin); break; case kHIDUsage_GD_Z: AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_Z); wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementMaxKey), &m_nZMax); wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementMinKey), &m_nZMin); break; default: break; } } else if (nPage == kHIDPage_Simulation && nUsage == kHIDUsage_Sim_Rudder) { //rudder... AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_RUDDER ); wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementMaxKey), &m_nRudderMax); wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i), CFSTR(kIOHIDElementMinKey), &m_nRudderMin); } } } }
wxString GroupCell::PrepareForTeX(wxString str) { #if !wxUSE_UNICODE wxString str1(str.wc_str(wxConvLocal), wxConvUTF8); #else wxString str1(str); #endif str1.Replace(wxT("\\"), wxT("\\verb|\\|")); str1.Replace(wxT("_"), wxT("\\_")); str1.Replace(wxT("%"), wxT("\\%")); str1.Replace(wxT("{"), wxT("\\{")); str1.Replace(wxT("}"), wxT("\\}")); str1.Replace(wxT("^"), wxT("\\verb|^|")); str1.Replace(wxT(">"), wxT("\\verb|>|")); str1.Replace(wxT("<"), wxT("\\verb|<|")); #if !wxUSE_UNICODE wxString str2(str1.wc_str(wxConvUTF8), wxConvLocal); #else wxString str2(str1); #endif return str2; }
//--------------------------------------------------------------------------- // wxJoystickThread::Entry // // Thread procedure // // Runs a CFRunLoop for polling. Basically, it sets the HID queue to // call wxJoystickThread::HIDCallback in the context of this thread // when something changes on the device. It polls as long as the user // wants, or a certain amount if the user wants to "block". Note that // we don't actually block here since this is in a secondary thread. //--------------------------------------------------------------------------- void* wxJoystickThread::Entry() { CFRunLoopSourceRef pRLSource = NULL; if ((*m_hid->GetQueue())->createAsyncEventSource( m_hid->GetQueue(), &pRLSource) != kIOReturnSuccess ) { wxLogSysError(wxT("Couldn't create async event source")); return NULL; } wxASSERT(pRLSource != NULL); //attach runloop source to main run loop in thread CFRunLoopRef pRL = CFRunLoopGetCurrent(); CFRunLoopAddSource(pRL, pRLSource, kCFRunLoopDefaultMode); wxASSERT( CFRunLoopContainsSource(pRL, pRLSource, kCFRunLoopDefaultMode) ); if( (*m_hid->GetQueue())->setEventCallout(m_hid->GetQueue(), wxJoystickThread::HIDCallback, this, this) != kIOReturnSuccess ) { wxLogSysError(wxT("Could not set event callout for queue")); return NULL; } if( (*m_hid->GetQueue())->start(m_hid->GetQueue()) != kIOReturnSuccess ) { wxLogSysError(wxT("Could not start queue")); return NULL; } double dTime; while(true) { if (TestDestroy()) break; if (m_polling) dTime = 0.0001 * m_polling; else dTime = 0.0001 * 10; // check at least every 10 msec in "blocking" case //true just "handles and returns" - false forces it to stay the time //amount #if 1 CFRunLoopRunInMode(kCFRunLoopDefaultMode, dTime, true); #else IOReturn ret = NULL; HIDCallback(this, ret, this, this); Sleep(3000); #endif } wxASSERT( CFRunLoopContainsSource(pRL, pRLSource, kCFRunLoopDefaultMode) ); CFRunLoopRemoveSource(pRL, pRLSource, kCFRunLoopDefaultMode); CFRelease(pRLSource); return NULL; }
// ToXML // writes a groupcell in the form of // <cell type="code" hide="true"> // --contents-- // </cell> wxString GroupCell::ToXML(bool all) { wxString str; str = wxT("\n<cell"); // start opening tag // write "type" according to m_groupType switch (m_groupType) { case GC_TYPE_CODE: str += wxT(" type=\"code\""); break; case GC_TYPE_IMAGE: str += wxT(" type=\"image\""); break; case GC_TYPE_TEXT: str += wxT(" type=\"text\""); break; case GC_TYPE_TITLE: str += wxT(" type=\"title\""); break; case GC_TYPE_SECTION: str += wxT(" type=\"section\""); break; case GC_TYPE_SUBSECTION: str += wxT(" type=\"subsection\""); break; case GC_TYPE_PAGEBREAK: { str += wxT(" type=\"pagebreak\"/>"); return str + MathCell::ToXML(all); } break; default: str += wxT(" type=\"unknown\""); break; } // write hidden status if (m_hide) str += wxT(" hide=\"true\""); str += wxT(">\n"); MathCell *input = GetInput(); MathCell *output = GetLabel(); // write contents switch (m_groupType) { case GC_TYPE_CODE: if (input != NULL) { str += wxT("<input>\n"); str += input->ToXML(false); str += wxT("</input>"); } if (output != NULL) { str += wxT("\n<output>\n"); str += wxT("<mth>") + output->ToXML(true) + wxT("</mth>"); str += wxT("\n</output>"); } break; case GC_TYPE_IMAGE: if (input != NULL) str += input->ToXML(false); if (output != NULL) str += output->ToXML(true); break; case GC_TYPE_TEXT: if (input) str += input->ToXML(false); break; case GC_TYPE_TITLE: case GC_TYPE_SECTION: case GC_TYPE_SUBSECTION: if (input) str += input->ToXML(false); if (m_hiddenTree) { str += wxT("<fold>"); GroupCell *tmp = m_hiddenTree; while (tmp) { str += tmp->ToXML(false); tmp = dynamic_cast<GroupCell*>(tmp->m_next); } str += wxT("</fold>"); } break; default: if (output != NULL) str += output->ToXML(false); break; } str += wxT("\n</cell>\n"); return str + MathCell::ToXML(all); }
//--------------------------------------------------------------------------- // wxJoystickThread::HIDCallback (static) // // Callback for the native HID device when it recieves input. // // This is where the REAL dirty work gets done. // // 1) Loops through each event the queue has recieved // 2) First, checks if the thread that is running the loop for // the polling has ended - if so it breaks out // 3) Next, it checks if there was an error getting this event from // the HID queue, if there was, it logs an error and returns // 4) Now it does the real dirty work by getting the button states // from cookies 0-40 and axes positions/states from cookies 40-50 // in the native HID device by quering cookie values. // 5) Sends the event to the polling window (if any) // 6) Gets the next event and goes back to (1) //--------------------------------------------------------------------------- /*static*/ void wxJoystickThread::HIDCallback(void* WXUNUSED(target), IOReturn WXUNUSED(res), void* context, void* WXUNUSED(sender)) { IOHIDEventStruct hidevent; AbsoluteTime bogustime = {0,0}; IOReturn ret; wxJoystickThread* pThis = (wxJoystickThread*) context; wxHIDJoystick* m_hid = pThis->m_hid; //Get the "first" event from the queue //bogustime tells it we don't care at what time to start //where it gets the next from ret = (*m_hid->GetQueue())->getNextEvent(m_hid->GetQueue(), &hidevent, bogustime, 0); while (ret != kIOReturnUnderrun) { if (pThis->TestDestroy()) break; if(ret != kIOReturnSuccess) { wxLogSysError(wxString::Format(wxT("wxJoystick Error:[%i]"), ret)); return; } wxJoystickEvent wxevent; //Find the cookie that changed int nIndex = 0; IOHIDElementCookie* pCookies = m_hid->GetCookies(); while(nIndex < 50) { if(hidevent.elementCookie == pCookies[nIndex]) break; ++nIndex; } //debugging stuff #if 0 if(nIndex == 50) { wxLogSysError(wxString::Format(wxT("wxJoystick Out Of Bounds Error"))); break; } #endif //is the cookie a button? if (nIndex < 40) { if (hidevent.value) { pThis->m_buttons |= (1 << nIndex); wxevent.SetEventType(wxEVT_JOY_BUTTON_DOWN); } else { pThis->m_buttons &= ~(1 << nIndex); wxevent.SetEventType(wxEVT_JOY_BUTTON_UP); } wxevent.SetButtonChange(nIndex+1); } else if (nIndex == wxJS_AXIS_X) { pThis->m_lastposition.x = hidevent.value; wxevent.SetEventType(wxEVT_JOY_MOVE); pThis->m_axe[0] = hidevent.value; } else if (nIndex == wxJS_AXIS_Y) { pThis->m_lastposition.y = hidevent.value; wxevent.SetEventType(wxEVT_JOY_MOVE); pThis->m_axe[1] = hidevent.value; } else if (nIndex == wxJS_AXIS_Z) { wxevent.SetEventType(wxEVT_JOY_ZMOVE); pThis->m_axe[2] = hidevent.value; } else wxevent.SetEventType(wxEVT_JOY_MOVE); Nanoseconds timestamp = AbsoluteToNanoseconds(hidevent.timestamp); wxULongLong llTime(timestamp.hi, timestamp.lo); llTime /= 1000000; wxevent.SetTimestamp(llTime.GetValue()); wxevent.SetJoystick(pThis->m_joystick); wxevent.SetButtonState(pThis->m_buttons); wxevent.SetPosition(pThis->m_lastposition); wxevent.SetZPosition(pThis->m_axe[2]); wxevent.SetEventObject(pThis->m_catchwin); if (pThis->m_catchwin) pThis->m_catchwin->GetEventHandler()->AddPendingEvent(wxevent); ret = (*m_hid->GetQueue())->getNextEvent(m_hid->GetQueue(), &hidevent, bogustime, 0); } }
void DlgPass::updateProperties(Pass *p) { // m_PG->SetPropertyValue(wxT("Class"), wxString(p->getClassName().c_str())); // CAMERA if (p->getClassName() == "quad") m_PG->DisableProperty(wxT("Camera")); else m_PG->EnableProperty(wxT("Camera")); m_PG->SetPropertyValue(wxT("Camera"), wxString(p->getCameraName().c_str())); // VIEWPORT std::shared_ptr<Viewport> v = p->getViewport(); if (p->hasRenderTarget() && p->isRenderTargetEnabled()) { m_PG->SetPropertyValue(wxT("Viewport"), wxT("From Render Target")); m_PG->DisableProperty(wxT("Viewport")); } else if (!v) { m_PG->EnableProperty(wxT("Viewport")); m_PG->SetPropertyValue(wxT("Viewport"), wxT("From Camera")); } else { m_PG->EnableProperty(wxT("Viewport")); m_PG->SetPropertyValue(wxT("Viewport"), wxString(v->getName().c_str())); } // RENDER TARGET if (RESOURCEMANAGER->getNumRenderTargets()) { m_PG->EnableProperty(wxT("Render Target")); m_PG->EnableProperty(wxT("Use Render Target")); } else { m_PG->DisableProperty(wxT("Render Target")); m_PG->DisableProperty(wxT("Use Render Target")); } if (p->hasRenderTarget()) m_PG->SetPropertyValue(wxT("Render Target"), wxString(p->getRenderTarget()->getName().c_str())); else m_PG->SetPropertyValue(wxT("Render Target"), wxT("None")); m_PG->SetPropertyValue(wxT("Use Render Target"),p->isRenderTargetEnabled()); // SCENES std::vector<std::string> names; RENDERMANAGER->getAllSceneNames(&names); std::vector<std::string>::iterator iter; bool b; for (iter = names.begin(); iter != names.end(); ++iter) { if (p->hasScene(*iter)) b = true; else b = false; wxString str(wxT("Scenes.")); str.Append(wxString(*iter).c_str()); m_PG->SetPropertyValue(str, b); } // LIGHTS std::vector<std::string> lNames; RENDERMANAGER->getLightNames(&lNames); for (auto & name:lNames) { if (p->hasLight(name)) b = true; else b = false; wxString str(wxT("Lights.")); wxString aux(name.c_str()); str.Append(wxString(name.c_str())); m_PG->SetPropertyValue(str, b); } if (m_PG->GetPropertyByName(wxT("Material Maps"))) m_PG->DeleteProperty(wxT("Material Maps")); std::map<std::string, nau::material::MaterialID> mm = p->getMaterialMap(); wxPGProperty *pgMM; pgMM = m_PG->Append(new wxPGProperty(wxT("Material Maps"), wxPG_LABEL)); std::map<std::string, nau::material::MaterialID>::iterator iterMM = mm.begin(); MaterialID mid; wxString mName,propName; if (mm.size() != 0 && iterMM->first == "*") { mid = iterMM->second; mName = wxString(mid.getLibName().c_str()); mName.append(wxT("::")); mName.append(wxString(mid.getMaterialName().c_str())); m_PG->AppendIn(pgMM, new wxEnumProperty(wxT("*"), wxPG_LABEL,m_pgMaterialListPlus)); propName = wxT("Material Maps.*"); m_PG->SetPropertyValue(propName, mName); ++iterMM; } else { m_PG->AppendIn(pgMM, new wxEnumProperty(wxT("*"), wxPG_LABEL,m_pgMaterialListPlus)); propName = wxT("Material Maps.*"); m_PG->SetPropertyValue(propName, wxT("None")); } for ( ; iterMM != mm.end() ; ++iterMM) { mid = iterMM->second; mName = wxString(mid.getLibName().c_str()); mName.append(wxT("::")); mName.append(wxString(mid.getMaterialName().c_str())); m_PG->AppendIn(pgMM, new wxEnumProperty(wxString(iterMM->first.c_str()), wxPG_LABEL,m_pgMaterialList)); propName = wxT("Material Maps."); propName.append(wxString(iterMM->first.c_str())); m_PG->SetPropertyValue(propName, mName); //property name is the first value of the map, the prop value is the second value of the map } PropertyManager::updateGrid(m_PG, Pass::GetAttribs(), (AttributeValues *)p); Refresh(); //m_PG->RefreshGrid();//->Refresh(); }
/* Must be called on a click on the left toolbar (options toolbar * Update variables according to tools states */ void PCB_EDIT_FRAME::OnSelectOptionToolbar( wxCommandEvent& event ) { int id = event.GetId(); bool state = event.IsChecked(); DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)GetDisplayOptions(); switch( id ) { case ID_TB_OPTIONS_DRC_OFF: g_Drc_On = !state; if( GetToolId() == ID_TRACK_BUTT ) { if( g_Drc_On ) m_canvas->SetCursor( wxCURSOR_PENCIL ); else m_canvas->SetCursor( wxCURSOR_QUESTION_ARROW ); } break; case ID_TB_OPTIONS_SHOW_RATSNEST: SetElementVisibility( RATSNEST_VISIBLE, state ); if( state && (GetBoard()->m_Status_Pcb & LISTE_RATSNEST_ITEM_OK) == 0 ) Compile_Ratsnest( NULL, true ); m_canvas->Refresh(); break; case ID_TB_OPTIONS_SHOW_MODULE_RATSNEST: displ_opts->m_Show_Module_Ratsnest = state; // TODO: see if we can use the visibility list break; case ID_TB_OPTIONS_AUTO_DEL_TRACK: g_AutoDeleteOldTrack = state; break; case ID_TB_OPTIONS_SHOW_ZONES: displ_opts->m_DisplayZonesMode = 0; m_canvas->Refresh(); break; case ID_TB_OPTIONS_SHOW_ZONES_DISABLE: displ_opts->m_DisplayZonesMode = 1; m_canvas->Refresh(); break; case ID_TB_OPTIONS_SHOW_ZONES_OUTLINES_ONLY: displ_opts->m_DisplayZonesMode = 2; m_canvas->Refresh(); break; case ID_TB_OPTIONS_SHOW_VIAS_SKETCH: displ_opts->m_DisplayViaFill = !state; m_canvas->Refresh(); break; case ID_TB_OPTIONS_SHOW_TRACKS_SKETCH: displ_opts->m_DisplayPcbTrackFill = !state; m_canvas->Refresh(); break; case ID_TB_OPTIONS_SHOW_HIGH_CONTRAST_MODE: { displ_opts->m_ContrastModeDisplay = state; m_canvas->Refresh(); break; } case ID_TB_OPTIONS_SHOW_EXTRA_VERTICAL_TOOLBAR_MICROWAVE: m_show_microwave_tools = state; m_auimgr.GetPane( wxT( "m_microWaveToolBar" ) ).Show( m_show_microwave_tools ); m_auimgr.Update(); GetMenuBar()->SetLabel( ID_MENU_PCB_SHOW_HIDE_MUWAVE_TOOLBAR, m_show_microwave_tools ? _( "Hide Microwave Toolbar" ): _( "Show Microwave Toolbar" )); break; case ID_TB_OPTIONS_SHOW_MANAGE_LAYERS_VERTICAL_TOOLBAR: // show auxiliary Vertical layers and visibility manager toolbar m_show_layer_manager_tools = state; m_auimgr.GetPane( wxT( "m_LayersManagerToolBar" ) ).Show( m_show_layer_manager_tools ); m_auimgr.Update(); GetMenuBar()->SetLabel( ID_MENU_PCB_SHOW_HIDE_LAYERS_MANAGER_DIALOG, m_show_layer_manager_tools ? _( "Hide &Layers Manager" ) : _( "Show &Layers Manager" ) ); break; default: DisplayError( this, wxT( "PCB_EDIT_FRAME::OnSelectOptionToolbar error \n (event not handled!)" ) ); break; } }
void DlgPass::OnProcessPGChange( wxPropertyGridEvent& e) { Pass *p = getPass(); wxString name,subname,value; std::string mat,lib; name = e.GetPropertyName(); int index; index = e.GetPropertyValue().GetInteger(); if (name == wxT("Camera")) { value = m_pgCamList.GetLabel(index); p->setCamera(std::string(value.mb_str())); } else if (name == wxT("Viewport")) { if (index == 0) p->setViewport(RENDERMANAGER->getCamera(p->getCameraName())->getViewport()); else { value = m_pgViewportList.GetLabel(index-1); p->setViewport(RENDERMANAGER->getViewport(std::string(value.mb_str()))); } } else if (name == wxT("Use Render Target")) { p->enableRenderTarget(0 != e.GetPropertyValue().GetBool()); } else if (name == wxT("Render Target")) { value = e.GetPropertyValue().GetString(); if (value == wxT("None")) { p->setRenderTarget(NULL); m_PG->SetPropertyValue(wxT("Viewport"),wxT("From Camera")); m_PG->EnableProperty(wxT("Viewport")); } else { m_PG->SetPropertyValue(wxT("Viewport"), wxT("From Render Target")); m_PG->DisableProperty(wxT("Viewport")); p->setRenderTarget(RESOURCEMANAGER->getRenderTarget(std::string(value.mb_str()))); } } //else if (name == wxT("Clear Color")) // p->setPropb(Pass::COLOR_CLEAR, (0 != e.GetPropertyValue().GetBool())); //else if (name == wxT("Clear Depth")) // p->setPropb(Pass::DEPTH_CLEAR, (0 != e.GetPropertyValue().GetBool())); else if (name.substr(0,6) == wxT("Lights")) { subname = name.substr(7,std::string::npos); bool b = 0 != e.GetPropertyValue().GetBool(); if (b) p->addLight(std::string(subname.mb_str())); else p->removeLight(std::string(subname.mb_str())); } else if (name.substr(0,6) == wxT("Scenes")) { subname = name.substr(7,std::string::npos); bool b = 0 != e.GetPropertyValue().GetBool(); if (b) p->addScene(std::string(subname.mb_str())); else p->removeScene(std::string(subname.mb_str())); } else if (name.substr(0,13) == wxT("Material Maps")) { // Material Maps subname = name.substr(14, std::string::npos); if (subname == wxT("*")) value = m_pgMaterialListPlus.GetLabel(e.GetPropertyValue().GetInteger()); else value = m_pgMaterialList.GetLabel(e.GetPropertyValue().GetInteger()); mat = std::string(value.AfterLast(':').mb_str()); lib = std::string(value.BeforeFirst(':').mb_str()); if (subname == wxT("*")) { if (mat == "*") { p->remapAll(lib); updateMats(p); } else if (value != wxT("None")) { p->remapAll(lib,mat); updateMats(p); } } else p->remapMaterial(std::string(subname.c_str()),lib,mat); } else PropertyManager::updateProp(m_PG, name.ToStdString(), Pass::GetAttribs(), (AttributeValues *)p); //else if (name.substr(0,10) == wxT("Parameters")) { // subname = name.substr(11, std::string::npos); // p->setParam(std::string(subname.mb_str()), (float)(e.GetPropertyValue().GetDouble())); // //} }
// Get PID and name of each process that has our DLL loaded. static bool GetProcesses(std::vector<ProcessInfo>& processes) { // PSAPI function pointers. BOOL (WINAPI* lpfEnumProcesses)(DWORD*, DWORD, DWORD*); BOOL (WINAPI* lpfEnumProcessModules)(HANDLE, HMODULE*, DWORD, LPDWORD ); DWORD (WINAPI* lpfGetModuleBaseName)(HANDLE, HMODULE, LPCTSTR, DWORD); bool found = false; // Load library and get function pointers. HINSTANCE hInstLib = LoadLibraryA("PSAPI.DLL"); if (!hInstLib) { DBG("Failed to load PSAPI.DLL"); return false; } // Get procedure addresses. lpfEnumProcesses = (BOOL (WINAPI*)(DWORD*,DWORD,DWORD*)) GetProcAddress(hInstLib, "EnumProcesses"); lpfEnumProcessModules = (BOOL (WINAPI*)(HANDLE, HMODULE*, DWORD, LPDWORD)) GetProcAddress( hInstLib, "EnumProcessModules" ); lpfGetModuleBaseName =(DWORD (WINAPI*)(HANDLE, HMODULE, LPCTSTR, DWORD )) GetProcAddress( hInstLib, "GetModuleBaseNameW" ); if (!lpfEnumProcesses || !lpfEnumProcessModules || !lpfGetModuleBaseName) { DBG("GetProcAddress failed"); FreeLibrary(hInstLib); return false; } DWORD pidList[1000]; DWORD iCbneeded; if (!lpfEnumProcesses(pidList, sizeof(pidList), &iCbneeded)) { DBG("EnumProcesses failed"); FreeLibrary(hInstLib); return false; } // How many processes are there? int iNumProc = iCbneeded/sizeof(DWORD); // Get and match the name of each process for (int i = 0; i < iNumProc; ++i) { // First, get a handle to the process HANDLE processHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pidList[i]); if (processHandle) { // Get modules loaded by process int maxModules = 1000; HMODULE* hMod = 0; while (1) { hMod = new HMODULE[maxModules]; // Determine number of modules if (!lpfEnumProcessModules(processHandle, hMod, maxModules*sizeof(HMODULE), &iCbneeded)) { DWORD err = GetLastError(); if (err = ERROR_PARTIAL_COPY) { // This means that we are looking at the SYSTEM process. Skip it. delete[] hMod; hMod = 0; break; } } else if (iCbneeded <= maxModules*sizeof(HMODULE)) break; delete[] hMod; if (maxModules > 50000) { DBG("maxModules: " << maxModules); return false; // This is getting ridiculous... } } if (!hMod) continue; // Explorer? TCHAR executableName[MAX_PATH]; if (!lpfGetModuleBaseName(processHandle, hMod[0], executableName, MAX_PATH)) { DBG("GetModuleBaseName failed for process " << pidList[i]); return false; } //DBG("PROCESS " << wxAscii(executableName)); if (!_tcsicmp(executableName, wxT("explorer.exe"))) { // Explorer must always be killed processes.push_back(ProcessInfo(pidList[i], executableName, wxT(""))); continue; } // Check if any of the modules are our DLL int numModules = iCbneeded/sizeof(HMODULE); for (int j = 1; j < numModules; ++j) { TCHAR name[MAX_PATH]; if (!lpfGetModuleBaseName(processHandle, hMod[j], name, MAX_PATH)) { DBG("GetModuleBaseName failed for module " << j); return false; } if (!_tcsicmp(name, wxT("tortoiseshell.dll")) || !_tcsicmp(name, wxT("tortoiseshell64.dll"))) { DBG("Process " << pidList[i] << " has " << wxAscii(name) << " loaded"); // Yes, this process must be terminated windowTitle.clear(); EnumWindows(EnumWindowsCallback, pidList[i]); processes.push_back(ProcessInfo(pidList[i], executableName, windowTitle)); } } delete[] hMod; CloseHandle(processHandle); } } FreeLibrary(hInstLib); DBG("GetProcesses SUCCESS"); return true; }
void RadarCanvas::OnMove(wxMoveEvent &evt) { wxPoint pos = m_parent->GetPosition(); LOG_DIALOG(wxT("BR24radar_pi: %s move OpenGL canvas to %d, %d"), m_ri->m_name.c_str(), pos.x, pos.y); }
int SetupHelperApp::OnRun() { #ifdef _WIN64 DBG("--- x64 SetupHelper"); #else DBG("--- x86 SetupHelper"); #endif if (__argc < 3) return -1; std::vector<ProcessInfo> processes; DBG("Get processes (1)"); if (!GetProcesses(processes)) return -1; DBG("Got processes (1):"); for (size_t i = 0; i < processes.size(); ++i) { DBG(i << ": " << processes[i].pid); } // Kill all Explorer and cvslock processes for (size_t i = 0; i < processes.size(); ++i) { if (!_tcsicmp(processes[i].image.c_str(), wxT("explorer.exe"))) { DBG("Killing Explorer"); // Show dialog wxProgressDialog* dlg = new wxProgressDialog(wxT("TortoiseCVS Setup"), wxText(__argv[1])); dlg->Show(); // Kill Explorer TerminateProcess(processes[i]); int i = 0; while (IsProcessRunning(processes[i].pid) && (i < 50)) { dlg->Update((i+1)*100/50); Sleep(50); } // Avoid the Active Desktop error message HKEY hKey; if (RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer", 0, KEY_WRITE, &hKey)) { DWORD data = 0; RegSetValueExA(hKey, "FaultKey", 0, REG_DWORD, reinterpret_cast<BYTE*>(&data), sizeof(DWORD)); } dlg->Destroy(); } else if (!_tcsicmp(processes[i].image.c_str(), wxT("cvslock.exe"))) { // Kill CVSNT lock service TerminateProcess(processes[i]); } } // Show dialog wxProgressDialog* dlg = new wxProgressDialog(wxT("TortoiseCVS Setup"), wxText(__argv[1])); dlg->Show(); // Wait for Explorer restart for (int i = 0; i < 50; ++i) { if (IsExplorerRunning()) break; dlg->Update((i+1)*100/50); Sleep(50); } if (!IsExplorerRunning()) { dlg->Update(0); STARTUPINFOA startupinfo; startupinfo.cb = sizeof(STARTUPINFOA); startupinfo.lpReserved = 0; startupinfo.lpDesktop = 0; startupinfo.lpTitle = 0; startupinfo.dwFlags = 0; startupinfo.cbReserved2 = 0; startupinfo.lpReserved2 = 0; PROCESS_INFORMATION processinfo; CreateProcessA(0, "explorer.exe", 0, 0, FALSE, 0, 0, 0, &startupinfo, &processinfo); CloseHandle(processinfo.hProcess); CloseHandle(processinfo.hThread); for (int i = 0; i < 10; ++i) { Sleep(50); dlg->Update((i+1)*100/10); } } dlg->Destroy(); DBG("Check remaining processes"); bool anyLeft = true; while (anyLeft) { processes.clear(); DBG("Get processes (2)"); if (!GetProcesses(processes)) return -1; DBG("Got processes (2):"); for (size_t i = 0; i < processes.size(); ++i) { DBG(i << ": " << processes[i].pid); } anyLeft = false; for (size_t i = 0; i < processes.size(); ++i) { if (_tcsicmp(processes[i].image.c_str(), wxT("explorer.exe"))) { anyLeft = true; // Ask user to close application wxString msg; msg << wxT("The application "); if (processes[i].title.empty()) { // No title found (may be minimized to tray etc.) msg << processes[i].image; } else msg << wxT("'") << processes[i].title << wxT("' (") << processes[i].image << wxT(")"); msg << wxT("\nneeds to be closed before TortoiseCVS setup can continue.\n") << wxT("Please close the application and click OK, or click Cancel to leave the process ") << wxT("running.\nIn the latter case, you will be required to reboot Windows after installation."); if (MessageBox(0, msg.c_str(), wxT("TortoiseCVS Setup"), MB_OKCANCEL | MB_ICONINFORMATION) == IDCANCEL) return 1; } } } DBG("Loop done"); if (__argv[2][0] == 'b') return 0; // Delete any renamed DLL's // TODO: Make this work even when installing to a different directory std::string rootDir(GetRootDir()); std::string src(rootDir); src += "TortoiseShell.dll_renamed"; DBG("Deleting " << src); DeleteFileA(src.c_str()); src = rootDir; src += "TortoiseShell64.dll_renamed"; DBG("Deleting " << src); DeleteFileA(src.c_str()); src = rootDir; src += "TortoiseAct.exe_renamed"; DBG("Deleting " << src); DeleteFileA(src.c_str()); DBG("Exit: 0"); return 0; }
void ItemContainerWidgetsPage::StartTest(const wxString& label) { m_container->Clear(); wxLogMessage(wxT("Test - %s:"), label.c_str()); }
#ifdef __BORLANDC__ #pragma hdrstop #endif // for all others, include the necessary headers #ifndef WX_PRECOMP #include "wx/wx.h" #endif #include "wx/wfstream.h" #include "bstream.h" #define DATABUFFER_SIZE 1024 static const wxString FILENAME_FFILEINSTREAM = wxT("ffileinstream.test"); static const wxString FILENAME_FFILEOUTSTREAM = wxT("ffileoutstream.test"); /////////////////////////////////////////////////////////////////////////////// // The test case // // Try to fully test wxFFileInputStream and wxFFileOutputStream class ffileStream : public BaseStreamTestCase<wxFFileInputStream, wxFFileOutputStream> { public: ffileStream(); virtual ~ffileStream(); CPPUNIT_TEST_SUITE(ffileStream); // Base class stream tests the ffileStream supports.
MyDialog::MyDialog( wxWindow *parent, const wxString& title, const wxPoint& pos, const wxSize& size, const long WXUNUSED(style) ) : wxDialog(parent, VALIDATE_DIALOG_ID, title, pos, size, wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER) { // setup the flex grid sizer // ------------------------- wxFlexGridSizer *flexgridsizer = new wxFlexGridSizer(3, 2, 5, 5); // Create and add controls to sizers. Note that a member variable // of g_data is bound to each control upon construction. There is // currently no easy way to substitute a different validator or a // different transfer variable after a control has been constructed. // Pointers to some of these controls are saved in member variables // so that we can use them elsewhere, like this one. m_text = new wxTextCtrl(this, VALIDATE_TEXT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_ALPHA, &g_data.m_string)); m_text->SetToolTip("uses wxTextValidator with wxFILTER_ALPHA"); flexgridsizer->Add(m_text, 1, wxGROW); // Now set a wxTextValidator with an explicit list of characters NOT allowed: wxTextValidator textVal(wxFILTER_EMPTY|wxFILTER_EXCLUDE_LIST, &g_data.m_string2); textVal.SetCharExcludes("bcwyz"); wxTextCtrl* txt2 = new wxTextCtrl(this, VALIDATE_TEXT2, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, textVal); txt2->SetToolTip("uses wxTextValidator with wxFILTER_EMPTY|wxFILTER_EXCLUDE_LIST (to exclude 'bcwyz')"); flexgridsizer->Add(txt2, 1, wxGROW); flexgridsizer->Add(new wxListBox((wxWindow*)this, VALIDATE_LIST, wxDefaultPosition, wxDefaultSize, 3, g_listbox_choices, wxLB_MULTIPLE, wxGenericValidator(&g_data.m_listbox_choices)), 1, wxGROW); m_combobox = new wxComboBox(this, VALIDATE_COMBO, wxEmptyString, wxDefaultPosition, wxDefaultSize, 3, g_combobox_choices, 0L, MyComboBoxValidator(&g_data.m_combobox_choice)); m_combobox->SetToolTip("uses a custom validator (MyComboBoxValidator)"); flexgridsizer->Add(m_combobox, 1, wxALIGN_CENTER); // This wxCheckBox* doesn't need to be assigned to any pointer // because we don't use it elsewhere--it can be anonymous. // We don't need any such pointer to query its state, which // can be gotten directly from g_data. flexgridsizer->Add(new wxCheckBox(this, VALIDATE_CHECK, wxT("Sample checkbox"), wxDefaultPosition, wxDefaultSize, 0, wxGenericValidator(&g_data.m_checkbox_state)), 1, wxALIGN_CENTER|wxALL, 15); flexgridsizer->AddGrowableCol(0); flexgridsizer->AddGrowableCol(1); flexgridsizer->AddGrowableRow(1); // setup the button sizer // ---------------------- wxStdDialogButtonSizer *btn = new wxStdDialogButtonSizer(); btn->AddButton(new wxButton(this, wxID_OK)); btn->AddButton(new wxButton(this, wxID_CANCEL)); btn->Realize(); // setup a sizer with the controls for numeric validators // ------------------------------------------------------ wxIntegerValidator<int> valInt(&g_data.m_intValue, wxNUM_VAL_THOUSANDS_SEPARATOR | wxNUM_VAL_ZERO_AS_BLANK); valInt.SetMin(0); // Only allow positive numbers m_numericTextInt = new wxTextCtrl ( this, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, wxTE_RIGHT, valInt ); m_numericTextInt->SetToolTip("uses wxIntegerValidator to accept positive " "integers only"); m_numericTextDouble = new wxTextCtrl ( this, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, wxTE_RIGHT, wxMakeFloatingPointValidator ( 3, &g_data.m_doubleValue, wxNUM_VAL_THOUSANDS_SEPARATOR | wxNUM_VAL_NO_TRAILING_ZEROES ) ); m_numericTextDouble->SetToolTip("uses wxFloatingPointValidator with 3 decimals"); wxBoxSizer *numSizer = new wxBoxSizer( wxHORIZONTAL ); numSizer->Add( m_numericTextInt, 1, wxALL, 10 ); numSizer->Add( m_numericTextDouble, 1, wxALL, 10 ); // setup the main sizer // -------------------- wxBoxSizer *mainsizer = new wxBoxSizer( wxVERTICAL ); mainsizer->Add(flexgridsizer, 1, wxGROW | wxALL, 10); mainsizer->Add(new wxRadioBox((wxWindow*)this, VALIDATE_RADIO, wxT("Pick a color"), wxDefaultPosition, wxDefaultSize, 3, g_radiobox_choices, 1, wxRA_SPECIFY_ROWS, wxGenericValidator(&g_data.m_radiobox_choice)), 0, wxGROW | wxLEFT|wxBOTTOM|wxRIGHT, 10); mainsizer->Add( numSizer, 0, wxGROW | wxALL ); mainsizer->Add(btn, 0, wxGROW | wxALL, 10); SetSizer(mainsizer); mainsizer->SetSizeHints(this); // make the dialog a bit bigger than its minimal size: SetSize(GetBestSize()*1.5); }
void DeviceToolBar::FillHostDevices() { const std::vector<DeviceSourceMap> &inMaps = DeviceManager::Instance()->GetInputDeviceMaps(); const std::vector<DeviceSourceMap> &outMaps = DeviceManager::Instance()->GetOutputDeviceMaps(); //read what is in the prefs wxString host = gPrefs->Read(wxT("/AudioIO/Host"), wxT("")); size_t i; int foundHostIndex = -1; // if the host is not in the hosts combo then we rescanned. // set it to blank so we search for another host. if (mHost->FindString(host) == wxNOT_FOUND) host = wxT(""); for (i = 0; i < outMaps.size(); i++) { if (outMaps[i].hostString == host) { foundHostIndex = outMaps[i].hostIndex; break; } } if (foundHostIndex == -1) { for (i = 0; i < inMaps.size(); i++) { if (inMaps[i].hostString == host) { foundHostIndex = inMaps[i].hostIndex; break; } } } // If no host was found based on the prefs device host, load the first available one if (foundHostIndex == -1) { if (outMaps.size()) foundHostIndex = outMaps[0].hostIndex; else if (inMaps.size()) foundHostIndex = inMaps[0].hostIndex; } // Make sure in/out are clear in case no host was found mInput->Clear(); mOutput->Clear(); // If we still have no host it means no devices, in which case do nothing. if (foundHostIndex == -1) return; // Repopulate the Input/Output device list available to the user for (i = 0; i < inMaps.size(); i++) { if (foundHostIndex == inMaps[i].hostIndex) { mInput->Append(MakeDeviceSourceString(&inMaps[i])); if (host == wxT("")) { host = inMaps[i].hostString; gPrefs->Write(wxT("/AudioIO/Host"), host); mHost->SetStringSelection(host); } } } mInput->Enable(mInput->GetCount() ? true : false); mInput->InvalidateBestSize(); mInput->SetMaxSize(mInput->GetBestSize()); for (i = 0; i < outMaps.size(); i++) { if (foundHostIndex == outMaps[i].hostIndex) { mOutput->Append(MakeDeviceSourceString(&outMaps[i])); if (host == wxT("")) { host = outMaps[i].hostString; gPrefs->Write(wxT("/AudioIO/Host"), host); gPrefs->Flush(); mHost->SetStringSelection(host); } } } mOutput->Enable(mOutput->GetCount() ? true : false); mOutput->InvalidateBestSize(); mOutput->SetMaxSize(mOutput->GetBestSize()); // The setting of the Device is left up to OnChoice }