void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) ) { wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") ); }
wxSizerItem* wxGridBagSizer::Prepend( wxWindow *, int, int, int, wxObject* ) { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); return NULL; }
wxSizerItem* wxGridBagSizer::Insert( size_t, wxSizerItem * ) { wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); return NULL; }
void wxScrollBar::MacHandleControlClick( WXWidget control , wxInt16 controlpart , bool mouseStillDown ) { if ( (ControlHandle) m_macControl == NULL ) return ; int position = GetControl32BitValue( (ControlHandle) m_macControl) ; int minPos = GetControl32BitMinimum( (ControlHandle) m_macControl) ; int maxPos = GetControl32BitMaximum( (ControlHandle) m_macControl) ; wxEventType scrollEvent = wxEVT_NULL; int nScrollInc = 0; // all events have already been reported during mouse down, except for THUMBRELEASE if ( !mouseStillDown && controlpart !=kControlIndicatorPart ) return ; switch( controlpart ) { case kControlUpButtonPart : nScrollInc = -1; scrollEvent = wxEVT_SCROLL_LINEUP; break ; case kControlDownButtonPart : nScrollInc = 1; scrollEvent = wxEVT_SCROLL_LINEDOWN; break ; case kControlPageUpPart : nScrollInc = -m_pageSize; scrollEvent = wxEVT_SCROLL_PAGEUP; break ; case kControlPageDownPart : nScrollInc = m_pageSize; scrollEvent = wxEVT_SCROLL_PAGEDOWN; break ; case kControlIndicatorPart : nScrollInc = 0 ; if ( mouseStillDown ) scrollEvent = wxEVT_SCROLL_THUMBTRACK; else scrollEvent = wxEVT_SCROLL_THUMBRELEASE; break ; default : wxFAIL_MSG(wxT("illegal scrollbar selector")); break ; } int new_pos = position + nScrollInc; if (new_pos < minPos) new_pos = minPos; if (new_pos > maxPos) new_pos = maxPos; if ( nScrollInc ) SetThumbPosition(new_pos); wxScrollEvent event(scrollEvent, m_windowId); if ( m_windowStyle & wxHORIZONTAL ) { event.SetOrientation( wxHORIZONTAL ) ; } else { event.SetOrientation( wxVERTICAL ) ; } event.SetPosition(new_pos); event.SetEventObject( this ); wxWindow* window = GetParent() ; if (window && window->MacIsWindowScrollbar(this) ) { // this is hardcoded window->MacOnScroll(event); } else GetEventHandler()->ProcessEvent(event); }
bool wxButton::Create(wxWindow *parent, wxWindowID id, const wxString &label, const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator, const wxString& name) { if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxButton creation failed") ); return false; } // create either a standard button with text label (which may still contain // an image under GTK+ 2.6+) or a bitmap-only button if we don't have any // label const bool useLabel = !(style & wxBU_NOTEXT) && (!label.empty() || wxIsStockID(id)); if ( useLabel ) { m_widget = gtk_button_new_with_mnemonic(""); } else // no label, suppose we will have a bitmap { m_widget = gtk_button_new(); GtkWidget *image = gtk_image_new(); gtk_widget_show(image); gtk_container_add(GTK_CONTAINER(m_widget), image); } g_object_ref(m_widget); float x_alignment = 0.5; if (HasFlag(wxBU_LEFT)) x_alignment = 0.0; else if (HasFlag(wxBU_RIGHT)) x_alignment = 1.0; float y_alignment = 0.5; if (HasFlag(wxBU_TOP)) y_alignment = 0.0; else if (HasFlag(wxBU_BOTTOM)) y_alignment = 1.0; gtk_button_set_alignment(GTK_BUTTON(m_widget), x_alignment, y_alignment); if ( useLabel ) SetLabel(label); if (style & wxNO_BORDER) gtk_button_set_relief( GTK_BUTTON(m_widget), GTK_RELIEF_NONE ); g_signal_connect_after (m_widget, "clicked", G_CALLBACK (wxgtk_button_clicked_callback), this); g_signal_connect_after (m_widget, "style_set", G_CALLBACK (wxgtk_button_style_set_callback), this); m_parent->DoAddChild( this ); PostCreation(size); return true; }
void wxPen::SetStipple(const wxBitmap& WXUNUSED(stipple)) { wxFAIL_MSG( "stippled pens not supported" ); }
wxImage wxDIB::ConvertToImage() const { wxCHECK_MSG( IsOk(), wxNullImage, wxT("can't convert invalid DIB to wxImage") ); // create the wxImage object const int w = GetWidth(); const int h = GetHeight(); wxImage image(w, h, false /* don't bother clearing memory */); if ( !image.IsOk() ) { wxFAIL_MSG( wxT("could not allocate data for image") ); return wxNullImage; } const int bpp = GetDepth(); // Remember if we have any "real" transparency, i.e. either any partially // transparent pixels or not all pixels are fully opaque or fully // transparent. bool hasAlpha = false; bool hasOpaque = false; bool hasTransparent = false; if ( bpp == 32 ) { // 32 bit bitmaps may be either 0RGB or ARGB and we don't know in // advance which one do we have so suppose we have alpha of them and // get rid of it later if it turns out we didn't. image.SetAlpha(); } // this is the same loop as in Create() just above but with copy direction // reversed const int dstBytesPerLine = w * 3; const int srcBytesPerLine = GetLineSize(w, bpp); unsigned char *dst = image.GetData() + ((h - 1) * dstBytesPerLine); unsigned char *alpha = image.HasAlpha() ? image.GetAlpha() + (h - 1)*w : NULL; const unsigned char *srcLineStart = (unsigned char *)GetData(); for ( int y = 0; y < h; y++ ) { // copy one DIB line const unsigned char *src = srcLineStart; for ( int x = 0; x < w; x++ ) { dst[2] = *src++; dst[1] = *src++; dst[0] = *src++; if ( bpp == 32 ) { // wxImage uses non premultiplied alpha so undo // premultiplication done in Create() above const unsigned char a = *src; *alpha++ = a; // Check what kind of alpha do we have. switch ( a ) { case 0: hasTransparent = true; break; default: // Anything in between means we have real transparency // and must use alpha channel. hasAlpha = true; break; case 255: hasOpaque = true; break; } if ( a > 0 ) { dst[0] = (dst[0] * 255) / a; dst[1] = (dst[1] * 255) / a; dst[2] = (dst[2] * 255) / a; } src++; } dst += 3; } // pass to the previous line in the image dst -= 2*dstBytesPerLine; if ( alpha ) alpha -= 2*w; // and to the next one in the DIB srcLineStart += srcBytesPerLine; } if ( hasOpaque && hasTransparent ) hasAlpha = true; if ( !hasAlpha && image.HasAlpha() ) image.ClearAlpha(); return image; }
wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message, const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard, long style, const wxPoint& pos, const wxSize& sz, const wxString& name) : wxGenericFileDialog(parent, message, defaultDir, defaultFileName, wildCard, style, pos, sz, name, true ) { if (gtk_check_version(2,4,0)) { wxGenericFileDialog::Create( parent, message, defaultDir, defaultFileName, wildCard, style, pos ); return; } m_needParent = false; if (!PreCreation(parent, pos, wxDefaultSize) || !CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style, wxDefaultValidator, wxT("filedialog"))) { wxFAIL_MSG( wxT("wxFileDialog creation failed") ); return; } GtkFileChooserAction gtk_action; GtkWindow* gtk_parent = NULL; if (parent) gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) ); const gchar* ok_btn_stock; if ( style & wxFD_SAVE ) { gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE; ok_btn_stock = GTK_STOCK_SAVE; } else { gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN; ok_btn_stock = GTK_STOCK_OPEN; } m_widget = gtk_file_chooser_dialog_new( wxGTK_CONV(m_message), gtk_parent, gtk_action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, ok_btn_stock, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT); if ( style & wxFD_MULTIPLE ) gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(m_widget), true); // gtk_widget_hide_on_delete is used here to avoid that Gtk automatically // destroys the dialog when the user press ESC on the dialog: in that case // a second call to ShowModal() would result in a bunch of Gtk-CRITICAL // errors... g_signal_connect (G_OBJECT(m_widget), "delete_event", G_CALLBACK (gtk_widget_hide_on_delete), (gpointer)this); // local-only property could be set to false to allow non-local files to be // loaded. In that case get/set_uri(s) should be used instead of // get/set_filename(s) everywhere and the GtkFileChooserDialog should // probably also be created with a backend, e.g "gnome-vfs", "default", ... // (gtk_file_chooser_dialog_new_with_backend). Currently local-only is kept // as the default - true: // gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true); g_signal_connect (m_widget, "response", G_CALLBACK (gtk_filedialog_response_callback), this); SetWildcard(wildCard); // if defaultDir is specified it should contain the directory and // defaultFileName should contain the default name of the file, however if // directory is not given, defaultFileName contains both wxFileName fn; if ( defaultDir.empty() ) fn.Assign(defaultFileName); else if ( !defaultFileName.empty() ) fn.Assign(defaultDir, defaultFileName); // set the initial file name and/or directory wxString fname = fn.GetFullName(); if ( fname.empty() ) { wxString dir = fn.GetPath(); if ( !dir.empty() ) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_widget), dir.fn_str()); } } if ( style & wxFD_SAVE ) { if ( !fname.empty() ) { gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(m_widget), fname.fn_str()); } #if GTK_CHECK_VERSION(2,7,3) if ((style & wxFD_OVERWRITE_PROMPT) && !gtk_check_version(2,7,3)) gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(m_widget), TRUE); #endif } else // wxFD_OPEN { if ( !fname.empty() ) { gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(m_widget), fn.GetFullPath().fn_str()); } } #if GTK_CHECK_VERSION(2,4,0) if ( style & wxFD_PREVIEW ) { GtkWidget *previewImage = gtk_image_new(); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(m_widget), previewImage); g_signal_connect(m_widget, "update-preview", G_CALLBACK(gtk_filedialog_update_preview_callback), previewImage); } #endif // GTK+ 2.4+ }
bool wxListBox::Create( wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, int n, const wxString choices[], long style, const wxValidator& validator, const wxString &name ) { if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxListBox creation failed") ); return false; } m_widget = gtk_scrolled_window_new( NULL, NULL ); g_object_ref(m_widget); if (style & wxLB_ALWAYS_SB) { gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS ); } else { gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); } GTKScrolledWindowSetBorder(m_widget, style); m_treeview = GTK_TREE_VIEW( gtk_tree_view_new( ) ); //wxListBox doesn't have a header :) //NB: If enabled SetFirstItem doesn't work correctly gtk_tree_view_set_headers_visible(m_treeview, FALSE); #if wxUSE_CHECKLISTBOX if(m_hasCheckBoxes) ((wxCheckListBox*)this)->DoCreateCheckList(); #endif // wxUSE_CHECKLISTBOX // Create the data column gtk_tree_view_insert_column_with_attributes(m_treeview, -1, "", gtk_cell_renderer_text_new(), "text", WXLISTBOX_DATACOLUMN, NULL); // Now create+set the model (GtkListStore) - first argument # of columns #if wxUSE_CHECKLISTBOX if(m_hasCheckBoxes) m_liststore = gtk_list_store_new(2, G_TYPE_BOOLEAN, GTK_TYPE_TREE_ENTRY); else #endif m_liststore = gtk_list_store_new(1, GTK_TYPE_TREE_ENTRY); gtk_tree_view_set_model(m_treeview, GTK_TREE_MODEL(m_liststore)); g_object_unref (m_liststore); //free on treeview destruction // Disable the pop-up textctrl that enables searching - note that // the docs specify that even if this disabled (which we are doing) // the user can still have it through the start-interactive-search // key binding...either way we want to provide a searchequal callback // NB: If this is enabled a doubleclick event (activate) gets sent // on a successful search gtk_tree_view_set_search_column(m_treeview, WXLISTBOX_DATACOLUMN); gtk_tree_view_set_search_equal_func(m_treeview, (GtkTreeViewSearchEqualFunc) gtk_listbox_searchequal_callback, this, NULL); gtk_tree_view_set_enable_search(m_treeview, FALSE); GtkSelectionMode mode; // GTK_SELECTION_EXTENDED is a deprecated synonym for GTK_SELECTION_MULTIPLE if ( style & (wxLB_MULTIPLE | wxLB_EXTENDED) ) { mode = GTK_SELECTION_MULTIPLE; } else // no multi-selection flags specified { m_windowStyle |= wxLB_SINGLE; mode = GTK_SELECTION_SINGLE; } GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview ); gtk_tree_selection_set_mode( selection, mode ); // Handle sortable stuff if(HasFlag(wxLB_SORT)) { // Setup sorting in ascending (wx) order gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_liststore), WXLISTBOX_DATACOLUMN, GTK_SORT_ASCENDING); // Set the sort callback gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(m_liststore), WXLISTBOX_DATACOLUMN, (GtkTreeIterCompareFunc) gtk_listbox_sort_callback, this, //userdata NULL //"destroy notifier" ); } gtk_container_add (GTK_CONTAINER (m_widget), GTK_WIDGET(m_treeview) ); gtk_widget_show( GTK_WIDGET(m_treeview) ); m_focusWidget = GTK_WIDGET(m_treeview); Append(n, choices); // insert initial items // generate dclick events g_signal_connect_after(m_treeview, "row-activated", G_CALLBACK(gtk_listbox_row_activated_callback), this); // for intercepting dclick generation by <ENTER> g_signal_connect (m_treeview, "key_press_event", G_CALLBACK (gtk_listbox_key_press_callback), this); m_parent->DoAddChild( this ); PostCreation(size); SetInitialSize(size); // need this too because this is a wxControlWithItems g_signal_connect_after (selection, "changed", G_CALLBACK (gtk_listitem_changed_callback), this); return true; }
wxFontEncoding wxGetFontEncFromCharSet(int cs) { wxFontEncoding fontEncoding; switch ( cs ) { default: wxFAIL_MSG( _T("unexpected Win32 charset") ); // fall through and assume the system charset case DEFAULT_CHARSET: fontEncoding = wxFONTENCODING_SYSTEM; break; case ANSI_CHARSET: fontEncoding = wxFONTENCODING_CP1252; break; case SYMBOL_CHARSET: // what can we do here? fontEncoding = wxFONTENCODING_MAX; break; #if defined(__WIN32__) && !defined(__WXMICROWIN__) case EASTEUROPE_CHARSET: fontEncoding = wxFONTENCODING_CP1250; break; case BALTIC_CHARSET: fontEncoding = wxFONTENCODING_CP1257; break; case RUSSIAN_CHARSET: fontEncoding = wxFONTENCODING_CP1251; break; case ARABIC_CHARSET: fontEncoding = wxFONTENCODING_CP1256; break; case GREEK_CHARSET: fontEncoding = wxFONTENCODING_CP1253; break; case HEBREW_CHARSET: fontEncoding = wxFONTENCODING_CP1255; break; case TURKISH_CHARSET: fontEncoding = wxFONTENCODING_CP1254; break; case THAI_CHARSET: fontEncoding = wxFONTENCODING_CP874; break; case SHIFTJIS_CHARSET: fontEncoding = wxFONTENCODING_CP932; break; case GB2312_CHARSET: fontEncoding = wxFONTENCODING_CP936; break; case HANGUL_CHARSET: fontEncoding = wxFONTENCODING_CP949; break; case CHINESEBIG5_CHARSET: fontEncoding = wxFONTENCODING_CP950; break; #endif // Win32 case OEM_CHARSET: fontEncoding = wxFONTENCODING_CP437; break; } return fontEncoding; }
bool wxCheckBox::MSWOnDraw(WXDRAWITEMSTRUCT *item) { DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT *)item; if ( !IsOwnerDrawn() || dis->CtlType != ODT_BUTTON ) return wxCheckBoxBase::MSWOnDraw(item); // calculate the rectangles for the check mark itself and the label HDC hdc = dis->hDC; RECT& rect = dis->rcItem; RECT rectCheck, rectLabel; rectCheck.top = rectLabel.top = rect.top; rectCheck.bottom = rectLabel.bottom = rect.bottom; const int checkSize = GetBestSize().y; const int MARGIN = 3; const bool isRightAligned = HasFlag(wxALIGN_RIGHT); if ( isRightAligned ) { rectCheck.right = rect.right; rectCheck.left = rectCheck.right - checkSize; rectLabel.right = rectCheck.left - MARGIN; rectLabel.left = rect.left; } else // normal, left-aligned checkbox { rectCheck.left = rect.left; rectCheck.right = rectCheck.left + checkSize; rectLabel.left = rectCheck.right + MARGIN; rectLabel.right = rect.right; } // show we draw a focus rect? const bool isFocused = m_isPressed || FindFocus() == this; // draw the checkbox itself: note that this should really, really be in // wxRendererNative but unfortunately we can't add a new virtual function // to it without breaking backwards compatibility // classic Win32 version -- this can be useful when we move this into // wxRendererNative #if defined(__WXWINCE__) || !wxUSE_UXTHEME UINT state = DFCS_BUTTONCHECK; if ( !IsEnabled() ) state |= DFCS_INACTIVE; switch ( Get3StateValue() ) { case wxCHK_CHECKED: state |= DFCS_CHECKED; break; case wxCHK_UNDETERMINED: state |= DFCS_PUSHED; break; default: wxFAIL_MSG( _T("unexpected Get3StateValue() return value") ); // fall through case wxCHK_UNCHECKED: // no extra styles needed break; } if ( wxFindWindowAtPoint(wxGetMousePosition()) == this ) state |= DFCS_HOT; if ( !::DrawFrameControl(hdc, &rectCheck, DFC_BUTTON, state) ) { wxLogLastError(_T("DrawFrameControl(DFC_BUTTON)")); } #else // XP version wxUxThemeEngine *themeEngine = wxUxThemeEngine::GetIfActive(); if ( !themeEngine ) return false; wxUxThemeHandle theme(this, L"BUTTON"); if ( !theme ) return false; int state; switch ( Get3StateValue() ) { case wxCHK_CHECKED: state = CBS_CHECKEDNORMAL; break; case wxCHK_UNDETERMINED: state = CBS_MIXEDNORMAL; break; default: wxFAIL_MSG( _T("unexpected Get3StateValue() return value") ); // fall through case wxCHK_UNCHECKED: state = CBS_UNCHECKEDNORMAL; break; } if ( !IsEnabled() ) state += CBS_DISABLED_OFFSET; else if ( m_isPressed ) state += CBS_PRESSED_OFFSET; else if ( m_isHot ) state += CBS_HOT_OFFSET; HRESULT hr = themeEngine->DrawThemeBackground ( theme, hdc, BP_CHECKBOX, state, &rectCheck, NULL ); if ( FAILED(hr) ) { wxLogApiError(_T("DrawThemeBackground(BP_CHECKBOX)"), hr); } #endif // 0/1 // draw the text const wxString& label = GetLabel(); // first we need to measure it UINT fmt = DT_NOCLIP; // drawing underlying doesn't look well with focus rect (and the native // control doesn't do it) if ( isFocused ) fmt |= DT_HIDEPREFIX; if ( isRightAligned ) fmt |= DT_RIGHT; // TODO: also use DT_HIDEPREFIX if the system is configured so // we need to get the label real size first if we have to draw a focus rect // around it if ( isFocused ) { if ( !::DrawText(hdc, label, label.length(), &rectLabel, fmt | DT_CALCRECT) ) { wxLogLastError(_T("DrawText(DT_CALCRECT)")); } } if ( !IsEnabled() ) { ::SetTextColor(hdc, ::GetSysColor(COLOR_GRAYTEXT)); } if ( !::DrawText(hdc, label, label.length(), &rectLabel, fmt) ) { wxLogLastError(_T("DrawText()")); } // finally draw the focus if ( isFocused ) { rectLabel.left--; rectLabel.right++; if ( !::DrawFocusRect(hdc, &rectLabel) ) { wxLogLastError(_T("DrawFocusRect()")); } } return true; }
bool wxSound::Create(int WXUNUSED(size), const wxByte* WXUNUSED(data)) { wxFAIL_MSG( "not implemented" ); return false; }
void CTransferSocket::OnClose(int error) { m_pControlSocket->LogMessage(::Debug_Verbose, _T("CTransferSocket::OnClose(%d)"), error); m_onCloseCalled = true; if (m_transferEndReason != none) return; if (!m_pBackend) { if (!InitBackend()) { TransferEnd(transfer_failure); return; } } if (m_transferMode == upload) { if (m_shutdown && m_pTlsSocket) { if (m_pTlsSocket->Shutdown() != 0) TransferEnd(transfer_failure); else TransferEnd(successful); } else TransferEnd(transfer_failure); return; } if (error) { m_pControlSocket->LogMessage(::Error, _("Transfer connection interrupted: %s"), CSocket::GetErrorDescription(error).c_str()); TransferEnd(transfer_failure); return; } char buffer[100]; int numread = m_pBackend->Peek(&buffer, 100, error); if (numread > 0) { #ifndef __WXMSW__ wxFAIL_MSG(_T("Peek isn't supposed to return data after close notification")); #endif // MSDN says this: // FD_CLOSE being posted after all data is read from a socket. // An application should check for remaining data upon receipt // of FD_CLOSE to avoid any possibility of losing data. // First half is actually plain wrong. OnReceive(); return; } else if (numread < 0 && error != EAGAIN) { m_pControlSocket->LogMessage(::Error, _("Transfer connection interrupted: %s"), CSocket::GetErrorDescription(error).c_str()); TransferEnd(transfer_failure); return; } if (m_transferMode == resumetest) { if (m_transferBufferLen != 1) { TransferEnd(failed_resumetest); return; } } TransferEnd(successful); }
wxBitmap wxGTKCairoDCImpl::DoGetAsBitmap(const wxRect* /*subrect*/) const { wxFAIL_MSG("DoGetAsBitmap not implemented"); return wxBitmap(); }
void wxBitmapCheckBox::SetLabel(const wxBitmap *WXUNUSED(bitmap)) { // TODO wxFAIL_MSG(wxT("wxBitmapCheckBox::SetLabel() not yet implemented")); }
virtual int OnRun() { wxFAIL_MSG( wxT("unreachable code") ); return 0; }
void wxBitmapCheckBox::SetValue(bool WXUNUSED(val)) { // TODO wxFAIL_MSG(wxT("wxBitmapCheckBox::SetValue() not yet implemented")); }
wxRect wxScrollBar::GetScrollbarRect(wxScrollBar::Element elem, int thumbPos) const { if ( thumbPos == -1 ) { thumbPos = GetThumbPosition(); } const wxSize sizeArrow = m_renderer->GetScrollbarArrowSize(); wxSize sizeTotal = GetClientSize(); wxCoord *start, *width; wxCoord length, arrow; wxRect rect; if ( IsVertical() ) { rect.x = 0; rect.width = sizeTotal.x; length = sizeTotal.y; start = &rect.y; width = &rect.height; arrow = sizeArrow.y; } else // horizontal { rect.y = 0; rect.height = sizeTotal.y; length = sizeTotal.x; start = &rect.x; width = &rect.width; arrow = sizeArrow.x; } switch ( elem ) { case wxScrollBar::Element_Arrow_Line_1: *start = 0; *width = arrow; break; case wxScrollBar::Element_Arrow_Line_2: *start = length - arrow; *width = arrow; break; case wxScrollBar::Element_Arrow_Page_1: case wxScrollBar::Element_Arrow_Page_2: // we don't have them at all break; case wxScrollBar::Element_Thumb: case wxScrollBar::Element_Bar_1: case wxScrollBar::Element_Bar_2: // we need to calculate the thumb position - do it { length -= 2*arrow; wxCoord thumbStart, thumbEnd; int range = GetRange(); if ( !range ) { thumbStart = thumbEnd = 0; } else { GetScrollBarThumbSize(length, thumbPos, GetThumbSize(), range, &thumbStart, &thumbEnd); } if ( elem == wxScrollBar::Element_Thumb ) { *start = thumbStart; *width = thumbEnd - thumbStart; } else if ( elem == wxScrollBar::Element_Bar_1 ) { *start = 0; *width = thumbStart; } else // elem == wxScrollBar::Element_Bar_2 { *start = thumbEnd; *width = length - thumbEnd; } // everything is relative to the start of the shaft so far *start += arrow; } break; case wxScrollBar::Element_Max: default: wxFAIL_MSG( wxT("unknown scrollbar element") ); } return rect; }
wxDllType wxDynamicLibrary::GetProgramHandle() { wxFAIL_MSG( wxT("GetProgramHandle() is not implemented under this platform")); return 0; }
bool wxStdScrollBarInputHandler::HandleMouse(wxInputConsumer *consumer, const wxMouseEvent& event) { // is this a click event from an acceptable button? int btn = event.GetButton(); if ( btn == wxMOUSE_BTN_LEFT ) { // determine which part of the window mouse is in wxScrollBar *scrollbar = wxStaticCast(consumer->GetInputWindow(), wxScrollBar); wxHitTest ht = scrollbar->HitTestBar(event.GetPosition()); // when the mouse is pressed on any scrollbar element, we capture it // and hold capture until the same mouse button is released if ( event.ButtonDown() || event.ButtonDClick() ) { if ( !m_winCapture ) { m_btnCapture = btn; m_winCapture = consumer->GetInputWindow(); m_winCapture->CaptureMouse(); // generate the command bool hasAction = true; wxControlAction action; switch ( ht ) { case wxHT_SCROLLBAR_ARROW_LINE_1: action = wxACTION_SCROLL_LINE_UP; break; case wxHT_SCROLLBAR_ARROW_LINE_2: action = wxACTION_SCROLL_LINE_DOWN; break; case wxHT_SCROLLBAR_BAR_1: action = wxACTION_SCROLL_PAGE_UP; m_ptStartScrolling = event.GetPosition(); break; case wxHT_SCROLLBAR_BAR_2: action = wxACTION_SCROLL_PAGE_DOWN; m_ptStartScrolling = event.GetPosition(); break; case wxHT_SCROLLBAR_THUMB: consumer->PerformAction(wxACTION_SCROLL_THUMB_DRAG); m_ofsMouse = GetMouseCoord(scrollbar, event) - scrollbar->ScrollbarToPixel(); // fall through: there is no immediate action default: hasAction = false; } // remove highlighting Highlight(scrollbar, false); m_htLast = ht; // and press the arrow or highlight thumb now instead if ( m_htLast == wxHT_SCROLLBAR_THUMB ) Highlight(scrollbar, true); else Press(scrollbar, true); // start dragging if ( hasAction ) { m_timerScroll = new wxScrollBarTimer(this, action, scrollbar); m_timerScroll->StartAutoScroll(); } //else: no (immediate) action } //else: mouse already captured, nothing to do } // release mouse if the *same* button went up else if ( btn == m_btnCapture ) { if ( m_winCapture ) { StopScrolling(scrollbar); // if we were dragging the thumb, send the last event if ( m_htLast == wxHT_SCROLLBAR_THUMB ) { scrollbar->PerformAction(wxACTION_SCROLL_THUMB_RELEASE); } m_htLast = ht; Highlight(scrollbar, true); } else { // this is not supposed to happen as the button can't go up // without going down previously and then we'd have // m_winCapture by now wxFAIL_MSG( wxT("logic error in mouse capturing code") ); } } } return wxStdInputHandler::HandleMouse(consumer, event); }
void wxCheckListBox::OnKeyDown(wxKeyEvent& event) { // what do we do? enum { NONE, TOGGLE, SET, CLEAR } oper; switch ( event.GetKeyCode() ) { case WXK_SPACE: oper = TOGGLE; break; case WXK_NUMPAD_ADD: case '+': oper = SET; break; case WXK_NUMPAD_SUBTRACT: case '-': oper = CLEAR; break; default: oper = NONE; } if ( oper != NONE ) { wxArrayInt selections; int count = 0; if ( HasMultipleSelection() ) { count = GetSelections(selections); } else { int sel = GetSelection(); if (sel != -1) { count = 1; selections.Add(sel); } } for ( int i = 0; i < count; i++ ) { int nItem = selections[i]; switch ( oper ) { case TOGGLE: Toggle(nItem); break; case SET: case CLEAR: Check(nItem, oper == SET); break; default: wxFAIL_MSG( wxT("what should this key do?") ); } // we should send an event as this has been done by the user and // not by the program SendEvent(nItem); } } else // nothing to do { event.Skip(); } }
bool wxRibbonButtonBar::TryCollapseLayout(wxRibbonButtonBarLayout* original, size_t first_btn, size_t* last_button) { size_t btn_count = m_buttons.Count(); size_t btn_i; int used_height = 0; int used_width = 0; int available_width = 0; int available_height = 0; for(btn_i = first_btn + 1; btn_i > 0; /* decrement is inside loop */) { --btn_i; wxRibbonButtonBarButtonBase* button = m_buttons.Item(btn_i); wxRibbonButtonBarButtonState large_size_class = button->GetLargestSize(); wxSize large_size = button->sizes[large_size_class].size; int t_available_height = wxMax(available_height, large_size.GetHeight()); int t_available_width = available_width + large_size.GetWidth(); wxRibbonButtonBarButtonState small_size_class = large_size_class; if(!button->GetSmallerSize(&small_size_class)) { return false; } wxSize small_size = button->sizes[small_size_class].size; int t_used_height = used_height + small_size.GetHeight(); int t_used_width = wxMax(used_width, small_size.GetWidth()); if(t_used_height > t_available_height) { ++btn_i; break; } else { used_height = t_used_height; used_width = t_used_width; available_width = t_available_width; available_height = t_available_height; } } if(btn_i >= first_btn || used_width >= available_width) { return false; } if(last_button != NULL) { *last_button = btn_i; } wxRibbonButtonBarLayout* layout = new wxRibbonButtonBarLayout; WX_APPEND_ARRAY(layout->buttons, original->buttons); wxPoint cursor(layout->buttons.Item(btn_i).position); bool preserve_height = false; if(btn_i == 0) { // If height isn't preserved (i.e. it is reduced), then the minimum // size for the button bar will decrease, preventing the original // layout from being used (in some cases). // It may be a good idea to always preverse the height, but for now // it is only done when the first button is involved in a collapse. preserve_height = true; } for(; btn_i <= first_btn; ++btn_i) { wxRibbonButtonBarButtonInstance& instance = layout->buttons.Item(btn_i); instance.base->GetSmallerSize(&instance.size); instance.position = cursor; cursor.y += instance.base->sizes[instance.size].size.GetHeight(); } int x_adjust = available_width - used_width; for(; btn_i < btn_count; ++btn_i) { wxRibbonButtonBarButtonInstance& instance = layout->buttons.Item(btn_i); instance.position.x -= x_adjust; } layout->CalculateOverallSize(); // Sanity check if(layout->overall_size.GetWidth() >= original->overall_size.GetWidth() || layout->overall_size.GetHeight() > original->overall_size.GetHeight()) { delete layout; wxFAIL_MSG("Layout collapse resulted in increased size"); return false; } if(preserve_height) { layout->overall_size.SetHeight(original->overall_size.GetHeight()); } m_layouts.Add(layout); return true; }
bool wxCheckBox::MSWOnDraw(WXDRAWITEMSTRUCT *item) { DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT *)item; if ( !IsOwnerDrawn() || dis->CtlType != ODT_BUTTON ) return wxCheckBoxBase::MSWOnDraw(item); // calculate the rectangles for the check mark itself and the label HDC hdc = dis->hDC; RECT& rect = dis->rcItem; RECT rectCheck, rectLabel; rectCheck.top = rectLabel.top = rect.top; rectCheck.bottom = rectLabel.bottom = rect.bottom; const int checkSize = GetBestSize().y; const int MARGIN = 3; const bool isRightAligned = HasFlag(wxALIGN_RIGHT); if ( isRightAligned ) { rectCheck.right = rect.right; rectCheck.left = rectCheck.right - checkSize; rectLabel.right = rectCheck.left - MARGIN; rectLabel.left = rect.left; } else // normal, left-aligned checkbox { rectCheck.left = rect.left; rectCheck.right = rectCheck.left + checkSize; rectLabel.left = rectCheck.right + MARGIN; rectLabel.right = rect.right; } // show we draw a focus rect? const bool isFocused = m_isPressed || FindFocus() == this; // draw the checkbox itself wxDCTemp dc(hdc); int flags = 0; if ( !IsEnabled() ) flags |= wxCONTROL_DISABLED; switch ( Get3StateValue() ) { case wxCHK_CHECKED: flags |= wxCONTROL_CHECKED; break; case wxCHK_UNDETERMINED: flags |= wxCONTROL_PRESSED; break; default: wxFAIL_MSG( wxT("unexpected Get3StateValue() return value") ); // fall through case wxCHK_UNCHECKED: // no extra styles needed break; } if ( wxFindWindowAtPoint(wxGetMousePosition()) == this ) flags |= wxCONTROL_CURRENT; wxRendererNative::Get(). DrawCheckBox(this, dc, wxRectFromRECT(rectCheck), flags); // draw the text const wxString& label = GetLabel(); // first we need to measure it UINT fmt = DT_NOCLIP; // drawing underlying doesn't look well with focus rect (and the native // control doesn't do it) if ( isFocused ) fmt |= DT_HIDEPREFIX; if ( isRightAligned ) fmt |= DT_RIGHT; // TODO: also use DT_HIDEPREFIX if the system is configured so // we need to get the label real size first if we have to draw a focus rect // around it if ( isFocused ) { if ( !::DrawText(hdc, label.wx_str(), label.length(), &rectLabel, fmt | DT_CALCRECT) ) { wxLogLastError(wxT("DrawText(DT_CALCRECT)")); } } if ( !IsEnabled() ) { ::SetTextColor(hdc, ::GetSysColor(COLOR_GRAYTEXT)); } if ( !::DrawText(hdc, label.wx_str(), label.length(), &rectLabel, fmt) ) { wxLogLastError(wxT("DrawText()")); } // finally draw the focus if ( isFocused ) { rectLabel.left--; rectLabel.right++; if ( !::DrawFocusRect(hdc, &rectLabel) ) { wxLogLastError(wxT("DrawFocusRect()")); } } return true; }
void wxPopupWindowHandler::OnLeftDown(wxMouseEvent& event) { // let the window have it first (we're the first event handler in the chain // of handlers for this window) if ( m_popup->ProcessLeftDown(event) ) { return; } wxPoint pos = event.GetPosition(); // in non-Univ ports the system manages scrollbars for us #if defined(__WXUNIVERSAL__) && wxUSE_SCROLLBAR // scrollbar on which the click occurred wxWindow *sbar = NULL; #endif // __WXUNIVERSAL__ && wxUSE_SCROLLBAR wxWindow *win = (wxWindow *)event.GetEventObject(); switch ( win->HitTest(pos.x, pos.y) ) { case wxHT_WINDOW_OUTSIDE: { // do the coords translation now as after DismissAndNotify() // m_popup may be destroyed wxMouseEvent event2(event); m_popup->ClientToScreen(&event2.m_x, &event2.m_y); // clicking outside a popup dismisses it m_popup->DismissAndNotify(); // dismissing a tooltip shouldn't waste a click, i.e. you // should be able to dismiss it and press the button with the // same click, so repost this event to the window beneath us wxWindow *winUnder = wxFindWindowAtPoint(event2.GetPosition()); if ( winUnder ) { // translate the event coords to the ones of the window // which is going to get the event winUnder->ScreenToClient(&event2.m_x, &event2.m_y); event2.SetEventObject(winUnder); wxPostEvent(winUnder->GetEventHandler(), event2); } } break; #if defined(__WXUNIVERSAL__) && wxUSE_SCROLLBAR case wxHT_WINDOW_HORZ_SCROLLBAR: sbar = win->GetScrollbar(wxHORIZONTAL); break; case wxHT_WINDOW_VERT_SCROLLBAR: sbar = win->GetScrollbar(wxVERTICAL); break; #endif // __WXUNIVERSAL__ && wxUSE_SCROLLBAR default: // forgot to update the switch after adding a new hit test code? wxFAIL_MSG( wxT("unexpected HitTest() return value") ); wxFALLTHROUGH; case wxHT_WINDOW_CORNER: // don't actually know if this one is good for anything, but let it // pass just in case case wxHT_WINDOW_INSIDE: // let the normal processing take place event.Skip(); break; } #if defined(__WXUNIVERSAL__) && wxUSE_SCROLLBAR if ( sbar ) { // translate the event coordinates to the scrollbar ones pos = sbar->ScreenToClient(win->ClientToScreen(pos)); // and give the event to it wxMouseEvent event2 = event; event2.m_x = pos.x; event2.m_y = pos.y; (void)sbar->GetEventHandler()->ProcessEvent(event2); } #endif // __WXUNIVERSAL__ && wxUSE_SCROLLBAR }
wxSizerItem* wxGridBagSizer::Add( wxSizerItem * ) { wxFAIL_MSG(wxT("Invalid Add form called.")); return NULL; }
wxWindow *wxGetActiveWindow() { // TODO wxFAIL_MSG(wxT("Not implemented")); return NULL; }
wxSizerItem* wxGridBagSizer::Prepend( wxSizerItem * ) { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); return NULL; }
bool LIB_EDIT_FRAME::OnRightClick( const wxPoint& aPosition, wxMenu* PopMenu ) { LIB_ITEM* item = GetDrawItem(); bool BlockActive = GetScreen()->IsBlockActive(); if( BlockActive ) { AddMenusForBlock( PopMenu, this ); PopMenu->AppendSeparator(); return true; } if( m_component == NULL ) return true; // If Command in progress, put menu "cancel" if( item && item->InEditMode() ) { AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_CANCEL_EDITING, _( "Cancel" ), KiBitmap( cancel_xpm ) ); PopMenu->AppendSeparator(); } else { item = LocateItemUsingCursor( aPosition ); // If the clarify item selection context menu is aborted, don't show the context menu. if( item == NULL && m_canvas->GetAbortRequest() ) { m_canvas->SetAbortRequest( false ); return false; } if( GetToolId() != ID_NO_TOOL_SELECTED ) { // If a tool is active, put menu "end tool" AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_CANCEL_EDITING, _( "End Tool" ), KiBitmap( cursor_xpm ) ); PopMenu->AppendSeparator(); } } if( item ) { MSG_PANEL_ITEMS items; item->GetMsgPanelInfo( items ); SetMsgPanel( items ); } else { return true; } m_drawItem = item; bool not_edited = !item->InEditMode(); wxString msg; switch( item->Type() ) { case LIB_PIN_T: AddMenusForPin( PopMenu, (LIB_PIN*) item, this ); break; case LIB_ARC_T: if( not_edited ) { msg = AddHotkeyName( _( "Move Arc" ), s_Libedit_Hokeys_Descr, HK_LIBEDIT_MOVE_GRAPHIC_ITEM ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST, msg, KiBitmap( move_arc_xpm ) ); msg = AddHotkeyName( _( "Drag Arc Size" ), s_Libedit_Hokeys_Descr, HK_DRAG ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MODIFY_ITEM, msg, KiBitmap( move_arc_xpm ) ); } msg = AddHotkeyName( _( "Edit Arc Options" ), s_Libedit_Hokeys_Descr, HK_EDIT ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_BODY_EDIT_ITEM, msg, KiBitmap( options_arc_xpm ) ); if( not_edited ) { msg = AddHotkeyName( _( "Delete Arc" ), s_Libedit_Hokeys_Descr, HK_DELETE ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_DELETE_ITEM, msg, KiBitmap( delete_arc_xpm ) ); } break; case LIB_CIRCLE_T: if( not_edited ) { msg = AddHotkeyName( _( "Move Circle" ), s_Libedit_Hokeys_Descr, HK_LIBEDIT_MOVE_GRAPHIC_ITEM ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST, msg, KiBitmap( move_circle_xpm ) ); msg = AddHotkeyName( _( "Drag Circle Outline" ), s_Libedit_Hokeys_Descr, HK_DRAG ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MODIFY_ITEM, msg, KiBitmap( move_rectangle_xpm ) ); } msg = AddHotkeyName( _( "Edit Circle Options" ), s_Libedit_Hokeys_Descr, HK_EDIT ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_BODY_EDIT_ITEM, msg, KiBitmap( options_circle_xpm ) ); if( not_edited ) { msg = AddHotkeyName( _( "Delete Circle" ), s_Libedit_Hokeys_Descr, HK_DELETE ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_DELETE_ITEM, msg, KiBitmap( delete_circle_xpm ) ); } break; case LIB_RECTANGLE_T: if( not_edited ) { msg = AddHotkeyName( _( "Move Rectangle" ), s_Libedit_Hokeys_Descr, HK_LIBEDIT_MOVE_GRAPHIC_ITEM ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST, msg, KiBitmap( move_rectangle_xpm ) ); } msg = AddHotkeyName( _( "Edit Rectangle Options" ), s_Libedit_Hokeys_Descr, HK_EDIT ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_BODY_EDIT_ITEM, msg, KiBitmap( options_rectangle_xpm ) ); if( not_edited ) { msg = AddHotkeyName( _( "Drag Rectangle Edge" ), s_Libedit_Hokeys_Descr, HK_DRAG ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MODIFY_ITEM, msg, KiBitmap( move_rectangle_xpm ) ); msg = AddHotkeyName( _( "Delete Rectangle" ), s_Libedit_Hokeys_Descr, HK_DELETE ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_DELETE_ITEM, msg, KiBitmap( delete_rectangle_xpm ) ); } break; case LIB_TEXT_T: if( not_edited ) { msg = AddHotkeyName( _( "Move Text" ), s_Libedit_Hokeys_Descr, HK_LIBEDIT_MOVE_GRAPHIC_ITEM ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST, msg, KiBitmap( move_text_xpm ) ); } msg = AddHotkeyName( _( "Edit Text" ), s_Libedit_Hokeys_Descr, HK_EDIT ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_BODY_EDIT_ITEM, msg, KiBitmap( edit_text_xpm ) ); msg = AddHotkeyName( _( "Rotate Text" ), s_Libedit_Hokeys_Descr, HK_ROTATE ); AddMenuItem( PopMenu, ID_LIBEDIT_ROTATE_ITEM, msg, KiBitmap( edit_text_xpm ) ); if( not_edited ) { msg = AddHotkeyName( _( "Delete Text" ), s_Libedit_Hokeys_Descr, HK_DELETE ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_DELETE_ITEM, msg, KiBitmap( delete_text_xpm ) ); } break; case LIB_POLYLINE_T: if( not_edited ) { msg = AddHotkeyName( _( "Move Line" ), s_Libedit_Hokeys_Descr, HK_LIBEDIT_MOVE_GRAPHIC_ITEM ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST, msg, KiBitmap( move_line_xpm ) ); msg = AddHotkeyName( _( "Drag Edge Point" ), s_Libedit_Hokeys_Descr, HK_DRAG ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MODIFY_ITEM, msg, KiBitmap( move_line_xpm ) ); } if( item->IsNew() ) { AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_END_CREATE_ITEM, _( "Line End" ), KiBitmap( apply_xpm ) ); } msg = AddHotkeyName( _( "Edit Line Options" ), s_Libedit_Hokeys_Descr, HK_EDIT ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_BODY_EDIT_ITEM, msg, KiBitmap( options_segment_xpm ) ); if( not_edited ) { msg = AddHotkeyName( _( "Delete Line " ), s_Libedit_Hokeys_Descr, HK_DELETE ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_DELETE_ITEM, msg, KiBitmap( delete_segment_xpm ) ); } if( item->IsNew() ) { if( ( (LIB_POLYLINE*) item )->GetCornerCount() > 2 ) { msg = AddHotkeyName( _( "Delete Segment" ), s_Libedit_Hokeys_Descr, HK_DELETE ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_DELETE_CURRENT_POLY_SEGMENT, msg, KiBitmap( delete_segment_xpm ) ); } } break; case LIB_FIELD_T: if( not_edited ) { msg = AddHotkeyName( _( "Move Field" ), s_Libedit_Hokeys_Descr, HK_LIBEDIT_MOVE_GRAPHIC_ITEM ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST, msg, KiBitmap( move_field_xpm ) ); } msg = AddHotkeyName( _( "Field Rotate" ), s_Libedit_Hokeys_Descr, HK_ROTATE ); AddMenuItem( PopMenu, ID_LIBEDIT_ROTATE_ITEM, msg, KiBitmap( rotate_field_xpm ) ); msg = AddHotkeyName( _( "Field Edit" ), s_Libedit_Hokeys_Descr, HK_EDIT ); AddMenuItem( PopMenu, ID_POPUP_LIBEDIT_FIELD_EDIT_ITEM, msg, KiBitmap( edit_text_xpm ) ); break; default: wxFAIL_MSG( wxString::Format( wxT( "Unknown library item type %d" ), item->Type() ) ); m_drawItem = NULL; break; } PopMenu->AppendSeparator(); return true; }
pascal OSStatus wxMacCarbonFontPanelHandler(EventHandlerCallRef WXUNUSED(nextHandler), EventRef event, void *userData) { OSStatus result = eventNotHandledErr ; wxFontDialog *fontdialog = (wxFontDialog*) userData ; wxFontData& fontdata= fontdialog->GetFontData() ; wxMacCarbonEvent cEvent( event ); switch(cEvent.GetKind()) { case kEventFontSelection : { bool setup = false ; #if wxOSX_USE_CORE_TEXT if ( UMAGetSystemVersion() >= 0x1050 ) { CTFontDescriptorRef descr; if ( cEvent.GetParameter<CTFontDescriptorRef>( kEventParamCTFontDescriptor, typeCTFontDescriptorRef, &descr ) == noErr ) { wxFont font; wxNativeFontInfo fontinfo; fontinfo.Init(descr); font.Create(fontinfo); fontdata.SetChosenFont( font ) ; setup = true; } } #endif #if wxOSX_USE_ATSU_TEXT ATSUFontID fontId = 0 ; if ( !setup && (cEvent.GetParameter<ATSUFontID>(kEventParamATSUFontID, &fontId) == noErr) ) { FMFontStyle fontStyle = cEvent.GetParameter<FMFontStyle>(kEventParamFMFontStyle); FMFontSize fontSize = cEvent.GetParameter<FMFontSize>(kEventParamFMFontSize); CFStringRef cfName = NULL; #if 1 FMFontFamily fontFamily = cEvent.GetParameter<FMFontFamily>(kEventParamFMFontFamily); ATSFontFamilyRef atsfontfamilyref = FMGetATSFontFamilyRefFromFontFamily( fontFamily ) ; OSStatus err = ATSFontFamilyGetName( atsfontfamilyref , kATSOptionFlagsDefault , &cfName ) ; if ( err != noErr ) { wxFAIL_MSG("ATSFontFamilyGetName failed"); } #else // we don't use the ATSU naming anymore ByteCount actualLength = 0; char *c = NULL; OSStatus err = ATSUFindFontName(fontId , kFontFamilyName, kFontUnicodePlatform, kFontNoScriptCode, kFontNoLanguageCode , 0 , NULL , &actualLength , NULL ); if ( err == noErr) { actualLength += 1 ; char *c = (char*)malloc( actualLength ); err = ATSUFindFontName(fontId, kFontFamilyName, kFontUnicodePlatform, kFontNoScriptCode, kFontNoLanguageCode, actualLength, c , NULL, NULL); cfName = CFStringCreateWithCharacters(NULL, (UniChar*) c, (actualLength-1) >> 1); } else { err = ATSUFindFontName(fontId , kFontFamilyName, kFontNoPlatformCode, kFontNoScriptCode, kFontNoLanguageCode , 0 , NULL , &actualLength , NULL ); if ( err == noErr ) { actualLength += 1 ; c = (char*)malloc(actualLength); err = ATSUFindFontName(fontId, kFontFamilyName, kFontNoPlatformCode, kFontNoScriptCode, kFontNoLanguageCode, actualLength, c , NULL, NULL); c[actualLength-1] = 0; cfName = CFStringCreateWithCString(NULL, c, kCFStringEncodingMacRoman ); } } if ( c!=NULL ) free(c); #endif if ( cfName!=NULL ) { fontdata.m_chosenFont.SetFaceName(wxCFStringRef(cfName).AsString(wxLocale::GetSystemEncoding())); fontdata.m_chosenFont.SetPointSize(fontSize); fontdata.m_chosenFont.SetStyle(fontStyle & italic ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL); fontdata.m_chosenFont.SetUnderlined((fontStyle & underline)!=0); fontdata.m_chosenFont.SetWeight(fontStyle & bold ? wxFONTWEIGHT_BOLD : wxFONTWEIGHT_NORMAL); } }
bool wxTopLevelWindowGTK::Create( wxWindow *parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& sizeOrig, long style, const wxString &name ) { // always create a frame of some reasonable, even if arbitrary, size (at // least for MSW compatibility) wxSize size = sizeOrig; size.x = WidthDefault(size.x); size.y = HeightDefault(size.y); wxTopLevelWindows.Append( this ); m_needParent = false; if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") ); return false; } m_title = title; m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow; // NB: m_widget may be !=NULL if it was created by derived class' Create, // e.g. in wxTaskBarIconAreaGTK if (m_widget == NULL) { if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) { m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); // Tell WM that this is a dialog window and make it center // on parent by default (this is what GtkDialog ctor does): gtk_window_set_type_hint(GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_position(GTK_WINDOW(m_widget), GTK_WIN_POS_CENTER_ON_PARENT); } else { m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); #if GTK_CHECK_VERSION(2,1,0) if (!gtk_check_version(2,1,0)) { if (style & wxFRAME_TOOL_WINDOW) { gtk_window_set_type_hint(GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_UTILITY); // On some WMs, like KDE, a TOOL_WINDOW will still show // on the taskbar, but on Gnome a TOOL_WINDOW will not. // For consistency between WMs and with Windows, we // should set the NO_TASKBAR flag which will apply // the set_skip_taskbar_hint if it is available, // ensuring no taskbar entry will appear. style |= wxFRAME_NO_TASKBAR; } } #endif } } wxWindow *topParent = wxGetTopLevelParent(m_parent); if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) && (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) || (style & wxFRAME_FLOAT_ON_PARENT))) { gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(topParent->m_widget) ); } #if GTK_CHECK_VERSION(2,2,0) if (!gtk_check_version(2,2,0)) { if (style & wxFRAME_NO_TASKBAR) { gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); } } #endif #ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) { if (style & wxSTAY_ON_TOP) { gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); } } #endif #if 0 if (!name.empty()) gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) ); #endif gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); g_signal_connect (m_widget, "delete_event", G_CALLBACK (gtk_frame_delete_callback), this); // m_mainWidget holds the toolbar, the menubar and the client area m_mainWidget = gtk_pizza_new(); gtk_widget_show( m_mainWidget ); GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS ); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); if (m_miniEdge == 0) // wxMiniFrame has its own version. { // For m_mainWidget themes g_signal_connect (m_mainWidget, "expose_event", G_CALLBACK (gtk_window_expose_callback), this); } // m_wxwindow only represents the client area without toolbar and menubar m_wxwindow = gtk_pizza_new(); gtk_widget_show( m_wxwindow ); gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow ); // we donm't allow the frame to get the focus as otherwise // the frame will grab it at arbitrary focus changes GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); if (m_parent) m_parent->AddChild( this ); // the user resized the frame by dragging etc. g_signal_connect (m_widget, "size_allocate", G_CALLBACK (gtk_frame_size_callback), this); PostCreation(); if ((m_x != -1) || (m_y != -1)) gtk_widget_set_uposition( m_widget, m_x, m_y ); gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height ); // we cannot set MWM hints and icons before the widget has // been realized, so we do this directly after realization g_signal_connect (m_widget, "realize", G_CALLBACK (gtk_frame_realized_callback), this); // map and unmap for iconized state g_signal_connect (m_widget, "map_event", G_CALLBACK (gtk_frame_map_callback), this); g_signal_connect (m_widget, "unmap_event", G_CALLBACK (gtk_frame_unmap_callback), this); // the only way to get the window size is to connect to this event g_signal_connect (m_widget, "configure_event", G_CALLBACK (gtk_frame_configure_callback), this); // disable native tab traversal g_signal_connect (m_widget, "focus", G_CALLBACK (gtk_frame_focus_callback), this); // activation g_signal_connect_after (m_widget, "focus_in_event", G_CALLBACK (gtk_frame_focus_in_callback), this); g_signal_connect_after (m_widget, "focus_out_event", G_CALLBACK (gtk_frame_focus_out_callback), this); // decorations if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER)) { m_gdkDecor = 0; m_gdkFunc = 0; } else if (m_miniEdge > 0) { m_gdkDecor = 0; m_gdkFunc = 0; if ((style & wxRESIZE_BORDER) != 0) m_gdkFunc |= GDK_FUNC_RESIZE; } else { m_gdkDecor = (long) GDK_DECOR_BORDER; m_gdkFunc = (long) GDK_FUNC_MOVE; // All this is for Motif Window Manager "hints" and is supposed to be // recognized by other WMs as well. if ((style & wxCAPTION) != 0) { m_gdkDecor |= GDK_DECOR_TITLE; } if ((style & wxCLOSE_BOX) != 0) { m_gdkFunc |= GDK_FUNC_CLOSE; } if ((style & wxSYSTEM_MENU) != 0) { m_gdkDecor |= GDK_DECOR_MENU; } if ((style & wxMINIMIZE_BOX) != 0) { m_gdkFunc |= GDK_FUNC_MINIMIZE; m_gdkDecor |= GDK_DECOR_MINIMIZE; } if ((style & wxMAXIMIZE_BOX) != 0) { m_gdkFunc |= GDK_FUNC_MAXIMIZE; m_gdkDecor |= GDK_DECOR_MAXIMIZE; } if ((style & wxRESIZE_BORDER) != 0) { m_gdkFunc |= GDK_FUNC_RESIZE; m_gdkDecor |= GDK_DECOR_RESIZEH; } } return true; }