bool wxNotebook::InsertPage( size_t position, wxNotebookPage* win, const wxString& text, bool select, int imageId ) { wxCHECK_MSG( m_widget != NULL, false, wxT("invalid notebook") ); wxCHECK_MSG( win->GetParent() == this, false, wxT("Can't add a page whose parent is not the notebook!") ); wxCHECK_MSG( position <= GetPageCount(), false, wxT("invalid page index in wxNotebookPage::InsertPage()") ); // Hack Alert! (Part II): See above in wxNotebook::AddChildGTK // why this has to be done. gtk_widget_unparent(win->m_widget); if (m_themeEnabled) win->SetThemeEnabled(true); GtkNotebook *notebook = GTK_NOTEBOOK(m_widget); wxGtkNotebookPage* pageData = new wxGtkNotebookPage; m_pages.Insert(win, position); m_pagesData.Insert(position, pageData); // set the label image and text // this must be done before adding the page, as GetPageText // and GetPageImage will otherwise return wrong values in // the page-changed event that results from inserting the // first page. pageData->m_imageIndex = imageId; pageData->m_box = gtk_hbox_new(false, 1); gtk_container_set_border_width(GTK_CONTAINER(pageData->m_box), 2); pageData->m_image = NULL; if (imageId != -1) { if (m_imageList) { const wxBitmap* bitmap = m_imageList->GetBitmapPtr(imageId); pageData->m_image = gtk_image_new_from_pixbuf(bitmap->GetPixbuf()); gtk_box_pack_start(GTK_BOX(pageData->m_box), pageData->m_image, false, false, m_padding); } else wxFAIL_MSG("invalid notebook imagelist"); } /* set the label text */ pageData->m_label = gtk_label_new(wxGTK_CONV(wxStripMenuCodes(text))); gtk_box_pack_end(GTK_BOX(pageData->m_box), pageData->m_label, false, false, m_padding); gtk_widget_show_all(pageData->m_box); gtk_notebook_insert_page(notebook, win->m_widget, pageData->m_box, position); /* apply current style */ GtkRcStyle *style = GTKCreateWidgetStyle(); if ( style ) { gtk_widget_modify_style(pageData->m_label, style); gtk_rc_style_unref(style); } if (select && GetPageCount() > 1) { SetSelection( position ); } InvalidateBestSize(); return true; }
void wxListBox::DoInsertItems(const wxArrayString& items, unsigned int pos) { wxCHECK_RET( m_list != NULL, wxT("invalid listbox") ); // VZ: notice that InsertItems knows nothing about sorting, so calling it // from outside (and not from our own Append) is likely to break // everything // code elsewhere supposes we have as many items in m_clientList as items // in the listbox wxASSERT_MSG( m_clientList.GetCount() == GetCount(), wxT("bug in client data management") ); InvalidateBestSize(); GList *children = m_list->children; unsigned int length = g_list_length(children); wxCHECK_RET( pos <= length, wxT("invalid index in wxListBox::InsertItems") ); unsigned int nItems = items.GetCount(); int index; if (m_strings) { for (unsigned int n = 0; n < nItems; n++) { index = m_strings->Add( items[n] ); if (index != (int)GetCount()) { GtkAddItem( items[n], index ); wxList::compatibility_iterator node = m_clientList.Item( index ); m_clientList.Insert( node, (wxObject*) NULL ); } else { GtkAddItem( items[n] ); m_clientList.Append( (wxObject*) NULL ); } } } else { if (pos == length) { for ( unsigned int n = 0; n < nItems; n++ ) { GtkAddItem( items[n] ); m_clientList.Append((wxObject *)NULL); } } else { wxList::compatibility_iterator node = m_clientList.Item( pos ); for ( unsigned int n = 0; n < nItems; n++ ) { GtkAddItem( items[n], pos+n ); m_clientList.Insert( node, (wxObject *)NULL ); } } } wxASSERT_MSG( m_clientList.GetCount() == GetCount(), wxT("bug in client data management") ); }
bool wxNotebook::InsertPage( size_t position, wxNotebookPage* win, const wxString& text, bool select, int imageId ) { wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") ); wxCHECK_MSG( win->GetParent() == this, FALSE, wxT("Can't add a page whose parent is not the notebook!") ); wxCHECK_MSG( position <= GetPageCount(), FALSE, wxT("invalid page index in wxNotebookPage::InsertPage()") ); // Hack Alert! (Part II): See above in wxInsertChildInNotebook callback // why this has to be done. NOTE: using gtk_widget_unparent here does not // work as it seems to undo too much and will cause errors in the // gtk_notebook_insert_page below, so instead just clear the parent by // hand here. win->m_widget->parent = NULL; // don't receive switch page during addition gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget), GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this ); if (m_themeEnabled) win->SetThemeEnabled(true); GtkNotebook *notebook = GTK_NOTEBOOK(m_widget); wxGtkNotebookPage *nb_page = new wxGtkNotebookPage(); if ( position == GetPageCount() ) m_pagesData.Append( nb_page ); else m_pagesData.Insert( position, nb_page ); m_pages.Insert(win, position); nb_page->m_box = gtk_hbox_new( FALSE, 1 ); gtk_container_border_width( GTK_CONTAINER(nb_page->m_box), 2 ); gtk_signal_connect( GTK_OBJECT(win->m_widget), "size_allocate", GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)win ); gtk_notebook_insert_page( notebook, win->m_widget, nb_page->m_box, position ); nb_page->m_page = (GtkNotebookPage*) g_list_last(notebook->children)->data; /* set the label image */ nb_page->m_image = imageId; if (imageId != -1) { wxASSERT( m_imageList != NULL ); const wxBitmap *bmp = m_imageList->GetBitmapPtr(imageId); GdkPixmap *pixmap = bmp->GetPixmap(); GdkBitmap *mask = NULL; if ( bmp->GetMask() ) { mask = bmp->GetMask()->GetBitmap(); } GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask ); gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding); gtk_widget_show(pixmapwid); } /* set the label text */ nb_page->m_text = text; if (nb_page->m_text.empty()) nb_page->m_text = wxEmptyString; nb_page->m_label = GTK_LABEL( gtk_label_new(wxGTK_CONV(nb_page->m_text)) ); gtk_box_pack_end( GTK_BOX(nb_page->m_box), GTK_WIDGET(nb_page->m_label), FALSE, FALSE, m_padding ); /* apply current style */ GtkRcStyle *style = CreateWidgetStyle(); if ( style ) { gtk_widget_modify_style(GTK_WIDGET(nb_page->m_label), style); gtk_rc_style_unref(style); } /* show the label */ gtk_widget_show( GTK_WIDGET(nb_page->m_label) ); if (select && (m_pagesData.GetCount() > 1)) { SetSelection( position ); } gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page", GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this ); InvalidateBestSize(); return true; }
void wxMultiColumnListCtrl::CalculateLayout(wxDC& dc) { if (m_items.GetSelection() == -1) m_items.SetSelection(0); int columnCount = 1; // Spacing between edge of window or between columns int xMargin = 4; int yMargin = 4; // Inter-row spacing int rowSpacing = 2; wxSize itemSize = m_items.CalculateItemSize(dc); m_overallSize = wxSize(350, 200); size_t i; int currentRow = 0; int x = xMargin; int y = yMargin; bool breaking = false; for (i = 0; i < (size_t) m_items.GetItemCount(); i++) { wxSize oldOverallSize = m_overallSize; m_items.GetItem(i).SetRect(wxRect(x, y, itemSize.x, itemSize.y)); m_items.GetItem(i).SetColPos(columnCount-1); m_items.GetItem(i).SetRowPos(currentRow); if (m_items.GetItem(i).GetRect().GetBottom() > m_overallSize.y) m_overallSize.y = m_items.GetItem(i).GetRect().GetBottom() + yMargin; if (m_items.GetItem(i).GetRect().GetRight() > m_overallSize.x) m_overallSize.x = m_items.GetItem(i).GetRect().GetRight() + xMargin; currentRow ++; y += (rowSpacing + itemSize.y); bool stopBreaking = breaking; if ((currentRow > m_items.GetRowCount()) || (m_items.GetItem(i).GetBreakColumn() && !breaking && (currentRow != 1))) { currentRow = 0; columnCount ++; x += (xMargin + itemSize.x); y = yMargin; // Make sure we don't orphan a group if (m_items.GetItem(i).GetIsGroup() || (m_items.GetItem(i).GetBreakColumn() && !breaking)) { m_overallSize = oldOverallSize; if (m_items.GetItem(i).GetBreakColumn()) breaking = true; // Repeat the last item, in the next column i --; } } if (stopBreaking) breaking = false; } m_items.SetColumnCount(columnCount); InvalidateBestSize(); }
bool wxControlBase::SetFont(const wxFont& font) { InvalidateBestSize(); return wxWindow::SetFont(font); }
int wxComboBox::DoInsertItems(const wxArrayStringsAdapter& items, unsigned int pos, void **clientData, wxClientDataType type) { wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid combobox") ); DisableEvents(); GtkWidget *list = GTK_COMBO(m_widget)->list; GtkRcStyle *style = CreateWidgetStyle(); const unsigned int count = items.GetCount(); for( unsigned int i = 0; i < count; ++i, ++pos ) { GtkWidget * list_item = gtk_list_item_new_with_label( wxGTK_CONV( items[i] ) ); if ( pos == GetCount() ) { gtk_container_add( GTK_CONTAINER(list), list_item ); } else // insert, not append { GList *gitem_list = g_list_alloc (); gitem_list->data = list_item; gtk_list_insert_items( GTK_LIST (list), gitem_list, pos ); } if (GTK_WIDGET_REALIZED(m_widget)) { gtk_widget_realize( list_item ); gtk_widget_realize( GTK_BIN(list_item)->child ); if (style) { gtk_widget_modify_style( GTK_WIDGET( list_item ), style ); GtkBin *bin = GTK_BIN( list_item ); GtkWidget *label = GTK_WIDGET( bin->child ); gtk_widget_modify_style( label, style ); } } gtk_widget_show( list_item ); if ( m_clientDataList.GetCount() < GetCount() ) m_clientDataList.Insert( pos, NULL ); if ( m_clientObjectList.GetCount() < GetCount() ) m_clientObjectList.Insert( pos, NULL ); AssignNewItemClientData(pos, clientData, i, type); } if ( style ) gtk_rc_style_unref( style ); EnableEvents(); InvalidateBestSize(); return pos - 1; }
bool wxToolBar::Realize() { if (m_tools.GetCount() == 0) return FALSE; int x = m_xMargin + kwxMacToolBarLeftMargin ; int y = m_yMargin + kwxMacToolBarTopMargin ; int tw, th; GetSize(& tw, & th); int maxWidth = 0 ; int maxHeight = 0 ; int maxToolWidth = 0; int maxToolHeight = 0; // Find the maximum tool width and height wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); while ( node ) { wxToolBarTool *tool = (wxToolBarTool *)node->GetData(); wxSize sz = tool->GetSize() ; if ( sz.x > maxToolWidth ) maxToolWidth = sz.x ; if (sz.y> maxToolHeight) maxToolHeight = sz.y; node = node->GetNext(); } bool lastWasRadio = FALSE; node = m_tools.GetFirst(); while (node) { wxToolBarTool *tool = (wxToolBarTool *)node->GetData(); wxSize cursize = tool->GetSize() ; bool isRadio = FALSE; if ( tool->IsButton() && tool->GetKind() == wxITEM_RADIO ) { if ( !lastWasRadio ) { if (tool->Toggle(true)) { DoToggleTool(tool, true); } } else if (tool->IsToggled()) { wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious(); while ( nodePrev ) { wxToolBarToolBase *tool = nodePrev->GetData(); if ( !tool->IsButton() || (tool->GetKind() != wxITEM_RADIO) ) break; if ( tool->Toggle(false) ) { DoToggleTool(tool, false); } nodePrev = nodePrev->GetPrevious(); } } isRadio = TRUE; } else { isRadio = FALSE; } lastWasRadio = isRadio; // for the moment we just do a single row/column alignement if ( x + cursize.x > maxWidth ) maxWidth = x + cursize.x ; if ( y + cursize.y > maxHeight ) maxHeight = y + cursize.y ; if ( GetWindowStyleFlag() & wxTB_VERTICAL ) { int x1 = x + (maxToolWidth - cursize.x)/2 ; tool->SetPosition( wxPoint( x1 , y ) ) ; } else { int y1 = y + (maxToolHeight - cursize.y)/2 ; tool->SetPosition( wxPoint( x , y1 ) ) ; } if ( GetWindowStyleFlag() & wxTB_VERTICAL ) { y += cursize.y ; y += kwxMacToolSpacing ; } else { x += cursize.x ; x += kwxMacToolSpacing ; } node = node->GetNext(); } if ( GetWindowStyleFlag() & wxTB_HORIZONTAL ) { if ( m_maxRows == 0 ) { // if not set yet, only one row SetRows(1); } m_minWidth = maxWidth; maxWidth = tw ; maxHeight += m_yMargin + kwxMacToolBarTopMargin; m_minHeight = m_maxHeight = maxHeight ; } else { if ( GetToolsCount() > 0 && m_maxRows == 0 ) { // if not set yet, have one column SetRows(GetToolsCount()); } m_minHeight = maxHeight; maxHeight = th ; maxWidth += m_xMargin + kwxMacToolBarLeftMargin; m_minWidth = m_maxWidth = maxWidth ; } SetSize( maxWidth, maxHeight ); InvalidateBestSize(); return TRUE; }
void wxAnyButton::DoSetBitmap(const wxBitmap& bitmap, State which) { switch ( which ) { case State_Normal: if ( DontShowLabel() ) { // we only have the bitmap in this button, never remove it but // do invalidate the best size when the bitmap (and presumably // its size) changes InvalidateBestSize(); } #ifdef __WXGTK26__ // normal image is special: setting it enables images for the button and // resetting it to nothing disables all of them else if ( !gtk_check_version(2,6,0) ) { GtkWidget *image = gtk_button_get_image(GTK_BUTTON(m_widget)); if ( image && !bitmap.IsOk() ) { gtk_container_remove(GTK_CONTAINER(m_widget), image); } else if ( !image && bitmap.IsOk() ) { image = gtk_image_new(); gtk_button_set_image(GTK_BUTTON(m_widget), image); } else // image presence or absence didn't change { // don't invalidate best size below break; } InvalidateBestSize(); } #endif // GTK+ 2.6+ break; case State_Pressed: if ( bitmap.IsOk() ) { if ( !m_bitmaps[which].IsOk() ) { // we need to install the callbacks to be notified about // the button pressed state change g_signal_connect ( m_widget, "pressed", G_CALLBACK(wxgtk_button_press_callback), this ); g_signal_connect ( m_widget, "released", G_CALLBACK(wxgtk_button_released_callback), this ); } } else // no valid bitmap { if ( m_bitmaps[which].IsOk() ) { // we don't need to be notified about the button pressed // state changes any more g_signal_handlers_disconnect_by_func ( m_widget, (gpointer)wxgtk_button_press_callback, this ); g_signal_handlers_disconnect_by_func ( m_widget, (gpointer)wxgtk_button_released_callback, this ); // also make sure we don't remain stuck in pressed state if ( m_isPressed ) { m_isPressed = false; GTKUpdateBitmap(); } } } break; case State_Current: // the logic here is the same as above for State_Pressed: we need // to connect the handlers if we must be notified about the changes // in the button current state and we disconnect them when/if we // don't need them any more if ( bitmap.IsOk() ) { if ( !m_bitmaps[which].IsOk() ) { g_signal_connect ( m_widget, "enter", G_CALLBACK(wxgtk_button_enter_callback), this ); g_signal_connect ( m_widget, "leave", G_CALLBACK(wxgtk_button_leave_callback), this ); } } else // no valid bitmap { if ( m_bitmaps[which].IsOk() ) { g_signal_handlers_disconnect_by_func ( m_widget, (gpointer)wxgtk_button_enter_callback, this ); g_signal_handlers_disconnect_by_func ( m_widget, (gpointer)wxgtk_button_leave_callback, this ); if ( m_isCurrent ) { m_isCurrent = false; GTKUpdateBitmap(); } } } break; case State_Focused: if ( bitmap.IsOk() ) { Connect(wxEVT_SET_FOCUS, wxFocusEventHandler(wxAnyButton::GTKOnFocus)); Connect(wxEVT_KILL_FOCUS, wxFocusEventHandler(wxAnyButton::GTKOnFocus)); } else // no valid focused bitmap { Disconnect(wxEVT_SET_FOCUS, wxFocusEventHandler(wxAnyButton::GTKOnFocus)); Disconnect(wxEVT_KILL_FOCUS, wxFocusEventHandler(wxAnyButton::GTKOnFocus)); } break; default: // no callbacks to connect/disconnect ; } m_bitmaps[which] = bitmap; // update the bitmap immediately if necessary, otherwise it will be done // when the bitmap for the corresponding state is needed the next time by // GTKUpdateBitmap() if ( bitmap.IsOk() && which == GTKGetCurrentState() ) { GTKDoShowBitmap(bitmap); } }
void wxStaticBitmap::SetImageNoCopy( wxGDIImage* image) { Free(); InvalidateBestSize(); m_isIcon = image->IsKindOf( wxCLASSINFO(wxIcon) ); // the image has already been copied m_image = image; int x, y; int w, h; GetPosition(&x, &y); GetSize(&w, &h); // Normally we just use the handle of provided image but in some cases we // create our own temporary bitmap, so the actual handle may end up being // different from the original one. const HANDLE handleOrig = (HANDLE)m_image->GetHandle(); HANDLE handle = handleOrig; #if wxUSE_WXDIB if ( !m_isIcon ) { // wxBitmap normally stores alpha in pre-multiplied format but // apparently STM_SETIMAGE message handler does pre-multiplication // internally so we need to undo the pre-multiplication here for a // while (this is similar to what we do in ImageList::Add()). const wxBitmap& bmp = static_cast<wxBitmap&>(*image); if ( bmp.HasAlpha() ) { // For bitmap with alpha channel create temporary DIB with // not-premultiplied alpha values. handle = wxDIB(bmp.ConvertToImage(), wxDIB::PixelFormat_NotPreMultiplied).Detach(); } } #endif // wxUSE_WXDIB LONG style = ::GetWindowLong( (HWND)GetHWND(), GWL_STYLE ) ; ::SetWindowLong( (HWND)GetHWND(), GWL_STYLE, ( style & ~( SS_BITMAP|SS_ICON ) ) | ( m_isIcon ? SS_ICON : SS_BITMAP ) ); MSWReplaceImageHandle((WXLPARAM)handle); DeleteCurrentHandleIfNeeded(); m_currentHandle = (WXHANDLE)handle; m_ownsCurrentHandle = handle != handleOrig; if ( ImageIsOk() ) { int width = image->GetWidth(), height = image->GetHeight(); if ( width && height ) { w = width; h = height; ::MoveWindow(GetHwnd(), x, y, width, height, FALSE); } } RECT rect; rect.left = x; rect.top = y; rect.right = x + w; rect.bottom = y + h; ::InvalidateRect(GetHwndOf(GetParent()), &rect, TRUE); }
bool wxNotebook::InsertPage( size_t position, wxNotebookPage* win, const wxString& text, bool select, int imageId ) { wxCHECK_MSG( m_widget != NULL, false, wxT("invalid notebook") ); wxCHECK_MSG( win->GetParent() == this, false, wxT("Can't add a page whose parent is not the notebook!") ); wxCHECK_MSG( position <= GetPageCount(), false, _T("invalid page index in wxNotebookPage::InsertPage()") ); // Hack Alert! (Part II): See above in wxInsertChildInNotebook callback // why this has to be done. NOTE: using gtk_widget_unparent here does not // work as it seems to undo too much and will cause errors in the // gtk_notebook_insert_page below, so instead just clear the parent by // hand here. win->m_widget->parent = NULL; if (m_themeEnabled) win->SetThemeEnabled(true); GtkNotebook *notebook = GTK_NOTEBOOK(m_widget); wxGtkNotebookPage *nb_page = new wxGtkNotebookPage(); if ( position == GetPageCount() ) m_pagesData.Append( nb_page ); else m_pagesData.Insert( position, nb_page ); m_pages.Insert(win, position); // set the label image and text // this must be done before adding the page, as GetPageText // and GetPageImage will otherwise return wrong values in // the page-changed event that results from inserting the // first page. nb_page->m_image = imageId; nb_page->m_text = wxStripMenuCodes(text); nb_page->m_box = gtk_hbox_new( FALSE, 1 ); gtk_container_set_border_width((GtkContainer*)nb_page->m_box, 2); g_signal_connect (win->m_widget, "size_allocate", G_CALLBACK (gtk_page_size_callback), win); gtk_notebook_insert_page(notebook, win->m_widget, nb_page->m_box, position); nb_page->m_page = gtk_notebook_get_nth_page(notebook, position); if (imageId != -1) { wxASSERT( m_imageList != NULL ); const wxBitmap *bmp = m_imageList->GetBitmapPtr(imageId); GtkWidget* pixmapwid = gtk_image_new_from_pixbuf(bmp->GetPixbuf()); gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding); gtk_widget_show(pixmapwid); } /* set the label text */ nb_page->m_label = GTK_LABEL( gtk_label_new(wxGTK_CONV(nb_page->m_text)) ); gtk_box_pack_end( GTK_BOX(nb_page->m_box), GTK_WIDGET(nb_page->m_label), FALSE, FALSE, m_padding ); /* apply current style */ GtkRcStyle *style = CreateWidgetStyle(); if ( style ) { gtk_widget_modify_style(GTK_WIDGET(nb_page->m_label), style); gtk_rc_style_unref(style); } /* show the label */ gtk_widget_show( GTK_WIDGET(nb_page->m_label) ); if (select && (m_pagesData.GetCount() > 1)) { SetSelection( position ); } InvalidateBestSize(); return true; }
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase) { wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase); GSList* radioGroup; GtkWidget* bin_child; switch ( tool->GetStyle() ) { case wxTOOL_STYLE_BUTTON: switch (tool->GetKind()) { case wxITEM_CHECK: tool->m_item = gtk_toggle_tool_button_new(); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; case wxITEM_RADIO: radioGroup = GetRadioGroup(pos); if (!radioGroup) { // this is the first button in the radio button group, // it will be toggled automatically by GTK so bring the // internal flag in sync tool->Toggle(true); } tool->m_item = gtk_radio_tool_button_new(radioGroup); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; default: wxFAIL_MSG("unknown toolbar child type"); // fall through case wxITEM_DROPDOWN: case wxITEM_NORMAL: tool->m_item = gtk_tool_button_new(NULL, ""); g_signal_connect(tool->m_item, "clicked", G_CALLBACK(item_clicked), tool); break; } if (!HasFlag(wxTB_NOICONS)) { GtkWidget* image = gtk_image_new(); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(tool->m_item), image); tool->SetImage(); gtk_widget_show(image); #ifdef __WXGTK3__ g_signal_connect(image, "draw", G_CALLBACK(image_draw), tool); #else g_signal_connect(image, "expose_event", G_CALLBACK(image_expose_event), tool); #endif } if (!tool->GetLabel().empty()) { gtk_tool_button_set_label( GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel())); // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT gtk_tool_item_set_is_important(tool->m_item, true); } if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty()) { #if GTK_CHECK_VERSION(2, 12, 0) if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL) { gtk_tool_item_set_tooltip_text(tool->m_item, wxGTK_CONV(tool->GetShortHelp())); } else #endif { #ifndef __WXGTK3__ gtk_tool_item_set_tooltip(tool->m_item, m_tooltips, wxGTK_CONV(tool->GetShortHelp()), ""); #endif } } bin_child = gtk_bin_get_child(GTK_BIN(tool->m_item)); g_signal_connect(bin_child, "button_press_event", G_CALLBACK(button_press_event), tool); g_signal_connect(bin_child, "enter_notify_event", G_CALLBACK(enter_notify_event), tool); g_signal_connect(bin_child, "leave_notify_event", G_CALLBACK(enter_notify_event), tool); if (tool->GetKind() == wxITEM_DROPDOWN) tool->CreateDropDown(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_SEPARATOR: tool->m_item = gtk_separator_tool_item_new(); if ( tool->IsStretchable() ) { gtk_separator_tool_item_set_draw ( GTK_SEPARATOR_TOOL_ITEM(tool->m_item), FALSE ); gtk_tool_item_set_expand(tool->m_item, TRUE); } gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_CONTROL: wxWindow* control = tool->GetControl(); if (gtk_widget_get_parent(control->m_widget) == NULL) AddChildGTK(control); tool->m_item = GTK_TOOL_ITEM(gtk_widget_get_parent(gtk_widget_get_parent(control->m_widget))); if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos)) { g_object_ref(tool->m_item); gtk_container_remove( GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item)); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); g_object_unref(tool->m_item); } break; } gtk_widget_show(GTK_WIDGET(tool->m_item)); InvalidateBestSize(); return true; }
void wxStaticBitmap::SetImage( const wxGDIImage* image ) { wxGDIImage* convertedImage = ConvertImage( *image ); SetImageNoCopy( convertedImage ); InvalidateBestSize(); }
void wxControlBase::SetLabel( const wxString &label ) { InvalidateBestSize(); wxWindow::SetLabel(label); }
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase) { wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase); GSList* radioGroup; switch ( tool->GetStyle() ) { case wxTOOL_STYLE_BUTTON: switch (tool->GetKind()) { case wxITEM_CHECK: tool->m_item = gtk_toggle_tool_button_new(); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; case wxITEM_RADIO: radioGroup = GetRadioGroup(pos); if (radioGroup) { // this is the first button in the radio button group, // it will be toggled automatically by GTK so bring the // internal flag in sync tool->Toggle(true); } tool->m_item = gtk_radio_tool_button_new(radioGroup); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; default: wxFAIL_MSG("unknown toolbar child type"); // fall through case wxITEM_DROPDOWN: case wxITEM_NORMAL: tool->m_item = gtk_tool_button_new(NULL, ""); g_signal_connect(tool->m_item, "clicked", G_CALLBACK(item_clicked), tool); break; } if (!HasFlag(wxTB_NOICONS)) { GtkWidget* image = gtk_image_new(); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(tool->m_item), image); tool->SetImage(); gtk_widget_show(image); g_signal_connect(image, "expose_event", G_CALLBACK(image_expose_event), tool); } if (!tool->GetLabel().empty()) { gtk_tool_button_set_label( GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel())); // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT gtk_tool_item_set_is_important(tool->m_item, true); } if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty()) { gtk_tool_item_set_tooltip(tool->m_item, m_tooltips, wxGTK_CONV(tool->GetShortHelp()), ""); } g_signal_connect(GTK_BIN(tool->m_item)->child, "button_press_event", G_CALLBACK(button_press_event), tool); g_signal_connect(tool->m_item, "enter_notify_event", G_CALLBACK(enter_notify_event), tool); g_signal_connect(tool->m_item, "leave_notify_event", G_CALLBACK(enter_notify_event), tool); if (tool->GetKind() == wxITEM_DROPDOWN) tool->CreateDropDown(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_SEPARATOR: tool->m_item = gtk_separator_tool_item_new(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_CONTROL: wxWindow* control = tool->GetControl(); if (control->m_widget->parent == NULL) AddChildGTK(control); tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent); if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos)) { g_object_ref(tool->m_item); gtk_container_remove( GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item)); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); g_object_unref(tool->m_item); } // Inserted items "slide" into place using an animated effect that // causes multiple size events on the item. Must set size request // to keep item size from getting permanently set too small by the // first of these size events. const wxSize size = control->GetSize(); gtk_widget_set_size_request(control->m_widget, size.x, size.y); break; } gtk_widget_show(GTK_WIDGET(tool->m_item)); InvalidateBestSize(); return true; }
void wxAnyButton::DoSetBitmapPosition(wxDirection dir) { GetPeer()->SetBitmapPosition(dir); InvalidateBestSize(); }
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase) { wxToolBarTool *tool = (wxToolBarTool *)toolBase; // if we have inserted a space before all the tools we must change the GTK // index by 1 size_t posGtk = m_xMargin > 1 ? pos + 1 : pos; if ( tool->IsButton() ) { if ( !HasFlag(wxTB_NOICONS) ) { wxBitmap bitmap = tool->GetNormalBitmap(); wxCHECK_MSG( bitmap.Ok(), false, wxT("invalid bitmap for wxToolBar icon") ); wxCHECK_MSG( bitmap.GetBitmap() == NULL, false, wxT("wxToolBar doesn't support GdkBitmap") ); wxCHECK_MSG( bitmap.GetPixmap() != NULL, false, wxT("wxToolBar::Add needs a wxBitmap") ); GtkWidget *tool_pixmap = (GtkWidget *)NULL; GdkPixmap *pixmap = bitmap.GetPixmap(); GdkBitmap *mask = (GdkBitmap *)NULL; if ( bitmap.GetMask() ) mask = bitmap.GetMask()->GetBitmap(); tool_pixmap = gtk_pixmap_new( pixmap, mask ); gtk_pixmap_set_build_insensitive( GTK_PIXMAP(tool_pixmap), TRUE ); gtk_misc_set_alignment( GTK_MISC(tool_pixmap), 0.5, 0.5 ); tool->m_pixmap = tool_pixmap; } } switch ( tool->GetStyle() ) { case wxTOOL_STYLE_BUTTON: // for a radio button we need the widget which starts the radio // group it belongs to, i.e. the first radio button immediately // preceding this one { GtkWidget *widget = NULL; if ( tool->IsRadio() ) { wxToolBarToolsList::compatibility_iterator node = wxToolBarToolsList::compatibility_iterator(); if ( pos ) node = m_tools.Item(pos - 1); while ( node ) { wxToolBarTool *toolNext = (wxToolBarTool *)node->GetData(); if ( !toolNext->IsRadio() ) break; widget = toolNext->m_item; node = node->GetPrevious(); } if ( !widget ) { // this is the first button in the radio button group, // it will be toggled automatically by GTK so bring the // internal flag in sync tool->Toggle(true); } } tool->m_item = gtk_toolbar_insert_element ( m_toolbar, tool->GetGtkChildType(), widget, tool->GetLabel().empty() ? NULL : (const char*) wxGTK_CONV( tool->GetLabel() ), tool->GetShortHelp().empty() ? NULL : (const char*) wxGTK_CONV( tool->GetShortHelp() ), "", // tooltip_private_text (?) tool->m_pixmap, (GtkSignalFunc)gtk_toolbar_callback, (gpointer)tool, posGtk ); if ( !tool->m_item ) { wxFAIL_MSG( _T("gtk_toolbar_insert_element() failed") ); return false; } gtk_signal_connect( GTK_OBJECT(tool->m_item), "enter_notify_event", GTK_SIGNAL_FUNC(gtk_toolbar_tool_callback), (gpointer)tool ); gtk_signal_connect( GTK_OBJECT(tool->m_item), "leave_notify_event", GTK_SIGNAL_FUNC(gtk_toolbar_tool_callback), (gpointer)tool ); } break; case wxTOOL_STYLE_SEPARATOR: gtk_toolbar_insert_space( m_toolbar, posGtk ); // skip the rest return true; case wxTOOL_STYLE_CONTROL: gtk_toolbar_insert_widget( m_toolbar, tool->GetControl()->m_widget, (const char *) NULL, (const char *) NULL, posGtk ); break; } GtkRequisition req; (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(m_widget) )->size_request ) (m_widget, &req ); m_width = req.width + m_xMargin; m_height = req.height + 2*m_yMargin; InvalidateBestSize(); return true; }
// same as AddPage() but does it at given position bool wxNotebook::InsertPage(size_t nPage, wxNotebookPage *pPage, const wxString& strText, bool bSelect, int imageId) { wxCHECK_MSG( pPage != NULL, false, wxT("NULL page in wxNotebook::InsertPage") ); wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false, wxT("invalid index in wxNotebook::InsertPage") ); wxASSERT_MSG( pPage->GetParent() == this, wxT("notebook pages must have notebook as parent") ); // add a new tab to the control // ---------------------------- // init all fields to 0 TC_ITEM tcItem; wxZeroMemory(tcItem); // set the image, if any if ( imageId != -1 ) { tcItem.mask |= TCIF_IMAGE; tcItem.iImage = imageId; } // and the text if ( !strText.empty() ) { tcItem.mask |= TCIF_TEXT; tcItem.pszText = const_cast<wxChar *>(strText.wx_str()); } // hide the page: unless it is selected, it shouldn't be shown (and if it // is selected it will be shown later) HWND hwnd = GetWinHwnd(pPage); SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE); // this updates internal flag too -- otherwise it would get out of sync // with the real state pPage->Show(false); // fit the notebook page to the tab control's display area: this should be // done before adding it to the notebook or TabCtrl_InsertItem() will // change the notebooks size itself! AdjustPageSize(pPage); // finally do insert it if ( TabCtrl_InsertItem(GetHwnd(), nPage, &tcItem) == -1 ) { wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str()); return false; } // need to update the bg brush when the first page is added // so the first panel gets the correct themed background if ( m_pages.empty() ) { #if wxUSE_UXTHEME UpdateBgBrush(); #endif // wxUSE_UXTHEME } // succeeded: save the pointer to the page m_pages.Insert(pPage, nPage); // we may need to adjust the size again if the notebook size changed: // normally this only happens for the first page we add (the tabs which // hadn't been there before are now shown) but for a multiline notebook it // can happen for any page at all as a new row could have been started if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) ) { AdjustPageSize(pPage); } // now deal with the selection // --------------------------- // if the inserted page is before the selected one, we must update the // index of the selected page if ( int(nPage) <= m_selection ) { // one extra page added m_selection++; } DoSetSelectionAfterInsertion(nPage, bSelect); InvalidateBestSize(); return true; }
// // Same as AddPage() but does it at given position // bool wxNotebook::InsertPage ( size_t nPage, wxNotebookPage* pPage, const wxString& rsStrText, bool bSelect, int nImageId ) { ULONG ulApiPage; wxASSERT( pPage != NULL ); wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false ); // // Under OS/2 we can only insert FIRST, LAST, NEXT or PREV. Requires // two different calls to the API. Page 1 uses the BKA_FIRST. Subsequent // pages use the previous page ID coupled with a BKA_NEXT call. Unlike // Windows, OS/2 uses an internal Page ID to ID the pages. // // OS/2 also has a nice auto-size feature that automatically sizes the // the attached window so we don't have to worry about the size of the // window on the page. // if (nPage == 0) { ulApiPage = LONGFROMMR(::WinSendMsg( GetHWND() ,BKM_INSERTPAGE ,(MPARAM)0 ,MPFROM2SHORT(BKA_AUTOPAGESIZE | BKA_MAJOR, BKA_FIRST) )); if (ulApiPage == 0L) { ERRORID vError; wxString sError; vError = ::WinGetLastError(vHabmain); sError = wxPMErrorToStr(vError); return false; } m_alPageId.Insert((long)ulApiPage, nPage); } else { ulApiPage = LONGFROMMR(::WinSendMsg( GetHWND() ,BKM_INSERTPAGE ,MPFROMLONG((ULONG)m_alPageId[nPage - 1]) ,MPFROM2SHORT(BKA_AUTOPAGESIZE | BKA_MAJOR, BKA_NEXT) )); if (ulApiPage == 0L) { ERRORID vError; wxString sError; vError = ::WinGetLastError(vHabmain); sError = wxPMErrorToStr(vError); return false; } m_alPageId.Insert((long)ulApiPage, nPage); } // // Associate a window handle with the page // if (pPage) { if (!::WinSendMsg( GetHWND() ,BKM_SETPAGEWINDOWHWND ,MPFROMLONG((ULONG)m_alPageId[nPage]) ,MPFROMHWND(pPage->GetHWND()) )) return false; } // // If the inserted page is before the selected one, we must update the // index of the selected page // if (nPage <= (size_t)m_nSelection) { // // One extra page added // m_nSelection++; } if (pPage) { // // Save the pointer to the page // m_pages.Insert( pPage ,nPage ); } // // Now set TAB dimenstions // wxWindowDC vDC(this); wxCoord nTextX; wxCoord nTextY; vDC.GetTextExtent(rsStrText, &nTextX, &nTextY); nTextY *= 2; nTextX = (wxCoord)(nTextX * 1.3); if (nTextX > m_nTabSize) { m_nTabSize = nTextX; ::WinSendMsg( GetHWND() ,BKM_SETDIMENSIONS ,MPFROM2SHORT((USHORT)m_nTabSize, (USHORT)nTextY) ,(MPARAM)BKA_MAJORTAB ); } // // Now set any TAB text // if (!rsStrText.empty()) { if (!SetPageText( nPage ,rsStrText )) return false; } // // Now set any TAB bitmap image // if (nImageId != -1) { if (!SetPageImage( nPage ,nImageId )) return false; } if (pPage) { // // Don't show pages by default (we'll need to adjust their size first) // HWND hWnd = GetWinHwnd(pPage); WinSetWindowULong( hWnd ,QWL_STYLE ,WinQueryWindowULong( hWnd ,QWL_STYLE ) & ~WS_VISIBLE ); // // This updates internal flag too - otherwise it will get out of sync // pPage->Show(false); } // // Some page should be selected: either this one or the first one if there is // still no selection // int nSelNew = -1; if (bSelect) nSelNew = nPage; else if ( m_nSelection == -1 ) nSelNew = 0; if (nSelNew != -1) SetSelection(nSelNew); InvalidateBestSize(); return true; } // end of wxNotebook::InsertPage
void wxNotebook::OnSize(wxSizeEvent& event) { if ( GetPageCount() == 0 ) { // Prevents droppings on resize, but does cause some flicker // when there are no pages. Refresh(); event.Skip(); return; } #ifndef __WXWINCE__ else { // Without this, we can sometimes get droppings at the edges // of a notebook, for example a notebook in a splitter window. // This needs to be reconciled with the RefreshRect calls // at the end of this function, which weren't enough to prevent // the droppings. wxSize sz = GetClientSize(); // Refresh right side wxRect rect(sz.x-4, 0, 4, sz.y); RefreshRect(rect); // Refresh bottom side rect = wxRect(0, sz.y-4, sz.x, 4); RefreshRect(rect); // Refresh left side rect = wxRect(0, 0, 4, sz.y); RefreshRect(rect); } #endif // !__WXWINCE__ // fit all the notebook pages to the tab control's display area RECT rc; rc.left = rc.top = 0; GetSize((int *)&rc.right, (int *)&rc.bottom); // save the total size, we'll use it below int widthNbook = rc.right - rc.left, heightNbook = rc.bottom - rc.top; // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it // returns completely false values for multiline tab controls after the tabs // are added but before getting the first WM_SIZE (off by ~50 pixels, see // // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863 // // and the only work around I could find was this ugly hack... without it // simply toggling the "multiline" checkbox in the notebook sample resulted // in a noticeable page displacement if ( HasFlag(wxNB_MULTILINE) ) { // avoid an infinite recursion: we get another notification too! static bool s_isInOnSize = false; if ( !s_isInOnSize ) { s_isInOnSize = true; SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED, MAKELPARAM(rc.right, rc.bottom)); s_isInOnSize = false; } // The best size depends on the number of rows of tabs, which can // change when the notepad is resized. InvalidateBestSize(); } #if wxUSE_UXTHEME // background bitmap size has changed, update the brush using it too UpdateBgBrush(); #endif // wxUSE_UXTHEME TabCtrl_AdjustRect(GetHwnd(), false, &rc); int width = rc.right - rc.left, height = rc.bottom - rc.top; size_t nCount = m_pages.Count(); for ( size_t nPage = 0; nPage < nCount; nPage++ ) { wxNotebookPage *pPage = m_pages[nPage]; pPage->SetSize(rc.left, rc.top, width, height); } // unless we had already repainted everything, we now need to refresh if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) ) { // invalidate areas not covered by pages RefreshRect(wxRect(0, 0, widthNbook, rc.top), false); RefreshRect(wxRect(0, rc.top, rc.left, height), false); RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom), false); RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height), false); } #if USE_NOTEBOOK_ANTIFLICKER // subclass the spin control used by the notebook to scroll pages to // prevent it from flickering on resize if ( !m_hasSubclassedUpdown ) { // iterate over all child windows to find spin button for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD); child; child = ::GetWindow(child, GW_HWNDNEXT) ) { wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child); // see if it exists, if no wxWindow found then assume it's the spin // btn if ( !childWindow ) { // subclass the spin button to override WM_ERASEBKGND if ( !gs_wndprocNotebookSpinBtn ) gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child); wxSetWindowProc(child, wxNotebookSpinBtnWndProc); m_hasSubclassedUpdown = true; break; } } } // Probably because of the games we play above to avoid flicker sometimes // the text controls inside notebook pages are not shown correctly (they // don't have their borders) when the notebook is shown for the first time. // It's not really clear why does this happen and maybe the bug is in // wxTextCtrl itself and not here but updating the page when it's about to // be shown doesn't cost much and works around the problem so do it here // for now. if ( !m_doneUpdateHack && IsShownOnScreen() ) { m_doneUpdateHack = true; wxWindow* const page = GetCurrentPage(); if ( page ) page->Update(); } #endif // USE_NOTEBOOK_ANTIFLICKER event.Skip(); }
int wxChoice::GtkAddHelper(GtkWidget *menu, unsigned int pos, const wxString& item) { wxCHECK_MSG(pos<=m_clientList.GetCount(), -1, wxT("invalid index")); GtkWidget *menu_item = gtk_menu_item_new_with_label( wxGTK_CONV( item ) ); size_t index; if ( m_strings ) { // sorted control, need to insert at the correct index index = m_strings->Add(item); gtk_menu_insert( GTK_MENU(menu), menu_item, index ); if ( index ) { m_clientList.Insert( m_clientList.Item(index - 1), NULL ); } else { m_clientList.Insert( NULL ); } } else { // don't call wxChoice::GetCount() from here because it doesn't work // if we're called from ctor (and GtkMenuShell is still NULL) // normal control, just append if (pos == m_clientList.GetCount()) { gtk_menu_append( GTK_MENU(menu), menu_item ); m_clientList.Append( NULL ); index = m_clientList.GetCount() - 1; } else { gtk_menu_insert( GTK_MENU(menu), menu_item, pos ); m_clientList.Insert( pos, NULL ); index = pos; } } if (GTK_WIDGET_REALIZED(m_widget)) { gtk_widget_realize( menu_item ); gtk_widget_realize( GTK_BIN(menu_item)->child ); ApplyWidgetStyle(); } // The best size of a wxChoice should probably // be changed everytime the control has been // changed, but at least after adding an item // it has to change. Adapted from Matt Ownby. InvalidateBestSize(); gtk_signal_connect_after( GTK_OBJECT( menu_item ), "activate", GTK_SIGNAL_FUNC(gtk_choice_clicked_callback), (gpointer*)this ); gtk_widget_show( menu_item ); // return the index of the item in the control return index; }
void ShareProperties::CreateControls() { ////@begin ShareProperties content construction if (!wxXmlResource::Get()->LoadDialog(this, GetParent(), _T("ID_DIALOG_SHARE_ADD"))) wxLogError(wxT("Missing wxXmlResource::Get()->Load() in OnInit()?")); m_pCtrlLocalShares = XRCCTRL(*this, "ID_COMBOBOX_SHARE_LOCALNAME", wxBitmapComboBox); m_pCtrlSmbPrintOptions = XRCCTRL(*this, "ID_PANEL_SMB_PRINTER", wxPanel); m_pCtrlSmbDriver = XRCCTRL(*this, "ID_COMBOBOX_SMBDRIVER", wxComboBox); m_pCtrlSmbPrivate = XRCCTRL(*this, "ID_RADIOBUTTON_SMB_PRIVATE", wxRadioButton); m_pCtrlSmbPublic = XRCCTRL(*this, "ID_RADIOBUTTON_SMB_PUBLIC", wxRadioButton); m_pCtrlSmbPrintUsername = XRCCTRL(*this, "ID_TEXTCTRL_SMBPRINT_USERNAME", wxTextCtrl); m_pCtrlSmbPrintPassword = XRCCTRL(*this, "ID_TEXTCTRL_SMBPRINT_PASSWORD", wxTextCtrl); m_pCtrlCupsOptions = XRCCTRL(*this, "ID_PANEL_CUPSOPTIONS", wxPanel); m_pCtrlCupsPrivate = XRCCTRL(*this, "ID_RADIOBUTTON_CUPS_PRIVATE", wxRadioButton); m_pCtrlCupsPublic = XRCCTRL(*this, "ID_RADIOBUTTON_CUPS_PUBLIC", wxRadioButton); m_pCtrlUsbOptions = XRCCTRL(*this, "ID_PANEL_USBIP", wxPanel); m_pCtrlSmbDiskOptions = XRCCTRL(*this, "ID_PANEL_SMBOPTIONS", wxPanel); m_pCtrlMountPoint = XRCCTRL(*this, "ID_TEXTCTRL_SHARE_MOUNTPOINT", wxTextCtrl); m_pCtrlUsername = XRCCTRL(*this, "ID_TEXTCTRL_SHARE_USERNAME", wxTextCtrl); m_pCtrlPassword = XRCCTRL(*this, "ID_TEXTCTRL_SHARE_PASSWORD", wxTextCtrl); // Set validators if (FindWindow(XRCID("ID_COMBOBOX_SMBDRIVER"))) FindWindow(XRCID("ID_COMBOBOX_SMBDRIVER"))->SetValidator( wxGenericValidator(& m_sSmbDriver) ); if (FindWindow(XRCID("ID_RADIOBUTTON_SMB_PUBLIC"))) FindWindow(XRCID("ID_RADIOBUTTON_SMB_PUBLIC"))->SetValidator( wxGenericValidator(& m_bSmbPublic) ); if (FindWindow(XRCID("ID_TEXTCTRL_SMBPRINT_USERNAME"))) FindWindow(XRCID("ID_TEXTCTRL_SMBPRINT_USERNAME"))->SetValidator( MyValidator(& m_sSmbPrintUsername) ); if (FindWindow(XRCID("ID_TEXTCTRL_SMBPRINT_PASSWORD"))) FindWindow(XRCID("ID_TEXTCTRL_SMBPRINT_PASSWORD"))->SetValidator( MyValidator(& m_sSmbPrintPassword) ); if (FindWindow(XRCID("ID_COMBOBOX_CUPSDRIVER"))) FindWindow(XRCID("ID_COMBOBOX_CUPSDRIVER"))->SetValidator( wxGenericValidator(& m_sCupsDriver) ); if (FindWindow(XRCID("ID_RADIOBUTTON_CUPS_PUBLIC"))) FindWindow(XRCID("ID_RADIOBUTTON_CUPS_PUBLIC"))->SetValidator( wxGenericValidator(& m_bCupsPublic) ); if (FindWindow(XRCID("ID_TEXTCTRL_SHARE_MOUNTPOINT"))) FindWindow(XRCID("ID_TEXTCTRL_SHARE_MOUNTPOINT"))->SetValidator( MyValidator(& m_sMountPoint) ); if (FindWindow(XRCID("ID_TEXTCTRL_SHARE_USERNAME"))) FindWindow(XRCID("ID_TEXTCTRL_SHARE_USERNAME"))->SetValidator( MyValidator(& m_sSmbDiskUsername) ); if (FindWindow(XRCID("ID_TEXTCTRL_SHARE_PASSWORD"))) FindWindow(XRCID("ID_TEXTCTRL_SHARE_PASSWORD"))->SetValidator( MyValidator(& m_sSmbDiskPassword) ); ////@end ShareProperties content construction // Create custom windows not generated automatically here. ////@begin ShareProperties content initialisation ////@end ShareProperties content initialisation int minw = 0; int minh = 0; int w, h; m_pCtrlSmbDiskOptions->Show(false); m_pCtrlSmbPrintOptions->Show(true); m_pCtrlCupsOptions->Show(false); InvalidateBestSize(); Layout(); m_pCtrlSmbPrintOptions->SetMinSize(m_pCtrlSmbPrintOptions->GetBestSize()); GetBestSize(&minw, &minh); m_pCtrlSmbDiskOptions->Show(false); m_pCtrlSmbPrintOptions->Show(false); m_pCtrlCupsOptions->Show(true); InvalidateBestSize(); Layout(); m_pCtrlCupsOptions->SetMinSize(m_pCtrlSmbDiskOptions->GetBestSize()); GetBestSize(&w, &h); if (w > minw) minw = w; if (h > minh) minh = h; m_pCtrlCupsOptions->Show(false); m_pCtrlSmbDiskOptions->Show(true); m_pCtrlSmbPrintOptions->Show(false); InvalidateBestSize(); Layout(); m_pCtrlSmbDiskOptions->SetMinSize(m_pCtrlSmbPrintOptions->GetBestSize()); GetBestSize(&w, &h); if (w > minw) minw = w; if (h > minh) minh = h; SetMinSize(wxSize(minw, minh)); if (m_iCurrentShare != -1) { ShareGroup sg = m_pCfg->aGetShareGroups().Item(m_iCurrentShare); wxBitmap bm = wxNullBitmap; m_pCtrlLocalShares->Append(sg.m_sShareName, bm, &sg); m_pCtrlLocalShares->SetSelection(0); m_pCtrlLocalShares->Enable(false); SetTitle(_("Modify shared resource - OpenNX")); switch (sg.m_eType) { case SharedResource::SHARE_UNKNOWN: break; case SharedResource::SHARE_SMB_DISK: m_pCtrlCupsOptions->Show(false); m_pCtrlSmbPrintOptions->Show(false); m_pCtrlSmbDiskOptions->Show(true); m_sMountPoint = sg.m_sAlias; m_sSmbDiskUsername = sg.m_sUsername; if (m_sSmbDiskUsername.IsEmpty()) m_sSmbDiskUsername = ::wxGetUserId(); m_sSmbDiskPassword = sg.m_sPassword; Layout(); break; case SharedResource::SHARE_SMB_PRINTER: m_pCtrlCupsOptions->Show(false); m_pCtrlSmbDiskOptions->Show(false); m_pCtrlSmbPrintOptions->Show(true); m_sSmbDriver = sg.m_sDriver; m_sSmbPrintUsername = sg.m_sUsername; if (m_sSmbPrintUsername.IsEmpty()) m_sSmbPrintUsername = ::wxGetUserId(); m_sSmbPrintPassword = sg.m_sPassword; if (sg.m_bPublic) m_pCtrlSmbPublic->SetValue(true); else m_pCtrlSmbPrivate->SetValue(true); Layout(); break; case SharedResource::SHARE_CUPS_PRINTER: m_pCtrlSmbPrintOptions->Show(false); m_pCtrlSmbDiskOptions->Show(false); m_pCtrlCupsOptions->GetSizer()->Layout(); m_pCtrlCupsOptions->Show(true); if (sg.m_bPublic) m_pCtrlCupsPublic->SetValue(true); else m_pCtrlCupsPrivate->SetValue(true); Layout(); break; } m_pCtrlMountPoint->SetValue(m_sMountPoint); } else { // Fetch list of shares if (m_bUseSmb) { SmbClient sc; m_aShares = sc.GetShares(); } if (m_bUseCups) { CupsClient cc; ArrayOfShares cupsShares = cc.GetShares(); WX_APPEND_ARRAY(m_aShares, cupsShares); } // Apparently, wxGTK (perhaps GTK itself) has a bug which // results in data pointers not being associated properly to the // ComboBox, if that ComboBox is sorted (wxCB_SORT attribute). // As a woraround, we use an *unsorted* ComboBox and sort the // shares before adding them to the ComboBox. m_aShares.Sort(cmpshares); // Build ComboBox content for (size_t i = 0; i < m_aShares.GetCount(); i++) { wxBitmap bm; switch (m_aShares[i].sharetype) { case SharedResource::SHARE_SMB_DISK: bm = GetBitmapResource(wxT("res/smbfolder.png")); break; case SharedResource::SHARE_SMB_PRINTER: bm = GetBitmapResource(wxT("res/smbprinter.png")); break; case SharedResource::SHARE_CUPS_PRINTER: bm = GetBitmapResource(wxT("res/cupsprinter.png")); break; default: bm = wxNullBitmap; break; } m_pCtrlLocalShares->Append(m_aShares[i].name, bm, m_aShares[i].GetThisVoid()); } if (m_aShares.GetCount() > 0) { // Select first element of ComboBox m_pCtrlLocalShares->SetSelection(0); SharedResource *res = wxDynamicCast(m_pCtrlLocalShares->GetClientData(0), SharedResource); wxASSERT(res); switch (res->sharetype) { case SharedResource::SHARE_UNKNOWN: break; case SharedResource::SHARE_SMB_DISK: m_pCtrlSmbPrintOptions->Show(false); m_pCtrlCupsOptions->Show(false); m_pCtrlSmbDiskOptions->Show(true); m_sMountPoint = wxT("$(SHARES)/") + res->name; Layout(); break; case SharedResource::SHARE_SMB_PRINTER: m_pCtrlSmbDiskOptions->Show(false); m_pCtrlCupsOptions->Show(false); m_pCtrlSmbPrintOptions->Show(true); m_sSmbDriver = wxT("laserjet"); Layout(); break; case SharedResource::SHARE_CUPS_PRINTER: m_pCtrlSmbDiskOptions->Show(false); m_pCtrlSmbPrintOptions->Show(false); m_pCtrlCupsOptions->Show(true); Layout(); break; } } else { wxLogMessage(_("No shares found")); m_pCtrlLocalShares->Enable(false); m_pCtrlMountPoint->Enable(false); m_pCtrlUsername->Enable(false); m_pCtrlPassword->Enable(false); } } }