void CViewProjects::UpdateSelection() { CTaskItemGroup* pGroup = NULL; PROJECT* project = NULL; CMainDocument* pDoc = wxGetApp().GetDocument(); int i, n, row; bool wasSuspended=false, wasNoNewWork=false; bool enableUpdate = false; bool enableSuspendResume = false; bool enableNoNewTasks = false; bool enableReset = false; bool enableDetach = false; bool enableProperties = false; wxASSERT(pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); wxASSERT(m_pTaskPane); wxASSERT(m_pListPane); CBOINCBaseView::PreUpdateSelection(); // Update the tasks static box buttons // pGroup = m_TaskGroups[0]; n = m_pListPane->GetSelectedItemCount(); if (n > 0) { enableUpdate = true; enableSuspendResume = true; enableNoNewTasks = true; enableReset = true; enableDetach = true; } row = -1; for (i=0; i<n; i++) { // Step through all selected items row = m_pListPane->GetNextItem(row, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); if (row < 0) break; // Should never happen project = pDoc->project(m_iSortedIndexes[row]); if (!project) { m_pTaskPane->DisableTaskGroupTasks(pGroup); if(m_TaskGroups.size()>1) { m_pTaskPane->DisableTaskGroupTasks(m_TaskGroups[1]); } return; } if (i == 0) { wasSuspended = project->suspended_via_gui; if (project->suspended_via_gui) { m_pTaskPane->UpdateTask( pGroup->m_Tasks[BTN_SUSPEND], _("Resume"), _("Resume tasks for this project.") ); } else { m_pTaskPane->UpdateTask( pGroup->m_Tasks[BTN_SUSPEND], _("Suspend"), _("Suspend tasks for this project.") ); } } else { if (wasSuspended != project->suspended_via_gui) { // Disable Suspend / Resume button if the multiple selection // has a mix of suspended and not suspended projects enableSuspendResume = false; } } if (i == 0) { wasNoNewWork = project->dont_request_more_work; if (project->dont_request_more_work) { m_pTaskPane->UpdateTask( pGroup->m_Tasks[BTN_NOWORK], _("Allow new tasks"), _("Allow fetching new tasks for this project.") ); } else { m_pTaskPane->UpdateTask( pGroup->m_Tasks[BTN_NOWORK], _("No new tasks"), _("Don't fetch new tasks for this project.") ); } } else { if (wasNoNewWork != project->dont_request_more_work) { // Disable Allow New Work / No New Work button if the multiple // selection has a mix of Allow New Work and No New Work projects enableNoNewTasks = false; } } if (project->attached_via_acct_mgr) { enableDetach = false; } } if (n == 1) { enableProperties = true; UpdateWebsiteSelection(GRP_WEBSITES, project); if(m_TaskGroups.size()>1) { m_pTaskPane->EnableTaskGroupTasks(m_TaskGroups[1]); } } else { UpdateWebsiteSelection(GRP_WEBSITES, NULL); if(m_TaskGroups.size()>1) { m_pTaskPane->DisableTaskGroupTasks(m_TaskGroups[1]); } } // To minimize flicker, set each button only once to the final desired state pGroup->m_Tasks[BTN_UPDATE]->m_pButton->Enable(enableUpdate); pGroup->m_Tasks[BTN_SUSPEND]->m_pButton->Enable(enableSuspendResume); pGroup->m_Tasks[BTN_NOWORK]->m_pButton->Enable(enableNoNewTasks); pGroup->m_Tasks[BTN_RESET]->m_pButton->Enable(enableReset); pGroup->m_Tasks[BTN_DETACH]->m_pButton->Enable(enableDetach); pGroup->m_Tasks[BTN_PROPERTIES]->m_pButton->Enable(enableProperties); CBOINCBaseView::PostUpdateSelection(); }
wxObject *wxToolBarAddOnXmlHandler::DoCreateResource() { wxToolBar* toolbar=NULL; if (m_class == _T("tool")) { wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: tool not within a toolbar!")); wxSize bitmapSize = m_toolbar->GetToolBitmapSize(); if (GetPosition() != wxDefaultPosition) { m_toolbar->AddTool(GetID(), #if wxCHECK_VERSION(2, 9, 0) wxEmptyString, #endif GetCenteredBitmap(_T("bitmap"), wxART_TOOLBAR, bitmapSize), GetCenteredBitmap(_T("bitmap2"), wxART_TOOLBAR, bitmapSize), #if !wxCHECK_VERSION(2, 9, 0) GetBool(_T("toggle")), GetPosition().x, GetPosition().y, NULL, #else wxITEM_NORMAL, #endif GetText(_T("tooltip")), GetText(_T("longhelp"))); if (GetBool(_T("disabled"))) { m_toolbar->Realize(); m_toolbar->EnableTool(GetID(),false); } } else { wxItemKind kind = wxITEM_NORMAL; if (GetBool(_T("radio"))) kind = wxITEM_RADIO; if (GetBool(_T("toggle"))) { wxASSERT_MSG( kind == wxITEM_NORMAL, _("can't have both toggleable and radion button at once") ); kind = wxITEM_CHECK; } m_toolbar->AddTool(GetID(), GetText(_T("label")), GetCenteredBitmap(_T("bitmap"), wxART_TOOLBAR, bitmapSize), GetCenteredBitmap(_T("bitmap2"), wxART_TOOLBAR, bitmapSize), kind, GetText(_T("tooltip")), GetText(_T("longhelp"))); if (GetBool(_T("disabled"))) { m_toolbar->Realize(); m_toolbar->EnableTool(GetID(),false); } } return m_toolbar; // must return non-NULL } else if (m_class == _T("separator")) { wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: separator not within a toolbar!")); m_toolbar->AddSeparator(); return m_toolbar; // must return non-NULL } else /*<object class="wxToolBar">*/ { m_isAddon=(m_class == _T("wxToolBarAddOn")); if(m_isAddon) { // special case: Only add items to toolbar toolbar=(wxToolBar*)m_instance; // XRC_MAKE_INSTANCE(toolbar, wxToolBar); } else { int style = GetStyle(_T("style"), wxNO_BORDER | wxTB_HORIZONTAL); #ifdef __WXMSW__ if (!(style & wxNO_BORDER)) style |= wxNO_BORDER; #endif XRC_MAKE_INSTANCE(toolbar, wxToolBar) toolbar->Create(m_parentAsWindow, GetID(), GetPosition(), GetSize(), style, GetName()); wxSize bmpsize = GetSize(_T("bitmapsize")); if (!(bmpsize == wxDefaultSize)) toolbar->SetToolBitmapSize(bmpsize); wxSize margins = GetSize(_T("margins")); if (!(margins == wxDefaultSize)) toolbar->SetMargins(margins.x, margins.y); long packing = GetLong(_T("packing"), -1); if (packing != -1) toolbar->SetToolPacking(packing); long separation = GetLong(_T("separation"), -1); if (separation != -1) toolbar->SetToolSeparation(separation); prepend.Clear(); append.Clear(); } wxXmlNode *children_node = GetParamNode(_T("object")); if (!children_node) children_node = GetParamNode(_T("object_ref")); if (children_node == NULL) return toolbar; m_isInside = TRUE; m_toolbar = toolbar; wxXmlNode *n = children_node; while (n) { if ((n->GetType() == wxXML_ELEMENT_NODE) && (n->GetName() == _T("object") || n->GetName() == _T("object_ref"))) { wxObject *created = CreateResFromNode(n, toolbar, NULL); wxControl *control = wxDynamicCast(created, wxControl); if (!IsOfClass(n, _T("tool")) && !IsOfClass(n, _T("separator")) && control != NULL && control != toolbar) { //Manager::Get()->GetLogManager()->DebugLog(F(_T("control=%p, parent=%p, toolbar=%p"), control, control->GetParent(), toolbar)); toolbar->AddControl(control); } } n = n->GetNext(); } toolbar->Realize(); toolbar->SetCustomOverflowItems( prepend, append); m_isInside = FALSE; m_toolbar = NULL; if(!m_isAddon) { if (m_parentAsWindow && !GetBool(_T("dontattachtoframe"))) { wxFrame *parentFrame = wxDynamicCast(m_parent, wxFrame); if (parentFrame) parentFrame->SetToolBar(toolbar); } } m_isAddon=false; return toolbar; } }
int wxSystemSettingsNative::GetMetric( wxSystemMetric index, wxWindow* win ) { GdkWindow *window = NULL; if (win) window = gtk_widget_get_window(win->GetHandle()); switch (index) { case wxSYS_BORDER_X: case wxSYS_BORDER_Y: case wxSYS_EDGE_X: case wxSYS_EDGE_Y: case wxSYS_FRAMESIZE_X: case wxSYS_FRAMESIZE_Y: if (win) { wxTopLevelWindow *tlw = wxDynamicCast(win, wxTopLevelWindow); if (!tlw) return GetBorderWidth(index, win); else if (window) { // Get the frame extents from the windowmanager. // In most cases the top extent is the titlebar, so we use the bottom extent // for the heights. int right, bottom; if (wxGetFrameExtents(window, NULL, &right, NULL, &bottom)) { switch (index) { case wxSYS_BORDER_X: case wxSYS_EDGE_X: case wxSYS_FRAMESIZE_X: return right; // width of right extent default: return bottom; // height of bottom extent } } } } return -1; // no window specified case wxSYS_CURSOR_X: case wxSYS_CURSOR_Y: return gdk_display_get_default_cursor_size( window ? gdk_drawable_get_display(window) : gdk_display_get_default()); case wxSYS_DCLICK_X: case wxSYS_DCLICK_Y: gint dclick_distance; g_object_get(GetSettingsForWindowScreen(window), "gtk-double-click-distance", &dclick_distance, NULL); return dclick_distance * 2; case wxSYS_DCLICK_MSEC: gint dclick; g_object_get(GetSettingsForWindowScreen(window), "gtk-double-click-time", &dclick, NULL); return dclick; case wxSYS_DRAG_X: case wxSYS_DRAG_Y: gint drag_threshold; g_object_get(GetSettingsForWindowScreen(window), "gtk-dnd-drag-threshold", &drag_threshold, NULL); // The correct thing here would be to double the value // since that is what the API wants. But the values // are much bigger under GNOME than under Windows and // just seem to much in many cases to be useful. // drag_threshold *= 2; return drag_threshold; case wxSYS_ICON_X: case wxSYS_ICON_Y: return 32; case wxSYS_SCREEN_X: if (window) return gdk_screen_get_width(gdk_drawable_get_screen(window)); else return gdk_screen_width(); case wxSYS_SCREEN_Y: if (window) return gdk_screen_get_height(gdk_drawable_get_screen(window)); else return gdk_screen_height(); case wxSYS_HSCROLL_Y: case wxSYS_VSCROLL_X: return 15; case wxSYS_CAPTION_Y: if (!window) // No realized window specified, and no implementation for that case yet. return -1; wxASSERT_MSG( wxDynamicCast(win, wxTopLevelWindow), wxT("Asking for caption height of a non toplevel window") ); // Get the height of the top windowmanager border. // This is the titlebar in most cases. The titlebar might be elsewhere, and // we could check which is the thickest wm border to decide on which side the // titlebar is, but this might lead to interesting behaviours in used code. // Reconsider when we have a way to report to the user on which side it is. { int top; if (wxGetFrameExtents(window, NULL, NULL, &top, NULL)) { return top; // top frame extent } } // Try a default approach without a window pointer, if possible // ... return -1; case wxSYS_PENWINDOWS_PRESENT: // No MS Windows for Pen computing extension available in X11 based gtk+. return 0; default: return -1; // metric is unknown } }
bool CDlgEventLog::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style ) { ////@begin CDlgEventLog member initialisation m_iPreviousRowCount = 0; m_iTotalDocCount = 0; m_iPreviousTotalDocCount = 0; if (!s_bIsFiltered) { s_strFilteredProjectName.clear(); } m_iFilteredIndexes.Clear(); m_bProcessingRefreshEvent = false; m_bEventLogIsOpen = true; ////@end CDlgEventLog member initialisation CSkinAdvanced* pSkinAdvanced = wxGetApp().GetSkinManager()->GetAdvanced(); wxPoint oTempPoint; wxSize oTempSize; wxASSERT(pSkinAdvanced); wxASSERT(wxDynamicCast(pSkinAdvanced, CSkinAdvanced)); if ((pos == wxDefaultPosition) && (size == wxDefaultSize)) { // Get size and position from the previous configuration GetWindowDimensions( oTempPoint, oTempSize ); #ifdef __WXMSW__ // Windows does some crazy things if the initial position is a negative // value. oTempPoint.x = wxDefaultCoord; oTempPoint.y = wxDefaultCoord; #endif #ifdef __WXMAC__ // If the user has changed the arrangement of multiple // displays, make sure the window title bar is still on-screen. Rect titleRect = {oTempPoint.y, oTempPoint.x, oTempPoint.y+22, oTempPoint.x+oTempSize.x }; InsetRect(&titleRect, 5, 5); // Make sure at least a 5X5 piece visible RgnHandle displayRgn = NewRgn(); CopyRgn(GetGrayRgn(), displayRgn); // Region encompassing all displays Rect menuRect = ((**GetMainDevice())).gdRect; menuRect.bottom = GetMBarHeight() + menuRect.top; RgnHandle menuRgn = NewRgn(); RectRgn(menuRgn, &menuRect); // Region hidden by menu bar DiffRgn(displayRgn, menuRgn, displayRgn); // Subtract menu bar retion if (!RectInRgn(&titleRect, displayRgn)) oTempPoint.y = oTempPoint.x = 30; DisposeRgn(menuRgn); DisposeRgn(displayRgn); #endif // ! __WXMAC__ } else { oTempPoint = pos; oTempSize = size; } wxDialog::Create( parent, id, caption, oTempPoint, oTempSize, style ); SetExtraStyle(GetExtraStyle()|wxWS_EX_BLOCK_EVENTS); // Initialize Application Title wxString strCaption = caption; if (strCaption.IsEmpty()) { strCaption.Printf(_("%s - Event Log"), pSkinAdvanced->GetApplicationName().c_str()); } SetTitle(strCaption); // Initialize Application Icon wxIconBundle icons; icons.AddIcon(*pSkinAdvanced->GetApplicationIcon()); icons.AddIcon(*pSkinAdvanced->GetApplicationIcon32()); SetIcons(icons); CreateControls(); // Create List Pane Items m_pList->InsertColumn(COLUMN_PROJECT, _("Project"), wxLIST_FORMAT_LEFT, 109); m_pList->InsertColumn(COLUMN_TIME, _("Time"), wxLIST_FORMAT_LEFT, 130); m_pList->InsertColumn(COLUMN_MESSAGE, _("Message"), wxLIST_FORMAT_LEFT, 378); m_pMessageInfoAttr = new wxListItemAttr( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT), wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW), wxNullFont ); m_pMessageErrorAttr = new wxListItemAttr( *wxRED, wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW), wxNullFont ); #if EVENT_LOG_STRIPES m_pMessageInfoGrayAttr = new wxListItemAttr( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT), wxColour(240, 240, 240), wxNullFont ); m_pMessageErrorGrayAttr = new wxListItemAttr(*wxRED, wxColour(240, 240, 240), wxNullFont); #else m_pMessageInfoGrayAttr = new wxListItemAttr(*m_pMessageInfoAttr); m_pMessageErrorGrayAttr = new wxListItemAttr(*m_pMessageErrorAttr); #endif SetTextColor(); RestoreState(); return true; }
/*! * called from CMainDocument::HandleCompletedRPC() after wxEVT_RPC_FINISHED event */ void CDlgEventLog::OnRefresh() { bool isConnected; static bool was_connected = false; static wxString strLastMachineName = wxEmptyString; wxString strNewMachineName = wxEmptyString; CMainDocument* pDoc = wxGetApp().GetDocument(); wxASSERT(pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); if (!IsShown()) return; if (!m_bProcessingRefreshEvent) { m_bProcessingRefreshEvent = true; wxASSERT(m_pList); wxInt32 iRowCount = GetDocCount(); if (0 >= iRowCount) { m_pList->DeleteAllItems(); ResetMessageFiltering(); } else { // If connected computer changed, reset message filtering isConnected = wxGetApp().GetDocument()->IsConnected(); if (isConnected) { pDoc->GetConnectedComputerName(strNewMachineName); if (strLastMachineName != strNewMachineName) { strLastMachineName = strNewMachineName; was_connected = false; ResetMessageFiltering(); } } // If connection status changed, adjust color of messages display if (was_connected != isConnected) { was_connected = isConnected; SetTextColor(); // Force a complete update m_pList->DeleteAllItems(); m_pList->SetItemCount(iRowCount); m_iPreviousRowCount = 0; // Force scrolling to bottom } else { // Connection status didn't change if (m_iPreviousRowCount != iRowCount) { m_pList->SetItemCount(iRowCount); } } } if ((iRowCount > 1) && (EnsureLastItemVisible()) && (m_iPreviousRowCount != iRowCount)) { m_pList->EnsureVisible(iRowCount - 1); } if (m_iPreviousRowCount != iRowCount) { m_iPreviousRowCount = iRowCount; } UpdateButtons(); m_bProcessingRefreshEvent = false; } }
void wxMDIParentFrame::OnInternalIdle() { /* if a MDI child window has just been inserted it has to be brought to the top in idle time. we simply set the last notebook page active as new pages can only be appended at the end */ if (m_justInserted) { GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget); gtk_notebook_set_current_page(notebook, -1); /* need to set the menubar of the child */ wxMDIChildFrame *active_child_frame = GetActiveChild(); if (active_child_frame != NULL) { wxMenuBar *menu_bar = active_child_frame->m_menuBar; if (menu_bar) { menu_bar->Attach(active_child_frame); } } m_justInserted = false; return; } wxFrame::OnInternalIdle(); wxMDIChildFrame *active_child_frame = GetActiveChild(); bool visible_child_menu = false; wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst(); while (node) { wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame ); if ( child_frame ) { wxMenuBar *menu_bar = child_frame->m_menuBar; if ( menu_bar ) { if (child_frame == active_child_frame) { if (menu_bar->Show(true)) { // Attach() asserts if we call it for an already // attached menu bar so don't do it if we're already // associated with this frame (it would be nice to get // rid of this check and ensure that this doesn't // happen...) if ( menu_bar->GetFrame() != child_frame ) menu_bar->Attach( child_frame ); } visible_child_menu = true; } else { if (menu_bar->Show(false)) { menu_bar->Detach(); } } } } node = node->GetNext(); } /* show/hide parent menu bar as required */ if ((m_frameMenuBar) && (m_frameMenuBar->IsShown() == visible_child_menu)) { if (visible_child_menu) { m_frameMenuBar->Show( false ); m_frameMenuBar->Detach(); } else { m_frameMenuBar->Show( true ); m_frameMenuBar->Attach( this ); } } }
bool wxDisplayMSW::ChangeMode(const wxVideoMode& mode) { // prepare ChangeDisplaySettingsEx() parameters DEVMODE dm; DEVMODE *pDevMode; int flags; if ( mode == wxDefaultVideoMode ) { // reset the video mode to default pDevMode = NULL; flags = 0; } else // change to the given mode { wxCHECK_MSG( mode.GetWidth() && mode.GetHeight(), false, wxT("at least the width and height must be specified") ); wxZeroMemory(dm); dm.dmSize = sizeof(dm); dm.dmDriverExtra = 0; dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT; dm.dmPelsWidth = mode.GetWidth(); dm.dmPelsHeight = mode.GetHeight(); if ( mode.GetDepth() ) { dm.dmFields |= DM_BITSPERPEL; dm.dmBitsPerPel = mode.GetDepth(); } if ( mode.GetRefresh() ) { dm.dmFields |= DM_DISPLAYFREQUENCY; dm.dmDisplayFrequency = mode.GetRefresh(); } pDevMode = &dm; #ifdef __WXWINCE__ flags = 0; #else // !__WXWINCE__ flags = CDS_FULLSCREEN; #endif // __WXWINCE__/!__WXWINCE__ } // get pointer to the function dynamically // // we're only called from the main thread, so it's ok to use static // variable static ChangeDisplaySettingsEx_t pfnChangeDisplaySettingsEx = NULL; if ( !pfnChangeDisplaySettingsEx ) { wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET); if ( dllDisplay.IsLoaded() ) { wxDL_INIT_FUNC_AW(pfn, ChangeDisplaySettingsEx, dllDisplay); } //else: huh, no this DLL must always be present, what's going on?? #ifndef __WXWINCE__ if ( !pfnChangeDisplaySettingsEx ) { // we must be under Win95 and so there is no multiple monitors // support anyhow pfnChangeDisplaySettingsEx = ChangeDisplaySettingsExForWin95; } #endif // !__WXWINCE__ } // do change the mode switch ( pfnChangeDisplaySettingsEx ( GetName().t_str(), // display name pDevMode, // dev mode or NULL to reset NULL, // reserved flags, NULL // pointer to video parameters (not used) ) ) { case DISP_CHANGE_SUCCESSFUL: // ok { // If we have a top-level, full-screen frame, emulate // the DirectX behaviour and resize it. This makes this // API quite a bit easier to use. wxWindow *winTop = wxTheApp->GetTopWindow(); wxFrame *frameTop = wxDynamicCast(winTop, wxFrame); if (frameTop && frameTop->IsFullScreen()) { wxVideoMode current = GetCurrentMode(); frameTop->SetClientSize(current.GetWidth(), current.GetHeight()); } } return true; case DISP_CHANGE_BADMODE: // don't complain about this, this is the only "expected" error break; default: wxFAIL_MSG( wxT("unexpected ChangeDisplaySettingsEx() return value") ); } return false; }
wxObject * MaxSplitterWindowXmlHandler::DoCreateResource() { XRC_MAKE_INSTANCE(splitter, MaxSplitterWindow); splitter->Create(m_parentAsWindow, GetID(), GetPosition(), GetSize(), GetStyle(wxT("style"), wxSP_3D), GetName()); splitter->MaxBind(_wx_wxsplitterwindow_wxSplitterWindow__xrcNew(splitter)); SetupWindow(splitter); long sashpos = GetLong(wxT("sashpos"), 0); long minpanesize = GetLong(wxT("minsize"), -1); float gravity = GetFloat(wxT("gravity"), 0.0); if (minpanesize != -1) splitter->SetMinimumPaneSize(minpanesize); if (gravity != 0.0) splitter->SetSashGravity(gravity); wxWindow *win1 = NULL, *win2 = NULL; wxXmlNode *n = m_node->GetChildren(); while (n) { if ((n->GetType() == wxXML_ELEMENT_NODE) && (n->GetName() == wxT("object") || n->GetName() == wxT("object_ref"))) { wxObject *created = CreateResFromNode(n, splitter, NULL); wxWindow *win = wxDynamicCast(created, wxWindow); if (win1 == NULL) { win1 = win; } else { win2 = win; break; } } n = n->GetNext(); } if (win1 == NULL) wxLogError(wxT("wxSplitterWindow node must contain at least one window.")); bool horizontal = (GetParamValue(wxT("orientation")) != wxT("vertical")); if (win1 && win2) { if (horizontal) splitter->SplitHorizontally(win1, win2, sashpos); else splitter->SplitVertically(win1, win2, sashpos); } else { splitter->Initialize(win1); } return splitter; }
void CBOINCClientManager::ShutdownBOINCCore(bool ShuttingDownManager) { wxLogTrace(wxT("Function Start/End"), wxT("CBOINCClientManager::ShutdownBOINCCore - Function Begin")); CMainDocument* pDoc = wxGetApp().GetDocument(); wxInt32 iCount = 0; bool bClientQuit = false; wxString strConnectedCompter = wxEmptyString; wxString strPassword = wxEmptyString; double startTime = 0; wxDateTime zeroTime = wxDateTime((time_t)0); wxDateTime rpcCompletionTime = zeroTime; ASYNC_RPC_REQUEST request; int quit_result; wxASSERT(pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); #ifdef __WXMAC__ // Mac Manager shuts down client only if Manager started client if (!m_bBOINCStartedByManager) return; #endif #ifdef __WXMSW__ if (IsBOINCConfiguredAsDaemon()) { stop_daemon_via_daemonctrl(); bClientQuit = true; } else #endif { pDoc->GetConnectedComputerName(strConnectedCompter); if (!pDoc->IsComputerNameLocal(strConnectedCompter)) { RPC_CLIENT rpc; if (!rpc.init("localhost")) { pDoc->m_pNetworkConnection->GetLocalPassword(strPassword); rpc.authorize((const char*)strPassword.mb_str()); if (IsBOINCCoreRunning()) { rpc.quit(); for (iCount = 0; iCount <= 10; iCount++) { if (!bClientQuit && !IsBOINCCoreRunning()) { wxLogTrace(wxT("Function Status"), wxT("CBOINCClientManager::ShutdownBOINCCore - (localhost) Application Exit Detected")); bClientQuit = true; break; } wxLogTrace(wxT("Function Status"), wxT("CBOINCClientManager::ShutdownBOINCCore - (localhost) Application Exit NOT Detected, Sleeping...")); ::wxSleep(1); } } else { bClientQuit = true; } } rpc.close(); } else { if (IsBOINCCoreRunning()) { if (ShuttingDownManager) { // Set event filtering to allow RPC completion // events but not events which start new RPCs wxGetApp().SetEventFiltering(true); } quit_result = -1; request.clear(); request.which_rpc = RPC_QUIT; request.rpcType = RPC_TYPE_ASYNC_NO_REFRESH; request.completionTime = &rpcCompletionTime; request.resultPtr = &quit_result; pDoc->RequestRPC(request); // Issue an asynchronous Quit RPC // Client needs time to shut down project applications, so don't wait // for it to shut down; assume it will exit OK if Quit RPC succeeds. startTime = dtime(); while ((dtime() - startTime) < 10.0) { // Allow 10 seconds boinc_sleep(0.25); // Check 4 times per second wxSafeYield(NULL, true); // To allow handling RPC completion events if (!bClientQuit && (rpcCompletionTime != zeroTime)) { // If Quit RPC finished, check its returned value if (quit_result) { break; // Quit RPC returned an error } wxLogTrace(wxT("Function Status"), wxT("CBOINCClientManager::ShutdownBOINCCore - Application Exit Detected")); bClientQuit = true; break; } wxLogTrace(wxT("Function Status"), wxT("CBOINCClientManager::ShutdownBOINCCore - Application Exit NOT Detected, Sleeping...")); } } else { bClientQuit = true; } } } if (!bClientQuit) { KillClient(); } m_lBOINCCoreProcessId = 0; wxLogTrace(wxT("Function Start/End"), wxT("CBOINCClientManager::ShutdownBOINCCore - Function End")); }
bool wxStandardDialogLayoutAdapter::DoLayoutAdaptation(wxDialog* dialog) { if (dialog->GetSizer()) { #if wxUSE_BOOKCTRL wxBookCtrlBase* bookContentWindow = wxDynamicCast(dialog->GetContentWindow(), wxBookCtrlBase); if (bookContentWindow) { // If we have a book control, make all the pages (that use sizers) scrollable wxWindowList windows; for (size_t i = 0; i < bookContentWindow->GetPageCount(); i++) { wxWindow* page = bookContentWindow->GetPage(i); wxScrolledWindow* scrolledWindow = wxDynamicCast(page, wxScrolledWindow); if (scrolledWindow) windows.Append(scrolledWindow); else if (page->GetSizer()) { // Create a scrolled window and reparent scrolledWindow = CreateScrolledWindow(page); wxSizer* oldSizer = page->GetSizer(); wxSizer* newSizer = new wxBoxSizer(wxVERTICAL); newSizer->Add(scrolledWindow,1, wxEXPAND, 0); page->SetSizer(newSizer, false /* don't delete the old sizer */); scrolledWindow->SetSizer(oldSizer); ReparentControls(page, scrolledWindow); windows.Append(scrolledWindow); } } FitWithScrolling(dialog, windows); } else #endif // wxUSE_BOOKCTRL { #if wxUSE_BUTTON // If we have an arbitrary dialog, create a scrolling area for the main content, and a button sizer // for the main buttons. wxScrolledWindow* scrolledWindow = CreateScrolledWindow(dialog); int buttonSizerBorder = 0; // First try to find a wxStdDialogButtonSizer wxSizer* buttonSizer = FindButtonSizer(true /* find std button sizer */, dialog, dialog->GetSizer(), buttonSizerBorder); // Next try to find a wxBoxSizer containing the controls if (!buttonSizer && dialog->GetLayoutAdaptationLevel() > wxDIALOG_ADAPTATION_STANDARD_SIZER) buttonSizer = FindButtonSizer(false /* find ordinary sizer */, dialog, dialog->GetSizer(), buttonSizerBorder); // If we still don't have a button sizer, collect any 'loose' buttons in the layout if (!buttonSizer && dialog->GetLayoutAdaptationLevel() > wxDIALOG_ADAPTATION_ANY_SIZER) { int count = 0; wxStdDialogButtonSizer* stdButtonSizer = new wxStdDialogButtonSizer; buttonSizer = stdButtonSizer; FindLooseButtons(dialog, stdButtonSizer, dialog->GetSizer(), count); if (count > 0) stdButtonSizer->Realize(); else { wxDELETE(buttonSizer); } } if (buttonSizerBorder == 0) buttonSizerBorder = 5; ReparentControls(dialog, scrolledWindow, buttonSizer); wxBoxSizer* newTopSizer = new wxBoxSizer(wxVERTICAL); wxSizer* oldSizer = dialog->GetSizer(); dialog->SetSizer(newTopSizer, false /* don't delete old sizer */); newTopSizer->Add(scrolledWindow, 1, wxEXPAND|wxALL, 0); if (buttonSizer) newTopSizer->Add(buttonSizer, 0, wxEXPAND|wxALL, buttonSizerBorder); scrolledWindow->SetSizer(oldSizer); FitWithScrolling(dialog, scrolledWindow); #endif // wxUSE_BUTTON } } dialog->SetLayoutAdaptationDone(true); return true; }
wxObject *wxStatusBarXmlHandler::DoCreateResource() { XRC_MAKE_INSTANCE(statbar, wxStatusBar) statbar->Create(m_parentAsWindow, GetID(), GetStyle(), GetName()); int fields = GetLong(wxT("fields"), 1); wxString widths = GetParamValue(wxT("widths")); wxString styles = GetParamValue(wxT("styles")); if (fields > 1 && !widths.IsEmpty()) { int *width = new int[fields]; for (int i = 0; i < fields; ++i) { width[i] = wxAtoi(widths.BeforeFirst(wxT(','))); if(widths.Find(wxT(','))) widths.Remove(0, widths.Find(wxT(',')) + 1); } statbar->SetFieldsCount(fields, width); delete[] width; } else statbar->SetFieldsCount(fields); if (!styles.empty()) { int *style = new int[fields]; for (int i = 0; i < fields; ++i) { style[i] = wxSB_NORMAL; wxString first = styles.BeforeFirst(wxT(',')); if (first == wxT("wxSB_NORMAL")) style[i] = wxSB_NORMAL; else if (first == wxT("wxSB_FLAT")) style[i] = wxSB_FLAT; else if (first == wxT("wxSB_RAISED")) style[i] = wxSB_RAISED; else if (!first.empty()) { ReportParamError ( "styles", wxString::Format ( "unknown status bar field style \"%s\"", first ) ); } if(styles.Find(wxT(','))) styles.Remove(0, styles.Find(wxT(',')) + 1); } statbar->SetStatusStyles(fields, style); delete [] style; } CreateChildren(statbar); if (m_parentAsWindow) { wxFrame *parentFrame = wxDynamicCast(m_parent, wxFrame); if (parentFrame) parentFrame->SetStatusBar(statbar); } return statbar; }
wxObject *wxChoicebookXmlHandler::DoCreateResource() { if (m_class == wxT("choicebookpage")) { wxXmlNode *n = GetParamNode(wxT("object")); if ( !n ) n = GetParamNode(wxT("object_ref")); if (n) { bool old_ins = m_isInside; m_isInside = false; wxObject *item = CreateResFromNode(n, m_choicebook, NULL); m_isInside = old_ins; wxWindow *wnd = wxDynamicCast(item, wxWindow); if (wnd) { m_choicebook->AddPage(wnd, GetText(wxT("label")), GetBool(wxT("selected"))); if ( HasParam(wxT("bitmap")) ) { wxBitmap bmp = GetBitmap(wxT("bitmap"), wxART_OTHER); wxImageList *imgList = m_choicebook->GetImageList(); if ( imgList == NULL ) { imgList = new wxImageList( bmp.GetWidth(), bmp.GetHeight() ); m_choicebook->AssignImageList( imgList ); } int imgIndex = imgList->Add(bmp); m_choicebook->SetPageImage(m_choicebook->GetPageCount()-1, imgIndex ); } else if ( HasParam(wxT("image")) ) { if ( m_choicebook->GetImageList() ) { m_choicebook->SetPageImage(m_choicebook->GetPageCount()-1, GetLong(wxT("image")) ); } else // image without image list? { ReportError(n, "image can only be used in conjunction " "with imagelist"); } } } else { ReportError(n, "choicebookpage child must be a window"); } return wnd; } else { ReportError("choicebookpage must have a window child"); return NULL; } } else { XRC_MAKE_INSTANCE(nb, wxChoicebook) nb->Create(m_parentAsWindow, GetID(), GetPosition(), GetSize(), GetStyle(wxT("style")), GetName()); wxImageList *imagelist = GetImageList(); if ( imagelist ) nb->AssignImageList(imagelist); wxChoicebook *old_par = m_choicebook; m_choicebook = nb; bool old_ins = m_isInside; m_isInside = true; CreateChildren(m_choicebook, true/*only this handler*/); m_isInside = old_ins; m_choicebook = old_par; return nb; } }
virtual void _OnPaintPanel( wxPaintEvent& event ) { wxClientDC dc(wxDynamicCast(event.GetEventObject(), wxWindow)); RedrawPanel(&dc); }
static gboolean expose_event(GtkWidget* widget, GdkEventExpose* gdk_event, wxMiniFrame* win) #endif { #ifdef __WXGTK3__ if (!gtk_cairo_should_draw_window(cr, gtk_widget_get_window(widget))) return false; GtkStyleContext* sc = gtk_widget_get_style_context(widget); gtk_style_context_save(sc); gtk_style_context_add_class(sc, GTK_STYLE_CLASS_BUTTON); gtk_render_frame(sc, cr, 0, 0, win->m_width, win->m_height); gtk_style_context_restore(sc); wxGTKCairoDC dc(cr); #else if (gdk_event->count > 0 || gdk_event->window != gtk_widget_get_window(widget)) { return false; } gtk_paint_shadow (gtk_widget_get_style(widget), gtk_widget_get_window(widget), GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, NULL, NULL, // FIXME: No clipping? 0, 0, win->m_width, win->m_height); wxClientDC dc(win); wxDCImpl *impl = dc.GetImpl(); wxClientDCImpl *gtk_impl = wxDynamicCast( impl, wxClientDCImpl ); gtk_impl->m_gdkwindow = gtk_widget_get_window(widget); // Hack alert #endif int style = win->GetWindowStyle(); if (style & wxRESIZE_BORDER) { dc.SetBrush( *wxGREY_BRUSH ); dc.SetPen( *wxTRANSPARENT_PEN ); dc.DrawRectangle( win->m_width - 14, win->m_height-14, 14, 14 ); } if (win->m_miniTitle && !win->GetTitle().empty()) { dc.SetFont( *wxSMALL_FONT ); wxBrush brush(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT)); dc.SetBrush( brush ); dc.SetPen( *wxTRANSPARENT_PEN ); dc.DrawRectangle( win->m_miniEdge-1, win->m_miniEdge-1, win->m_width - (2*(win->m_miniEdge-1)), 15 ); const wxColour textColor = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT); dc.SetTextForeground(textColor); dc.DrawText( win->GetTitle(), 6, 4 ); if (style & wxCLOSE_BOX) { dc.SetTextBackground(textColor); dc.DrawBitmap( win->m_closeButton, win->m_width-18, 3, true ); } } return false; }
void Grid::OnKeyDown(wxKeyEvent &event) { switch (event.GetKeyCode()) { case WXK_LEFT: case WXK_RIGHT: { int rows = GetNumberRows(); int cols = GetNumberCols(); int crow = GetGridCursorRow(); int ccol = GetGridCursorCol(); if (event.GetKeyCode() == WXK_LEFT) { if (crow == 0 && ccol == 0) { // do nothing } else if (ccol == 0) { SetGridCursor(crow - 1, cols - 1); } else { SetGridCursor(crow, ccol - 1); } } else { if (crow == rows - 1 && ccol == cols - 1) { // do nothing } else if (ccol == cols - 1) { SetGridCursor(crow + 1, 0); } else { SetGridCursor(crow, ccol + 1); } } #if wxUSE_ACCESSIBILITY // Make sure the NEW cell is made available to the screen reader mAx->SetCurrentCell(GetGridCursorRow(), GetGridCursorCol()); #endif } break; case WXK_TAB: { int rows = GetNumberRows(); int cols = GetNumberCols(); int crow = GetGridCursorRow(); int ccol = GetGridCursorCol(); if (event.ControlDown()) { int flags = wxNavigationKeyEvent::FromTab | ( event.ShiftDown() ? wxNavigationKeyEvent::IsBackward : wxNavigationKeyEvent::IsForward ); Navigate(flags); return; } else if (event.ShiftDown()) { if (crow == 0 && ccol == 0) { Navigate(wxNavigationKeyEvent::FromTab | wxNavigationKeyEvent::IsBackward); return; } else if (ccol == 0) { SetGridCursor(crow - 1, cols - 1); } else { SetGridCursor(crow, ccol - 1); } } else { if (crow == rows - 1 && ccol == cols - 1) { Navigate(wxNavigationKeyEvent::FromTab | wxNavigationKeyEvent::IsForward); return; } else if (ccol == cols - 1) { SetGridCursor(crow + 1, 0); } else { SetGridCursor(crow, ccol + 1); } } MakeCellVisible(GetGridCursorRow(), GetGridCursorCol()); #if wxUSE_ACCESSIBILITY // Make sure the NEW cell is made available to the screen reader mAx->SetCurrentCell(GetGridCursorRow(), GetGridCursorCol()); #endif } break; case WXK_RETURN: case WXK_NUMPAD_ENTER: { if (!IsCellEditControlShown()) { wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow); wxWindow *def = tlw->GetDefaultItem(); if (def && def->IsEnabled()) { wxCommandEvent cevent(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId()); GetParent()->GetEventHandler()->ProcessEvent(cevent); } } else { wxGrid::OnKeyDown(event); // This looks strange, but what it does is selects the cell when // enter is pressed after editing. Without it, Jaws and Window-Eyes // do not speak the NEW cell contents (the one below the edited one). SetGridCursor(GetGridCursorRow(), GetGridCursorCol()); } break; } default: wxGrid::OnKeyDown(event); break; } }
void wxTextCtrl::OnChar(wxKeyEvent& event) { int key = event.GetKeyCode() ; bool eat_key = false ; long from, to; if ( !IsEditable() && !event.IsKeyInCategory(WXK_CATEGORY_ARROW | WXK_CATEGORY_TAB) && !( (key == WXK_RETURN || key == WXK_NUMPAD_ENTER) && ( (m_windowStyle & wxTE_PROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) ) // && key != WXK_PAGEUP && key != WXK_PAGEDOWN && key != WXK_HOME && key != WXK_END ) { // eat it return ; } if ( !GetTextPeer()->CanClipMaxLength() ) { // Check if we have reached the max # of chars (if it is set), but still // allow navigation and deletion GetSelection( &from, &to ); if ( !IsMultiLine() && m_maxLength && GetValue().length() >= m_maxLength && !event.IsKeyInCategory(WXK_CATEGORY_ARROW | WXK_CATEGORY_TAB | WXK_CATEGORY_CUT) && !( (key == WXK_RETURN || key == WXK_NUMPAD_ENTER) && (m_windowStyle & wxTE_PROCESS_ENTER) ) && from == to ) { // eat it, we don't want to add more than allowed # of characters // TODO: generate EVT_TEXT_MAXLEN() return; } } // assume that any key not processed yet is going to modify the control m_dirty = true; switch ( key ) { case WXK_RETURN: case WXK_NUMPAD_ENTER: if (m_windowStyle & wxTE_PROCESS_ENTER) { wxCommandEvent event(wxEVT_TEXT_ENTER, m_windowId); event.SetEventObject( this ); event.SetString( GetValue() ); if ( HandleWindowEvent(event) ) return; } if ( !(m_windowStyle & wxTE_MULTILINE) ) { wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow); if ( tlw && tlw->GetDefaultItem() ) { wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton); if ( def && def->IsEnabled() ) { wxCommandEvent event(wxEVT_BUTTON, def->GetId() ); event.SetEventObject(def); def->Command(event); return ; } } // this will make wxWidgets eat the ENTER key so that // we actually prevent line wrapping in a single line text control eat_key = true; } break; case WXK_TAB: if ( !(m_windowStyle & wxTE_PROCESS_TAB)) { int flags = 0; if (!event.ShiftDown()) flags |= wxNavigationKeyEvent::IsForward ; if (event.ControlDown()) flags |= wxNavigationKeyEvent::WinChange ; Navigate(flags); return; } else { // This is necessary (don't know why); // otherwise the tab will not be inserted. WriteText(wxT("\t")); eat_key = true; } break; default: break; } if (!eat_key) { // perform keystroke handling event.Skip(true) ; } // osx_cocoa sends its event upon insertText }
void OnCreated( wxObject* wxobject, wxWindow* /*wxparent*/ ) { // For storing objects whose postion needs to be determined std::vector< std::pair< wxObject*, wxGBSizerItem* > > newObjects; wxGBPosition lastPosition( 0, 0 ); // Get sizer wxGridBagSizer* sizer = wxDynamicCast( wxobject, wxGridBagSizer ); if ( NULL == sizer ) { wxLogError( wxT("This should be a wxGridBagSizer!") ); return; } // Add the children IManager* manager = GetManager(); size_t count = manager->GetChildCount( wxobject ); if ( 0 == count ) { // wxGridBagSizer gets upset sometimes without children sizer->Add( 0, 0, wxGBPosition( 0, 0 ) ); return; } for ( size_t i = 0; i < count; ++i ) { // Should be a GBSizerItem wxObject* wxsizerItem = manager->GetChild( wxobject, i ); IObject* isizerItem = manager->GetIObject( wxsizerItem ); // Get the location of the item wxGBSpan span( isizerItem->GetPropertyAsInteger( _("rowspan") ), isizerItem->GetPropertyAsInteger( _("colspan") ) ); int column = isizerItem->GetPropertyAsInteger( _("column") ); if ( column < 0 ) { // Needs to be auto positioned after the other children are added wxGBSizerItem* item = GetGBSizerItem( isizerItem, lastPosition, span, manager->GetChild( wxsizerItem, 0 ) ); if ( item != NULL ) { newObjects.push_back( std::pair< wxObject*, wxGBSizerItem* >( wxsizerItem, item ) ); } continue; } wxGBPosition position( isizerItem->GetPropertyAsInteger( _("row") ), column ); // Check for intersection if ( sizer->CheckForIntersection( position, span ) ) { continue; } lastPosition = position; // Add the child to the sizer wxGBSizerItem* item = GetGBSizerItem( isizerItem, position, span, manager->GetChild( wxsizerItem, 0 ) ); if ( item != NULL ) { sizer->Add( item ); } } std::vector< std::pair< wxObject*, wxGBSizerItem* > >::iterator it; for ( it = newObjects.begin(); it != newObjects.end(); ++it ) { wxGBPosition position = it->second->GetPos(); wxGBSpan span = it->second->GetSpan(); int column = position.GetCol(); while ( sizer->CheckForIntersection( position, span ) ) { column++; position.SetCol( column ); } it->second->SetPos( position ); sizer->Add( it->second ); GetManager()->ModifyProperty( it->first, _("row"), wxString::Format( wxT("%i"), position.GetRow() ), false ); GetManager()->ModifyProperty( it->first, _("column"), wxString::Format( wxT("%i"), column ), false ); } }
bool wxRibbonToolBar::Realize() { if(m_art == NULL) return false; // Calculate the size of each group and the position/size of each tool wxMemoryDC temp_dc; size_t group_count = m_groups.GetCount(); size_t g, t; for(g = 0; g < group_count; ++g) { wxRibbonToolBarToolBase* prev = NULL; wxRibbonToolBarToolGroup* group = m_groups.Item(g); size_t tool_count = group->tools.GetCount(); int tallest = 0; for(t = 0; t < tool_count; ++t) { wxRibbonToolBarToolBase* tool = group->tools.Item(t); tool->size = m_art->GetToolSize(temp_dc, this, tool->bitmap.GetSize(), tool->kind, t == 0, t == (tool_count - 1), &tool->dropdown); if(t == 0) tool->state |= wxRIBBON_TOOLBAR_TOOL_FIRST; if(t == tool_count - 1) tool->state |= wxRIBBON_TOOLBAR_TOOL_LAST; if(tool->size.GetHeight() > tallest) tallest = tool->size.GetHeight(); if(prev) { tool->position = prev->position; tool->position.x += prev->size.x; } else { tool->position = wxPoint(0, 0); } prev = tool; } if(tool_count == 0) group->size = wxSize(0, 0); else { group->size = wxSize(prev->position.x + prev->size.x, tallest); for(t = 0; t < tool_count; ++t) group->tools.Item(t)->size.SetHeight(tallest); } } // Calculate the minimum size for each possible number of rows int nrows, r; int sep = m_art->GetMetric(wxRIBBON_ART_TOOL_GROUP_SEPARATION_SIZE); int smallest_area = INT_MAX; wxSize* row_sizes = new wxSize[m_nrows_max]; wxOrientation major_axis = m_art->GetFlags() & wxRIBBON_BAR_FLOW_VERTICAL ? wxVERTICAL : wxHORIZONTAL; SetMinSize(wxSize(0, 0)); wxSize minSize(INT_MAX, INT_MAX); // See if we're sizing flexibly (i.e. wrapping), and set min size differently bool sizingFlexibly = false; wxRibbonPanel* panel = wxDynamicCast(GetParent(), wxRibbonPanel); if (panel && (panel->GetFlags() & wxRIBBON_PANEL_FLEXIBLE)) sizingFlexibly = true; // Without this, there will be redundant horizontal space because SetMinSize will // use the smallest possible height (and therefore largest width). if (sizingFlexibly) major_axis = wxHORIZONTAL; for(nrows = m_nrows_min; nrows <= m_nrows_max; ++nrows) { for(r = 0; r < nrows; ++r) row_sizes[r] = wxSize(0, 0); for(g = 0; g < group_count; ++g) { wxRibbonToolBarToolGroup* group = m_groups.Item(g); int shortest_row = 0; for(r = 1; r < nrows; ++r) { if(row_sizes[r].GetWidth() < row_sizes[shortest_row].GetWidth()) shortest_row = r; } row_sizes[shortest_row].x += group->size.x + sep; if(group->size.y > row_sizes[shortest_row].y) row_sizes[shortest_row].y = group->size.y; } wxSize size(0, 0); for(r = 0; r < nrows; ++r) { if(row_sizes[r].GetWidth() != 0) row_sizes[r].DecBy(sep, 0); if(row_sizes[r].GetWidth() > size.GetWidth()) size.SetWidth(row_sizes[r].GetWidth()); size.IncBy(0, row_sizes[r].y); } m_sizes[nrows - m_nrows_min] = size; if(GetSizeInOrientation(size, major_axis) < smallest_area) { smallest_area = GetSizeInOrientation(size, major_axis); SetMinSize(size); } if (sizingFlexibly) { if (size.x < minSize.x) minSize.x = size.x; if (size.y < minSize.y) minSize.y = size.y; } } if (sizingFlexibly) { // Give it the min size in either direction regardless of row, // so that we're able to vary the size of the panel according to // the space the toolbar takes up. SetMinSize(minSize); } delete[] row_sizes; // Position the groups wxSizeEvent dummy_event(GetSize()); OnSize(dummy_event); return true; }
bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate, const wxString& title, const wxPoint& pos, const wxSize& size) { // static cast is valid as we're only ever called for dialogs wxWindow * const parent = static_cast<wxDialog *>(this)->GetParentForModalDialog(); m_hWnd = (WXHWND)::CreateDialogIndirect ( wxGetInstance(), (DLGTEMPLATE*)dlgTemplate, parent ? GetHwndOf(parent) : NULL, (DLGPROC)wxDlgProc ); if ( !m_hWnd ) { wxFAIL_MSG(wxT("Failed to create dialog. Incorrect DLGTEMPLATE?")); wxLogSysError(wxT("Can't create dialog using memory template")); return false; } // For some reason, the system menu is activated when we use the // WS_EX_CONTEXTHELP style, so let's set a reasonable icon if ( HasExtraStyle(wxWS_EX_CONTEXTHELP) ) { wxFrame *winTop = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame); if ( winTop ) { wxIcon icon = winTop->GetIcon(); if ( icon.IsOk() ) { ::SendMessage(GetHwnd(), WM_SETICON, (WPARAM)TRUE, (LPARAM)GetHiconOf(icon)); } } } if ( !title.empty() ) { ::SetWindowText(GetHwnd(), title.t_str()); } SubclassWin(m_hWnd); // move the dialog to its initial position without forcing repainting int x, y, w, h; (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h); if ( x == (int)CW_USEDEFAULT ) { // Let the system position the window, just set its size. ::SetWindowPos(GetHwnd(), 0, 0, 0, w, h, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE); } else // Move the window to the desired location and set its size too. { if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) ) { wxLogLastError(wxT("MoveWindow")); } } return true; }
void wxRibbonToolBar::OnSize(wxSizeEvent& evt) { if(m_art == NULL) return; // Choose row count with largest possible area wxSize size = evt.GetSize(); int row_count = m_nrows_max; wxOrientation major_axis = m_art->GetFlags() & wxRIBBON_BAR_FLOW_VERTICAL ? wxVERTICAL : wxHORIZONTAL; // See if we're sizing flexibly, and set min size differently bool sizingFlexibly = false; wxRibbonPanel* panel = wxDynamicCast(GetParent(), wxRibbonPanel); if (panel && (panel->GetFlags() & wxRIBBON_PANEL_FLEXIBLE)) sizingFlexibly = true; // Without this, there will be redundant horizontal space because SetMinSize will // use the smallest possible height (and therefore largest width). if (sizingFlexibly) major_axis = wxHORIZONTAL; wxSize bestSize = m_sizes[0]; if(m_nrows_max != m_nrows_min) { int area = 0; for(int i = 0; i <= m_nrows_max - m_nrows_min; ++i) { if(m_sizes[i].x <= size.x && m_sizes[i].y <= size.y && GetSizeInOrientation(m_sizes[i], major_axis) > area) { area = GetSizeInOrientation(m_sizes[i], major_axis); row_count = m_nrows_min + i; bestSize = m_sizes[i]; } } } // Assign groups to rows and calculate row widths wxSize* row_sizes = new wxSize[row_count]; int sep = m_art->GetMetric(wxRIBBON_ART_TOOL_GROUP_SEPARATION_SIZE); int r; for(r = 0; r < row_count; ++r) row_sizes[r] = wxSize(0, 0); size_t g; size_t group_count = m_groups.GetCount(); for(g = 0; g < group_count; ++g) { wxRibbonToolBarToolGroup* group = m_groups.Item(g); int shortest_row = 0; for(r = 1; r < row_count; ++r) { if(row_sizes[r].GetWidth() < row_sizes[shortest_row].GetWidth()) shortest_row = r; } group->position = wxPoint(row_sizes[shortest_row].x, shortest_row); row_sizes[shortest_row].x += group->size.x + sep; if(group->size.y > row_sizes[shortest_row].y) row_sizes[shortest_row].y = group->size.y; } // Calculate row positions int total_height = 0; for(r = 0; r < row_count; ++r) total_height += row_sizes[r].GetHeight(); int rowsep = (size.GetHeight() - total_height) / (row_count + 1); int* rowypos = new int[row_count]; rowypos[0] = rowsep; for(r = 1; r < row_count; ++r) { rowypos[r] = rowypos[r - 1] + row_sizes[r - 1].GetHeight() + rowsep; } // Set group y positions for(g = 0; g < group_count; ++g) { wxRibbonToolBarToolGroup* group = m_groups.Item(g); group->position.y = rowypos[group->position.y]; } delete[] rowypos; delete[] row_sizes; }
void wxListBox::OnChar(wxKeyEvent& event) { // todo trigger proper events here event.Skip() ; return ; if ( event.GetKeyCode() == WXK_RETURN || event.GetKeyCode() == WXK_NUMPAD_ENTER) { wxWindow* parent = GetParent() ; while( parent && !parent->IsTopLevel() && parent->GetDefaultItem() == NULL ) parent = parent->GetParent() ; if ( parent && parent->GetDefaultItem() ) { wxButton *def = wxDynamicCast(parent->GetDefaultItem(), wxButton); if ( def && def->IsEnabled() ) { wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() ); event.SetEventObject(def); def->Command(event); return ; } } event.Skip() ; } /* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */ else if (event.GetKeyCode() == WXK_ESCAPE || (event.GetKeyCode() == '.' && event.MetaDown() ) ) { // FIXME: look in ancestors, not just parent. wxWindow* win = GetParent()->FindWindow( wxID_CANCEL ) ; if (win) { wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL); new_event.SetEventObject( win ); win->GetEventHandler()->ProcessEvent( new_event ); } } else if ( event.GetKeyCode() == WXK_TAB ) { wxNavigationKeyEvent new_event; new_event.SetEventObject( this ); new_event.SetDirection( !event.ShiftDown() ); /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */ new_event.SetWindowChange( event.ControlDown() ); new_event.SetCurrentFocus( this ); if ( !GetEventHandler()->ProcessEvent( new_event ) ) event.Skip() ; } else if ( event.GetKeyCode() == WXK_DOWN || event.GetKeyCode() == WXK_UP ) { // perform the default key handling first wxControl::OnKeyDown( event ) ; wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, m_windowId); event.SetEventObject( this ); wxArrayInt aSelections; int n, count = GetSelections(aSelections); if ( count > 0 ) { n = aSelections[0]; if ( HasClientObjectData() ) event.SetClientObject( GetClientObject(n) ); else if ( HasClientUntypedData() ) event.SetClientData( GetClientData(n) ); event.SetString( GetString(n) ); } else { n = -1; } event.SetInt(n); GetEventHandler()->ProcessEvent(event); } else { if ( event.GetTimestamp() > m_lastTypeIn + 60 ) { m_typeIn = wxEmptyString ; } m_lastTypeIn = event.GetTimestamp() ; m_typeIn += (char) event.GetKeyCode() ; int line = FindString(wxT("*")+m_typeIn+wxT("*")) ; if ( line >= 0 ) { if ( GetSelection() != line ) { SetSelection(line) ; wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, m_windowId); event.SetEventObject( this ); if ( HasClientObjectData() ) event.SetClientObject( GetClientObject( line ) ); else if ( HasClientUntypedData() ) event.SetClientData( GetClientData(line) ); event.SetString( GetString(line) ); event.SetInt(line); GetEventHandler()->ProcessEvent(event); } } } }
bool wxSetFocusToChild(wxWindow *win, wxWindow **childLastFocused) { wxCHECK_MSG( win, false, wxT("wxSetFocusToChild(): invalid window") ); // wxCHECK_MSG( childLastFocused, false, // wxT("wxSetFocusToChild(): NULL child poonter") ); if ( childLastFocused && *childLastFocused ) { // It might happen that the window got reparented if ( (*childLastFocused)->GetParent() == win ) { wxLogTrace(TRACE_FOCUS, wxT("SetFocusToChild() => last child (0x%p)."), (*childLastFocused)->GetHandle()); // not SetFocusFromKbd(): we're restoring focus back to the old // window and not setting it as the result of a kbd action (*childLastFocused)->SetFocus(); return true; } else { // it doesn't count as such any more *childLastFocused = NULL; } } // set the focus to the first child who wants it wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); while ( node ) { wxWindow *child = node->GetData(); node = node->GetNext(); // skip special windows: if ( !win->IsClientAreaChild(child) ) continue; if ( child->CanAcceptFocusFromKeyboard() && !child->IsTopLevel() ) { #if defined(__WXMSW__) && wxUSE_RADIOBTN // If a radiobutton is the first focusable child, search for the // selected radiobutton in the same group wxRadioButton* btn = wxDynamicCast(child, wxRadioButton); if (btn) { wxRadioButton* selected = wxGetSelectedButtonInGroup(btn); if (selected) child = selected; } #endif // __WXMSW__ wxLogTrace(TRACE_FOCUS, wxT("SetFocusToChild() => first child (0x%p)."), child->GetHandle()); if (childLastFocused) *childLastFocused = child; child->SetFocusFromKbd(); return true; } } return false; }
void CDlgEventLog::CreateControls() { CSkinAdvanced* pSkinAdvanced = wxGetApp().GetSkinManager()->GetAdvanced(); wxASSERT(pSkinAdvanced); wxASSERT(wxDynamicCast(pSkinAdvanced, CSkinAdvanced)); wxFlexGridSizer* itemFlexGridSizer2 = new wxFlexGridSizer(2, 1, 0, 0); itemFlexGridSizer2->AddGrowableRow(0); itemFlexGridSizer2->AddGrowableCol(0); SetSizer(itemFlexGridSizer2); m_pList = new CDlgEventLogListCtrl(this, ID_SIMPLE_MESSAGESVIEW, EVENT_LOG_DEFAULT_LIST_MULTI_SEL_FLAGS); itemFlexGridSizer2->Add(m_pList, 0, wxGROW|wxALL, 5); wxBoxSizer* itemBoxSizer4 = new wxBoxSizer(wxHORIZONTAL); itemFlexGridSizer2->Add(itemBoxSizer4, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 12); m_pFilterButton = new wxButton(this, ID_TASK_MESSAGES_FILTERBYPROJECT, _("&Show only this project"), wxDefaultPosition, wxDefaultSize); itemBoxSizer4->Add(m_pFilterButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); #ifdef wxUSE_CLIPBOARD wxButton* itemButton1 = new wxButton(this, ID_COPYAll, _("Copy &All"), wxDefaultPosition, wxDefaultSize ); itemButton1->SetHelpText( _("Copy all the messages to the clipboard.") ); #if wxUSE_TOOLTIPS itemButton1->SetToolTip( _("Copy all the messages to the clipboard.") ); #endif itemBoxSizer4->Add(itemButton1, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); m_pCopySelectedButton = new wxButton(this, ID_COPYSELECTED, _("Copy &Selected"), wxDefaultPosition, wxDefaultSize ); m_pCopySelectedButton->SetHelpText( #ifdef __WXMAC__ _("Copy the selected messages to the clipboard. You can select multiple messages by holding down the shift or command key while clicking on messages.") #else _("Copy the selected messages to the clipboard. You can select multiple messages by holding down the shift or control key while clicking on messages.") #endif ); #if wxUSE_TOOLTIPS m_pCopySelectedButton->SetToolTip( #ifdef __WXMAC__ _("Copy the selected messages to the clipboard. You can select multiple messages by holding down the shift or command key while clicking on messages.") #else _("Copy the selected messages to the clipboard. You can select multiple messages by holding down the shift or control key while clicking on messages.") #endif ); #endif itemBoxSizer4->Add(m_pCopySelectedButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); #endif wxButton* itemButton44 = new wxButton(this, wxID_OK, _("&Close"), wxDefaultPosition, wxDefaultSize); itemBoxSizer4->Add(itemButton44, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); #ifndef __WXMAC__ wxContextHelpButton* itemButton45 = new wxContextHelpButton(this); itemBoxSizer4->Add(itemButton45, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); #else wxButton* itemButton45 = new wxButton(this, ID_SIMPLE_HELP, _("&Help"), wxDefaultPosition, wxDefaultSize); wxString helpTip; helpTip.Printf(_("Get help with %s"), pSkinAdvanced->GetApplicationShortName().c_str()); itemButton45->SetHelpText(helpTip); #ifdef wxUSE_TOOLTIPS itemButton45->SetToolTip(helpTip); #endif itemBoxSizer4->Add(itemButton45, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); #endif SetFilterButtonText(); }
bool wxMacPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt) { sm_abortIt = false; sm_abortWindow = NULL; if (!printout) { sm_lastError = wxPRINTER_ERROR; return false; } if (m_printDialogData.GetMinPage() < 1) m_printDialogData.SetMinPage(1); if (m_printDialogData.GetMaxPage() < 1) m_printDialogData.SetMaxPage(9999); // Create a suitable device context wxPrinterDC *dc = NULL; if (prompt) { wxMacPrintDialog dialog(parent, & m_printDialogData); if (dialog.ShowModal() == wxID_OK) { dc = wxDynamicCast(dialog.GetPrintDC(), wxPrinterDC); wxASSERT(dc); m_printDialogData = dialog.GetPrintDialogData(); } } else { dc = new wxPrinterDC( m_printDialogData.GetPrintData() ) ; } // May have pressed cancel. if (!dc || !dc->IsOk()) { delete dc; return false; } // on the mac we have always pixels as addressing mode with 72 dpi printout->SetPPIScreen(72, 72); PMResolution res; PMPrinter printer; wxOSXPrintData* nativeData = (wxOSXPrintData*) (m_printDialogData.GetPrintData().GetNativeData()); if (PMSessionGetCurrentPrinter(nativeData->GetPrintSession(), &printer) == noErr) { if (PMPrinterGetOutputResolution( printer, nativeData->GetPrintSettings(), &res) == -9589 /* kPMKeyNotFound */ ) { res.hRes = res.vRes = 300; } } else { // fallback res.hRes = res.vRes = 300; } printout->SetPPIPrinter(int(res.hRes), int(res.vRes)); // Set printout parameters printout->SetDC(dc); int w, h; dc->GetSize(&w, &h); printout->SetPageSizePixels((int)w, (int)h); printout->SetPaperRectPixels(dc->GetPaperRect()); wxCoord mw, mh; dc->GetSizeMM(&mw, &mh); printout->SetPageSizeMM((int)mw, (int)mh); // Create an abort window wxBeginBusyCursor(); printout->OnPreparePrinting(); // Get some parameters from the printout, if defined int fromPage, toPage; int minPage, maxPage; printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage); if (maxPage == 0) { sm_lastError = wxPRINTER_ERROR; return false; } // Only set min and max, because from and to will be // set by the user if prompted for the print dialog above m_printDialogData.SetMinPage(minPage); m_printDialogData.SetMaxPage(maxPage); // Set from and to pages if bypassing the print dialog if ( !prompt ) { m_printDialogData.SetFromPage(fromPage); if( m_printDialogData.GetAllPages() ) m_printDialogData.SetToPage(maxPage); else m_printDialogData.SetToPage(toPage); } printout->OnBeginPrinting(); bool keepGoing = true; if (!printout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage())) { wxEndBusyCursor(); wxMessageBox(wxT("Could not start printing."), wxT("Print Error"), wxOK, parent); } int pn; for (pn = m_printDialogData.GetFromPage(); keepGoing && (pn <= m_printDialogData.GetToPage()) && printout->HasPage(pn); pn++) { if (sm_abortIt) { break; } else { dc->StartPage(); keepGoing = printout->OnPrintPage(pn); dc->EndPage(); } } printout->OnEndDocument(); printout->OnEndPrinting(); if (sm_abortWindow) { sm_abortWindow->Show(false); wxDELETE(sm_abortWindow); } wxEndBusyCursor(); delete dc; return true; }
void udLoopCaseAlgorithm::ProcessAlgorithm(udDiagramItem *src) { // test "prerequisites" wxASSERT(m_pParentGenerator); if(!m_pParentGenerator)return; wxASSERT(m_pParentGenerator->GetActiveLanguage()); if(!m_pParentGenerator->GetActiveLanguage())return; wxSFDiagramManager *pDiagManager = &src->GetDiagramManager(); udLanguage *pLang = m_pParentGenerator->GetActiveLanguage(); udSStateChartDiagramItem *pSCH = wxDynamicCast( src, udSStateChartDiagramItem ); if( ! pSCH ) return; bool fNonBlocking = pSCH->IsNonBlocking(); bool fHasFinalState = pDiagManager->Contains(CLASSINFO(umlFinalItem)); // get inital states ShapeList lstInitialStates; pDiagManager->GetShapes(CLASSINFO(umlInitialItem), lstInitialStates); pDiagManager->GetShapes(CLASSINFO(umlEntryItem), lstInitialStates); // create diagram function declaration if( !pSCH->IsInline() ) { udFunctionItem *pDeclFcn = IPluginManager::Get()->GetProject()->GetFunctionImplementedBy( pSCH ); if( pDeclFcn ) { pLang->WriteCodeBlocks( pDeclFcn->ToString( udCodeItem::cfDEFINITION, pLang ) ); } else { if( fHasFinalState ) pLang->FunctionDefCmd(wxT("STATE_T"), m_pParentGenerator->MakeValidIdentifier(pSCH->GetName()), wxEmptyString ); else pLang->FunctionDefCmd(pLang->GetDataTypeString(udLanguage::DT_VOID), m_pParentGenerator->MakeValidIdentifier(pSCH->GetName()), wxEmptyString ); } pLang->BeginCmd(); } if( !lstInitialStates.IsEmpty() ) { m_lstProcessedElements.Clear(); wxSFShapeBase *pHistory, *pTarget, *pInitial = lstInitialStates.GetFirst()->GetData(); // declare state variable pLang->SingleLineCommentCmd( wxT("set initial state") ); if( fNonBlocking ) pLang->VariableDeclAssignCmd( wxT("static STATE_T"), wxT("state"), m_pParentGenerator->MakeIDName(pInitial) ); else pLang->VariableDeclAssignCmd( wxT("STATE_T"), wxT("state"), m_pParentGenerator->MakeIDName(pInitial) ); // declare all history states and set history variables to proper values if( src->IsKindOf( CLASSINFO(udHStateChartDiagramItem) ) ) { ShapeList lstHistoryStates, lstOutTrans; pDiagManager->GetShapes( CLASSINFO( umlHistoryItem ), lstHistoryStates ); if( !lstHistoryStates.IsEmpty() ) pLang->SingleLineCommentCmd(wxT("set history states")); ShapeList::compatibility_iterator node = lstHistoryStates.GetFirst(); while( node ) { // find first processed state in a history level pHistory = node->GetData(); lstOutTrans.Clear(); pDiagManager->GetNeighbours( pHistory, lstOutTrans, CLASSINFO( umlTransitionItem ), wxSFShapeBase::lineSTARTING, sfDIRECT ); // there can be only one outcomming transition in hierarchical state with history if( !lstOutTrans.IsEmpty() ) { pTarget = lstOutTrans.GetFirst()->GetData(); if( fNonBlocking ) pLang->VariableDeclAssignCmd( wxT("static STATE_T"), pLang->MakeValidIdentifier( udLABEL::GetContent( pHistory, udLABEL::ltTITLE ) ).Lower(), m_pParentGenerator->MakeIDName(pTarget) ); else pLang->VariableDeclAssignCmd( wxT("STATE_T"), pLang->MakeValidIdentifier( udLABEL::GetContent( pHistory, udLABEL::ltTITLE ) ).Lower(), m_pParentGenerator->MakeIDName(pTarget) ); } node = node->GetNext(); } } pLang->NewLine(); // create infinite loop if( !fNonBlocking ) { pLang->InfiniteLoopCmd(); pLang->BeginCmd(); } // try to generate input action if set udFunctionItem *pInputAction = (udFunctionItem*) IPluginManager::Get()->GetProject()->GetProjectItem( CLASSINFO(udFunctionItem), pSCH->GetInputAction() ); if( pInputAction ) { pLang->SingleLineCommentCmd( wxT("Input action") ); if( !pInputAction->IsInline() ) pLang->WriteCodeBlocks( pInputAction->ToString( udCodeItem::cfCALL, pLang ) ); else { pLang->SingleLineCommentCmd( udGenerator::GetBeginCodeMark( pInputAction ) ); pLang->WriteCodeBlocks( pInputAction->GetCode() ); pLang->SingleLineCommentCmd( udGenerator::GetEndCodeMark( pInputAction ) ); } pLang->SingleLineCommentCmd( wxT("State machine") ); } pLang->SwitchCmd( wxT("state") ); pLang->BeginCmd(); // process diagram items (only one initial state is assumed) ProcessState( pInitial ); pLang->EndCmd(); if( !fNonBlocking ) pLang->EndCmd(); /*else if( !pSCH->IsInline() && fHasFinalState ) { pLang->NewLine(); pLang->ReturnCmd( wxT("state") ); }*/ } //pLang->ReturnCmd(pLang->NullValue()); if( !pSCH->IsInline() ) pLang->EndCmd(); }
CToolBar* CToolBar::Load(CMainFrame* pMainFrame) { { wxSize iconSize; wxString str = COptions::Get()->GetOption(OPTION_THEME_ICONSIZE); if (str == _T("32x32")) iconSize = CThemeProvider::GetIconSize(iconSizeNormal); else if (str == _T("48x48")) iconSize = CThemeProvider::GetIconSize(iconSizeLarge); else iconSize = CThemeProvider::GetIconSize(iconSizeSmall); wxToolBarXmlHandlerEx::SetIconSize(iconSize); } CToolBar* toolbar = wxDynamicCast(wxXmlResource::Get()->LoadToolBar(pMainFrame, _T("ID_TOOLBAR")), CToolBar); if (!toolbar) return 0; toolbar->m_pMainFrame = pMainFrame; CContextManager::Get()->RegisterHandler(toolbar, STATECHANGE_REMOTE_IDLE, true, true); CContextManager::Get()->RegisterHandler(toolbar, STATECHANGE_SERVER, true, true); CContextManager::Get()->RegisterHandler(toolbar, STATECHANGE_SYNC_BROWSE, true, true); CContextManager::Get()->RegisterHandler(toolbar, STATECHANGE_COMPARISON, true, true); CContextManager::Get()->RegisterHandler(toolbar, STATECHANGE_APPLYFILTER, true, false); CContextManager::Get()->RegisterHandler(toolbar, STATECHANGE_QUEUEPROCESSING, false, false); CContextManager::Get()->RegisterHandler(toolbar, STATECHANGE_CHANGEDCONTEXT, false, false); toolbar->RegisterOption(OPTION_SHOW_MESSAGELOG); toolbar->RegisterOption(OPTION_SHOW_QUEUE); toolbar->RegisterOption(OPTION_SHOW_TREE_LOCAL); toolbar->RegisterOption(OPTION_SHOW_TREE_REMOTE); toolbar->RegisterOption(OPTION_MESSAGELOG_POSITION); #if defined(EVT_TOOL_DROPDOWN) && defined(__WXMSW__) toolbar->MakeDropdownTool(XRCID("ID_TOOLBAR_SITEMANAGER")); #endif #ifdef __WXMSW__ int majorVersion, minorVersion; wxGetOsVersion(& majorVersion, & minorVersion); if (majorVersion < 6) toolbar->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)); #endif toolbar->ToggleTool(XRCID("ID_TOOLBAR_FILTER"), CFilterManager::HasActiveFilters()); toolbar->ToggleTool(XRCID("ID_TOOLBAR_LOGVIEW"), COptions::Get()->GetOptionVal(OPTION_SHOW_MESSAGELOG) != 0); toolbar->ToggleTool(XRCID("ID_TOOLBAR_QUEUEVIEW"), COptions::Get()->GetOptionVal(OPTION_SHOW_QUEUE) != 0); toolbar->ToggleTool(XRCID("ID_TOOLBAR_LOCALTREEVIEW"), COptions::Get()->GetOptionVal(OPTION_SHOW_TREE_LOCAL) != 0); toolbar->ToggleTool(XRCID("ID_TOOLBAR_REMOTETREEVIEW"), COptions::Get()->GetOptionVal(OPTION_SHOW_TREE_REMOTE) != 0); if (COptions::Get()->GetOptionVal(OPTION_MESSAGELOG_POSITION) == 2) toolbar->HideTool(XRCID("ID_TOOLBAR_LOGVIEW")); #ifdef __WXMAC__ // Hide then re-show fixes some odd sizing toolbar->Hide(); if (COptions::Get()->GetOptionVal(OPTION_TOOLBAR_HIDDEN) == 0) toolbar->Show(); #endif return toolbar; }
wxObject *wxAuiToolBarXmlHandler::DoCreateResource() { wxAuiToolBar* toolbar=NULL; if (m_class == _T("tool")) { wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: tool not within a toolbar!")); wxSize bitmapSize = m_toolbar->GetToolBitmapSize(); if (GetPosition() != wxDefaultPosition) { m_toolbar->AddTool(GetID(), GetCenteredBitmap(_T("bitmap"), wxART_OTHER, wxSize(16,16)), NULL, //GetCenteredBitmap(_T("bitmap2"), wxART_TOOLBAR, bitmapSize), GetBool(_T("toggle")), NULL, GetText(_T("tooltip")), GetText(_T("longhelp"))); if (GetBool(_T("disabled"))) { m_toolbar->Realize(); m_toolbar->EnableTool(GetID(),false); } } else { wxItemKind kind = wxITEM_NORMAL; if (GetBool(_T("radio"))) kind = wxITEM_RADIO; if (GetBool(_T("toggle"))) { wxASSERT_MSG( kind == wxITEM_NORMAL, _("can't have both toggleable and radion button at once") ); kind = wxITEM_CHECK; } m_toolbar->AddTool(GetID(), GetText(_T("label")), GetCenteredBitmap(_T("bitmap"), wxART_OTHER, bitmapSize), GetCenteredBitmap(_T("bitmap2"), wxART_OTHER, bitmapSize), kind, GetText(_T("tooltip")), GetText(_T("longhelp"))); if (GetBool(_T("disabled"))) { m_toolbar->Realize(); m_toolbar->EnableTool(GetID(),false); } } return m_toolbar; // must return non-NULL } else if (m_class == _T("overflow_tool")) { wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: tool not within a toolbar!")); wxSize bitmapSize = m_toolbar->GetToolBitmapSize(); wxItemKind kind = wxITEM_NORMAL; if (GetBool(_T("radio"))) kind = wxITEM_RADIO; if (GetBool(_T("toggle"))) { wxASSERT_MSG( kind == wxITEM_NORMAL, _("can't have both toggleable and radion button at once") ); kind = wxITEM_CHECK; } if (GetBool(_T("separator"))) kind = wxITEM_SEPARATOR; m_toolbar->AddOverflowTool(GetID(), GetText(_T("label")), GetCenteredBitmap(_T("bitmap"), wxART_OTHER, bitmapSize), GetText(_T("longhelp")), kind, GetBool(_T("prepend"),0) ); if (GetBool(_T("disabled"))) { m_toolbar->Realize(); m_toolbar->EnableTool(GetID(),false); } return m_toolbar; // must return non-NULL } else if (m_class == _T("separator")) { wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: separator not within a toolbar!")); m_toolbar->AddSeparator(); return m_toolbar; // must return non-NULL } else /*<object class="wxAuiToolBar">*/ { toolbar=(wxAuiToolBar*)m_instance; if(!toolbar && (m_class == _T("wxToolBarAddOn"))) { toolbar = new wxAuiToolBar(m_parentAsWindow, -1, wxDefaultPosition, wxDefaultSize); m_instance = (wxObject *)toolbar; } long style = GetStyle(_T("style"), -1); if (style!=-1) toolbar->SetWindowStyle(style); style = GetStyle(_T("add_style"), -1); if (style!=-1) toolbar->SetWindowStyle(toolbar->GetWindowStyle() | style); style = GetStyle(_T("remove_style"), -1); if (style!=-1) toolbar->SetWindowStyle(toolbar->GetWindowStyle() & ~style); wxSize bmpsize = GetSize(_T("bitmapsize")); // First find the generic bitmap size if (!(bmpsize == wxDefaultSize)) toolbar->SetToolBitmapSize(bmpsize); else { // if no generic size then find the platform dependent size #ifdef __WXMSW__ bmpsize = GetSize(_T("bitmapsize_win")); #endif #ifdef __WXMAC__ bmpsize = GetSize(_T("bitmapsize_mac")); #endif #ifdef __WXGTK__ bmpsize = GetSize(_T("bitmapsize_unix")); #endif if (!(bmpsize == wxDefaultSize)) toolbar->SetToolBitmapSize(bmpsize); } wxSize margins = GetSize(_T("margins")); if (!(margins == wxDefaultSize)) toolbar->SetMargins(margins.x, margins.y); long packing = GetLong(_T("packing"), -1); if (packing != -1) toolbar->SetToolPacking(packing); long separation = GetLong(_T("separation"), -1); if (separation != -1) toolbar->SetToolSeparation(separation); wxXmlNode *children_node = GetParamNode(_T("object")); if (!children_node) children_node = GetParamNode(_T("object_ref")); if (children_node == NULL) return toolbar; m_isInside = TRUE; m_toolbar = toolbar; wxXmlNode *n = children_node; while (n) { if ((n->GetType() == wxXML_ELEMENT_NODE) && (n->GetName() == _T("object") || n->GetName() == _T("object_ref"))) { wxObject *created = CreateResFromNode(n, toolbar, NULL); wxControl *control = wxDynamicCast(created, wxControl); if (!IsOfClass(n, _T("tool")) && !IsOfClass(n, _T("separator")) && control != NULL && control != toolbar) { //Manager::Get()->GetLogManager()->DebugLog(F(_T("control=%p, parent=%p, toolbar=%p"), control, control->GetParent(), toolbar)); toolbar->AddControl(control); } } n = n->GetNext(); } toolbar->Realize(); m_isInside = FALSE; m_toolbar = NULL; m_isAddon=false; return toolbar; } }
wxGxObjectDialog::wxGxObjectDialog( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style ), wxGISApplicationBase(), wxGxApplicationBase() { //this->SetSizeHints( wxSize( 400,300 ), wxDefaultSize ); m_pDropDownCommand = NULL; m_bAllowMultiSelect = false; m_bOverwritePrompt = false; m_nDefaultFilter = 0; m_pwxGxContentView = NULL; m_PopupCtrl = NULL; m_bAllFilters = true; m_bOwnFilter = true; m_pCatalog = wxDynamicCast(GetGxCatalog(), wxGxCatalogUI); bMainSizer = new wxBoxSizer( wxVERTICAL ); bHeaderSizer = new wxBoxSizer( wxHORIZONTAL ); m_staticText1 = new wxStaticText( this, wxID_ANY, _("Look in: "), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT ); m_staticText1->Wrap( -1 ); bHeaderSizer->Add( m_staticText1, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 ); m_TreeCombo = new wxComboCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxCB_READONLY); #ifdef __WXMSW__ m_TreeCombo->UseAltPopupWindow(true); #else m_TreeCombo->UseAltPopupWindow(false); #endif m_PopupCtrl = new wxTreeViewComboPopup(); m_TreeCombo->SetPopupControl(m_PopupCtrl); m_TreeCombo->EnablePopupAnimation(true); //m_PopupCtrl->Connect( wxEVT_LEFT_UP, wxMouseEventHandler( wxTreeViewComboPopup::OnMouseClick ), NULL, m_PopupCtrl ); m_PopupCtrl->Activate(this, NULL);//TODO: bHeaderSizer->Add( m_TreeCombo, 1, wxALL | wxALIGN_CENTER_VERTICAL, 5 ); m_toolBar = new wxAuiToolBar( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxAUI_TB_HORZ_LAYOUT|wxBORDER_NONE); m_toolBar->SetToolBitmapSize( wxSize( 16,16 ) ); m_toolBar->SetArtProvider(new wxGxToolBarArt()); // 0 Up One Level // 1 Connect Folder // 2 Disconnect Folder // 3 Location // 4 Delete Item // 5 Back // 6 Forward // 7 Create Folder int IDs[8] = {5,0,wxNOT_FOUND,1,2,wxNOT_FOUND,4,7}; wxGISCatalogMainCmd* pwxGISCatalogMainCmd(NULL); int nCmdCounter(0); for(size_t i = 0; i < 8; ++i) { if(IDs[i] == wxNOT_FOUND) { m_toolBar->AddSeparator(); continue; } pwxGISCatalogMainCmd = new wxGISCatalogMainCmd(); pwxGISCatalogMainCmd->OnCreate(this); pwxGISCatalogMainCmd->SetSubType(IDs[i]); pwxGISCatalogMainCmd->SetId(ID_PLUGINCMD + nCmdCounter); nCmdCounter++; m_CommandArray.push_back(pwxGISCatalogMainCmd); wxGISEnumCommandKind kind = pwxGISCatalogMainCmd->GetKind(); if (kind == enumGISCommandDropDown) kind = enumGISCommandNormal; m_toolBar->AddTool( pwxGISCatalogMainCmd->GetId(), pwxGISCatalogMainCmd->GetCaption(), pwxGISCatalogMainCmd->GetBitmap(), wxNullBitmap, (wxItemKind)kind, pwxGISCatalogMainCmd->GetTooltip(), pwxGISCatalogMainCmd->GetMessage(), NULL ); if(pwxGISCatalogMainCmd->GetKind() == enumGISCommandDropDown) m_toolBar->SetToolDropDown(pwxGISCatalogMainCmd->GetId(), true); } wxGISCatalogViewsCmd* pwxGISCatalogViewsCmd = new wxGISCatalogViewsCmd(); pwxGISCatalogViewsCmd->OnCreate(this); pwxGISCatalogViewsCmd->SetSubType(0); pwxGISCatalogViewsCmd->SetId(ID_PLUGINCMD + nCmdCounter); nCmdCounter++; //pwxGISCatalogViewsCmd->SetID(ID_PLUGINCMD + 9); m_CommandArray.push_back(pwxGISCatalogViewsCmd); wxGISEnumCommandKind kind = pwxGISCatalogViewsCmd->GetKind(); if(pwxGISCatalogViewsCmd->GetKind() == enumGISCommandDropDown) kind = enumGISCommandNormal; m_toolBar->AddTool( pwxGISCatalogViewsCmd->GetId(), pwxGISCatalogViewsCmd->GetCaption(), pwxGISCatalogViewsCmd->GetBitmap(), wxNullBitmap, (wxItemKind)kind, pwxGISCatalogViewsCmd->GetTooltip(), pwxGISCatalogViewsCmd->GetMessage(), NULL ); if(pwxGISCatalogViewsCmd->GetKind() == enumGISCommandDropDown) m_toolBar->SetToolDropDown(pwxGISCatalogViewsCmd->GetId(), true); m_toolBar->Realize(); //rename pwxGISCatalogMainCmd = new wxGISCatalogMainCmd(); pwxGISCatalogMainCmd->OnCreate(this); pwxGISCatalogMainCmd->SetId(ID_PLUGINCMD + nCmdCounter); pwxGISCatalogMainCmd->SetSubType(8); m_CommandArray.push_back(pwxGISCatalogMainCmd); nCmdCounter++; //refresh pwxGISCatalogMainCmd = new wxGISCatalogMainCmd(); pwxGISCatalogMainCmd->OnCreate(this); pwxGISCatalogMainCmd->SetId(ID_PLUGINCMD + nCmdCounter); pwxGISCatalogMainCmd->SetSubType(9); m_CommandArray.push_back(pwxGISCatalogMainCmd); nCmdCounter++; //load accelerators m_pGISAcceleratorTable = new wxGISAcceleratorTable(this); bHeaderSizer->Add( m_toolBar, 0, wxALIGN_CENTER_VERTICAL, 5 ); m_staticText2 = new wxStaticText( this, wxID_ANY, wxT(" "), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT ); m_staticText2->Wrap( -1 ); bHeaderSizer->Add( m_staticText2, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 ); bMainSizer->Add( bHeaderSizer, 0, wxEXPAND, 5 ); // // fgCeilSizer = new wxFlexGridSizer( 2, 3, 0, 0 ); fgCeilSizer->AddGrowableCol( 1 ); fgCeilSizer->SetFlexibleDirection( wxBOTH ); fgCeilSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED ); m_staticText4 = new wxStaticText( this, wxID_ANY, _("Name:"), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT ); m_staticText4->Wrap( -1 ); fgCeilSizer->Add( m_staticText4, 0, wxALL|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 ); m_NameTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_NO_VSCROLL, wxGenericValidator(&m_sName) ); fgCeilSizer->Add( m_NameTextCtrl, 1, wxALL|wxALIGN_CENTER_VERTICAL|wxEXPAND, 5 ); m_OkButton = new wxButton( this, wxID_OK , _("Activate"), wxDefaultPosition, wxDefaultSize, 0 ); m_OkButton->SetDefault(); fgCeilSizer->Add( m_OkButton, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 ); m_staticText6 = new wxStaticText( this, wxID_ANY, _("Show of type:"), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT ); m_staticText6->Wrap( -1 ); fgCeilSizer->Add( m_staticText6, 0, wxALL|wxALIGN_RIGHT, 5 ); m_WildcardCombo = new wxComboBox( this, FILTERCOMBO, _("Combo!"), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_DROPDOWN|wxCB_READONLY );//|wxCB_SORT fgCeilSizer->Add( m_WildcardCombo, 0, wxALL|wxEXPAND, 5 ); m_CancelButton = new wxButton( this, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 ); fgCeilSizer->Add( m_CancelButton, 0, wxALL, 5 ); bMainSizer->Add( fgCeilSizer, 0, wxEXPAND, 5 ); this->SetSizerAndFit(bMainSizer); this->Layout(); }
bool wxToolBar::Realize() { int nMaxToolWidth = 0; int nMaxToolHeight = 0; m_nCurrentRowsOrColumns = 0; m_vLastX = m_xMargin; m_vLastY = m_yMargin; m_vMaxWidth = 0; m_vMaxHeight = 0; // // Find the maximum tool width and height // wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); while (node ) { wxToolBarTool* pTool = (wxToolBarTool *)node->GetData(); if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty()) { // // Set the height according to the font and the border size // if (pTool->GetWidth() > m_vTextX) nMaxToolWidth = pTool->GetWidth() + 4; else nMaxToolWidth = m_vTextX; if (pTool->GetHeight() + m_vTextY > nMaxToolHeight) nMaxToolHeight = pTool->GetHeight() + m_vTextY; } else { if (pTool->GetWidth() > nMaxToolWidth ) nMaxToolWidth = pTool->GetWidth() + 4; if (pTool->GetHeight() > nMaxToolHeight) nMaxToolHeight = pTool->GetHeight(); } node = node->GetNext(); } wxCoord vTbWidth = 0L; wxCoord vTbHeight = 0L; GetSize( &vTbWidth ,&vTbHeight ); if (vTbHeight < nMaxToolHeight) { SetSize( -1L ,-1L ,vTbWidth ,nMaxToolHeight + 4 ); if (GetParent()->IsKindOf(CLASSINFO(wxFrame))) { wxFrame* pFrame = wxDynamicCast(GetParent(), wxFrame); if (pFrame) pFrame->PositionToolBar(); } } int nSeparatorSize = m_toolSeparation; node = m_tools.GetFirst(); while (node) { wxToolBarTool* pTool = (wxToolBarTool *)node->GetData(); if (pTool->IsSeparator()) { if (GetWindowStyleFlag() & (wxTB_TOP | wxTB_BOTTOM)) { pTool->m_vX = m_vLastX + nSeparatorSize; pTool->m_vHeight = m_defaultHeight + m_vTextY; if (m_nCurrentRowsOrColumns >= m_maxCols) m_vLastY += nSeparatorSize; else m_vLastX += nSeparatorSize * 4; } else { pTool->m_vY = m_vLastY + nSeparatorSize; pTool->m_vHeight = m_defaultHeight + m_vTextY; if (m_nCurrentRowsOrColumns >= m_maxRows) m_vLastX += nSeparatorSize; else m_vLastY += nSeparatorSize * 4; } } else if (pTool->IsButton()) { if (GetWindowStyleFlag() & (wxTB_TOP | wxTB_BOTTOM)) { if (m_nCurrentRowsOrColumns >= m_maxCols) { m_nCurrentRowsOrColumns = 0; m_vLastX = m_xMargin; m_vLastY += nMaxToolHeight + m_toolPacking; } pTool->m_vX = m_vLastX + (nMaxToolWidth - ((int)(nMaxToolWidth/2) + (int)(pTool->GetWidth()/2))); if (HasFlag(wxTB_TEXT)) pTool->m_vY = m_vLastY + nSeparatorSize - 2; // just bit of adjustment else pTool->m_vY = m_vLastY + (nMaxToolHeight - (int)(pTool->GetHeight()/2)); m_vLastX += nMaxToolWidth + m_toolPacking + m_toolSeparation; } else { if (m_nCurrentRowsOrColumns >= m_maxRows) { m_nCurrentRowsOrColumns = 0; m_vLastX += (nMaxToolWidth + m_toolPacking); m_vLastY = m_yMargin; } pTool->m_vX = m_vLastX + pTool->GetWidth(); if ( HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty() ) pTool->m_vY = m_vLastY + (nMaxToolHeight - m_vTextY) + m_toolPacking; else pTool->m_vY = m_vLastY + (nMaxToolHeight - (int)(pTool->GetHeight()/2)); m_vLastY += nMaxToolHeight + m_toolPacking + m_toolSeparation; } m_nCurrentRowsOrColumns++; } else { // TODO: support the controls } if (m_vLastX > m_maxWidth) m_maxWidth = m_vLastX; if (m_vLastY > m_maxHeight) m_maxHeight = m_vLastY; node = node->GetNext(); } if (GetWindowStyleFlag() & (wxTB_TOP | wxTB_BOTTOM)) m_maxWidth += nMaxToolWidth; else m_maxHeight += nMaxToolHeight; m_maxWidth += m_xMargin; m_maxHeight += m_yMargin; m_bInitialized = true; return true; } // end of wxToolBar::Realize
MyHtmlListBox *GetMyBox() { return wxDynamicCast(m_hlbox, MyHtmlListBox); }