bool wxStaticBitmap::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
m_needParent = TRUE;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxStaticBitmap creation failed") );
return false;
}
m_bitmap = bitmap;
wxBitmap bmp(bitmap.Ok() ? bitmap : wxBitmap(bogus_xpm));
m_widget = gtk_pixmap_new(bmp.GetPixmap(), NULL);
if (bitmap.Ok())
SetBitmap(bitmap);
PostCreation(size);
m_parent->DoAddChild( this );
return true;
}
bool wxButton::Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxValidator& validator, const wxString &name )
{
m_needParent = true;
m_acceptsFocus = true;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxButton creation failed") );
return false;
}
m_widget = gtk_button_new_with_mnemonic("");
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;
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
gtk_button_set_alignment(GTK_BUTTON(m_widget), x_alignment, y_alignment);
}
else
#endif
{
if (GTK_IS_MISC(GTK_BIN(m_widget)->child))
gtk_misc_set_alignment(GTK_MISC(GTK_BIN(m_widget)->child),
x_alignment, y_alignment);
}
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 (gtk_button_clicked_callback),
this);
g_signal_connect_after (m_widget, "style_set",
G_CALLBACK (gtk_button_style_set_callback),
this);
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
bool wxColourButton::Create( wxWindow *parent, wxWindowID id,
const wxColour &col,
const wxPoint &pos, const wxSize &size,
long style, const wxValidator& validator,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!wxControl::CreateBase(parent, id, pos, size, style, validator, name))
{
wxFAIL_MSG( wxT("wxColourButton creation failed") );
return false;
}
m_colour = col;
#ifdef __WXGTK3__
m_widget = gtk_color_button_new_with_rgba(m_colour);
#else
m_widget = gtk_color_button_new_with_color( m_colour.GetColor() );
#endif
g_object_ref(m_widget);
// GtkColourButton signals
g_signal_connect(m_widget, "color-set",
G_CALLBACK(gtk_clrbutton_setcolor_callback), this);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size);
return true;
}
bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
{
m_needParent = true;
m_insertCallback = (wxInsertChildFunction)wxInsertChildInMDI;
if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
!CreateBase( parent, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") ))
{
wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") );
return false;
}
m_widget = gtk_notebook_new();
gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
GTK_SIGNAL_FUNC(gtk_mdi_page_change_callback), (gpointer)parent );
gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
m_parent->DoAddChild( this );
PostCreation();
Show( true );
return true;
}
bool wxToggleButton::Create(wxWindow *parent, wxWindowID id,
const wxString &label, const wxPoint &pos,
const wxSize &size, long style,
const wxValidator& validator,
const wxString &name)
{
m_needParent = true;
m_acceptsFocus = true;
m_blockEvent = false;
if (!PreCreation(parent, pos, size) ||
!CreateBase(parent, id, pos, size, style, validator, name )) {
wxFAIL_MSG(wxT("wxToggleButton creation failed"));
return false;
}
wxControl::SetLabel(label);
// Create the gtk widget.
m_widget = gtk_toggle_button_new_with_label( wxGTK_CONV( m_label ) );
gtk_signal_connect(GTK_OBJECT(m_widget), "clicked",
GTK_SIGNAL_FUNC(gtk_togglebutton_clicked_callback),
(gpointer *)this);
m_parent->DoAddChild(this);
PostCreation(size);
return true;
}
bool wxChoice::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("wxChoice creation failed") );
return false;
}
if ( IsSorted() )
{
// if our m_strings != NULL, Append() will check for it and insert
// items in the correct order
m_strings = new wxSortedArrayString;
}
m_widget = gtk_combo_box_new_text();
g_object_ref(m_widget);
Append(n, choices);
m_parent->DoAddChild( this );
PostCreation(size);
g_signal_connect_after (m_widget, "changed",
G_CALLBACK (gtk_choice_changed_callback), this);
return true;
}
// Scrollbar
bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
if( !CreateControl( parent, id, pos, size, style, validator, name ) )
return false;
PreCreation();
wxSize newSize =
( style & wxHORIZONTAL ) ? wxSize( 140, 16 ) : wxSize( 16, 140 );
if( size.x != -1 ) newSize.x = size.x;
if( size.y != -1 ) newSize.y = size.y;
Widget parentWidget = (Widget) parent->GetClientWidget();
m_mainWidget =
DoCreateScrollBar( (WXWidget)parentWidget,
(wxOrientation)(style & (wxHORIZONTAL|wxVERTICAL)),
(void (*)())wxScrollBarCallback );
PostCreation();
AttachWidget (parent, m_mainWidget, (WXWidget) NULL,
pos.x, pos.y, newSize.x, newSize.y);
return true;
}
bool wxDirButton::Create( wxWindow *parent, wxWindowID id,
const wxString &label, const wxString &path,
const wxString &message, const wxString &wildcard,
const wxPoint &pos, const wxSize &size,
long style, const wxValidator& validator,
const wxString &name )
{
if (!(style & wxDIRP_USE_TEXTCTRL))
{
// VERY IMPORTANT: this code is identic to relative code in wxFileButton;
// if you find a problem here, fix it also in wxFileButton !
if (!PreCreation( parent, pos, size ) ||
!wxControl::CreateBase(parent, id, pos, size, style & wxWINDOW_STYLE_MASK,
validator, name))
{
wxFAIL_MSG( wxT("wxDirButtonGTK creation failed") );
return false;
}
// create the dialog associated with this button
SetWindowStyle(style);
m_message = message;
m_wildcard = wildcard;
if ((m_dialog = CreateDialog()) == NULL)
return false;
SetPath(path);
// little trick used to avoid problems when there are other GTK windows 'grabbed':
// GtkFileChooserDialog won't be responsive to user events if there is another
// window which called gtk_grab_add (and this happens if e.g. a wxDialog is running
// in modal mode in the application - see wxDialogGTK::ShowModal).
// An idea could be to put the grab on the m_dialog->m_widget when the GtkFileChooserButton
// is clicked and then remove it as soon as the user closes the dialog itself.
// Unfortunately there's no way to hook in the 'clicked' event of the GtkFileChooserButton,
// thus we add grab on m_dialog->m_widget when it's shown and remove it when it's
// hidden simply using its "show" and "hide" events - clean & simple :)
g_signal_connect(m_dialog->m_widget, "show", G_CALLBACK(gtk_grab_add), NULL);
g_signal_connect(m_dialog->m_widget, "hide", G_CALLBACK(gtk_grab_remove), NULL);
// NOTE: we deliberately ignore the given label as GtkFileChooserButton
// use as label the currently selected file
m_widget = gtk_file_chooser_button_new_with_dialog( m_dialog->m_widget );
g_object_ref(m_widget);
// GtkFileChooserButton signals
g_signal_connect(m_widget, "current-folder-changed",
G_CALLBACK(gtk_dirbutton_currentfolderchanged_callback), this);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size);
}
else
return wxGenericDirButton::Create(parent, id, label, path, message, wildcard,
pos, size, style, validator, name);
return true;
}
bool
wxNativeWindow::Create(wxWindow* parent,
wxWindowID winid,
wxNativeWindowHandle widget)
{
wxCHECK_MSG( widget, false, wxS("Invalid null GtkWidget") );
// Standard wxGTK controls use PreCreation() but we never have any size
// specified at this stage, so don't bother with it.
if ( !CreateBase(parent, winid) )
return false;
// Add a reference to the widget to match g_object_unref() in wxWindow dtor.
m_widget = widget;
g_object_ref(m_widget);
parent->DoAddChild(this);
PostCreation();
// Ensure that the best (and minimal) size is set to fully display the
// widget.
GtkRequisition req;
gtk_widget_get_preferred_size(widget, NULL, &req);
SetInitialSize(wxSize(req.width, req.height));
return true;
}
bool wxBitmapToggleButton::Create(wxWindow *parent, wxWindowID id,
const wxBitmap &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("wxBitmapToggleButton creation failed"));
return false;
}
// Create the gtk widget.
m_widget = gtk_toggle_button_new();
g_object_ref(m_widget);
if (style & wxNO_BORDER)
gtk_button_set_relief( GTK_BUTTON(m_widget), GTK_RELIEF_NONE );
m_bitmap = label;
OnSetBitmap();
g_signal_connect (m_widget, "clicked",
G_CALLBACK (gtk_togglebutton_clicked_callback),
this);
m_parent->DoAddChild(this);
PostCreation(size);
return true;
}
bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
{
if ( !PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
!CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
style, wxDefaultValidator, "wxMDIClientWindow" ))
{
wxFAIL_MSG( "wxMDIClientWindow creation failed" );
return false;
}
m_widget = gtk_notebook_new();
g_object_ref(m_widget);
g_signal_connect(m_widget, "switch_page", G_CALLBACK(switch_page), parent);
gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
m_parent->DoAddChild( this );
PostCreation();
Show( true );
return true;
}
void pgDialog::LoadResource(wxWindow *parent, const wxChar *name)
{
if (name)
dlgName = name;
wxXmlResource::Get()->LoadDialog(this, parent, dlgName);
PostCreation();
}
bool wxGauge::Create( wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name )
{
m_needParent = true;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxGauge creation failed") );
return false;
}
m_rangeMax = range;
m_widget = gtk_progress_bar_new();
if ( style & wxGA_VERTICAL )
{
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR(m_widget),
GTK_PROGRESS_BOTTOM_TO_TOP );
}
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size);
return true;
}
bool wxSpinButton::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
if (!PreCreation(parent, pos, size) ||
!CreateBase(parent, id, pos, size, style, wxDefaultValidator, name))
{
wxFAIL_MSG( wxT("wxSpinButton creation failed") );
return false;
}
m_pos = 0;
m_widget = gtk_spin_button_new_with_range(0, 100, 1);
g_object_ref(m_widget);
gtk_entry_set_width_chars(GTK_ENTRY(m_widget), 0);
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON(m_widget),
(int)(m_windowStyle & wxSP_WRAP) );
g_signal_connect_after(
m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
bool wxAnimationCtrl::Create( wxWindow *parent, wxWindowID id,
const wxAnimation& anim,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
if (!PreCreation( parent, pos, size ) ||
!base_type::CreateBase(parent, id, pos, size, style & wxWINDOW_STYLE_MASK,
wxDefaultValidator, name))
{
wxFAIL_MSG( wxT("wxAnimationCtrl creation failed") );
return false;
}
SetWindowStyle(style);
m_widget = gtk_image_new();
g_object_ref(m_widget);
gtk_widget_show(m_widget);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size);
if (anim.IsOk())
SetAnimation(anim);
// init the timer used for animation
m_timer.SetOwner(this);
return true;
}
bool wxToggleButton::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("wxToggleButton creation failed"));
return false;
}
// Create the gtk widget.
m_widget = gtk_toggle_button_new_with_mnemonic("");
g_object_ref(m_widget);
SetLabel(label);
g_signal_connect (m_widget, "clicked",
G_CALLBACK (gtk_togglebutton_clicked_callback),
this);
m_parent->DoAddChild(this);
PostCreation(size);
return true;
}
bool wxCheckBox::Create(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos,
const wxSize &size,
long style,
const wxValidator& validator,
const wxString &name )
{
m_needParent = true;
m_acceptsFocus = true;
m_blockEvent = false;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxCheckBox creation failed") );
return false;
}
wxASSERT_MSG( (style & wxCHK_ALLOW_3RD_STATE_FOR_USER) == 0 ||
(style & wxCHK_3STATE) != 0,
wxT("Using wxCHK_ALLOW_3RD_STATE_FOR_USER")
wxT(" style flag for a 2-state checkbox is useless") );
if ( style & wxALIGN_RIGHT )
{
// VZ: as I don't know a way to create a right aligned checkbox with
// GTK we will create a checkbox without label and a label at the
// left of it
m_widgetCheckbox = gtk_check_button_new();
m_widgetLabel = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(m_widgetLabel), 0.0, 0.5);
m_widget = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetLabel, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetCheckbox, FALSE, FALSE, 3);
gtk_widget_show( m_widgetLabel );
gtk_widget_show( m_widgetCheckbox );
}
else
{
m_widgetCheckbox = gtk_check_button_new_with_label("");
m_widgetLabel = GTK_BIN(m_widgetCheckbox)->child;
m_widget = m_widgetCheckbox;
}
SetLabel( label );
g_signal_connect (m_widgetCheckbox, "toggled",
G_CALLBACK (gtk_checkbox_toggled_callback), this);
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
bool wxRadioButton::Create( wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name )
{
m_acceptsFocus = TRUE;
m_needParent = TRUE;
m_blockEvent = FALSE;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxRadioButton creation failed") );
return FALSE;
}
GSList* radioButtonGroup = NULL;
if (!HasFlag(wxRB_GROUP))
{
// search backward for last group start
wxRadioButton *chief = NULL;
wxWindowList::compatibility_iterator node = parent->GetChildren().GetLast();
while (node)
{
wxWindow *child = node->GetData();
if (child->IsRadioButton())
{
chief = (wxRadioButton*) child;
if (child->HasFlag(wxRB_GROUP))
break;
}
node = node->GetPrevious();
}
if (chief)
{
// we are part of the group started by chief
radioButtonGroup = gtk_radio_button_group( GTK_RADIO_BUTTON(chief->m_widget) );
}
}
m_widget = gtk_radio_button_new_with_label( radioButtonGroup, wxGTK_CONV( label ) );
SetLabel(label);
gtk_signal_connect( GTK_OBJECT(m_widget), "clicked",
GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
m_parent->DoAddChild( this );
PostCreation(size);
return TRUE;
}
bool wxToolBar::Create( wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name )
{
if ( !PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxToolBar creation failed") );
return false;
}
FixupStyle();
m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() );
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
if (gtk_check_version(2, 12, 0))
{
m_tooltips = gtk_tooltips_new();
g_object_ref(m_tooltips);
gtk_object_sink(GTK_OBJECT(m_tooltips));
}
#endif
GtkSetStyle();
if (style & wxTB_DOCKABLE)
{
m_widget = gtk_handle_box_new();
g_signal_connect(m_widget, "child_detached",
G_CALLBACK(child_detached), NULL);
g_signal_connect(m_widget, "child_attached",
G_CALLBACK(child_attached), NULL);
if (style & wxTB_FLAT)
gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
}
else
{
m_widget = gtk_event_box_new();
ConnectWidget( m_widget );
}
g_object_ref(m_widget);
gtk_container_add(GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar));
gtk_widget_show(GTK_WIDGET(m_toolbar));
m_parent->DoAddChild( this );
PostCreation(size);
g_signal_connect_after(m_toolbar, "size_request",
G_CALLBACK(size_request), this);
return true;
}
bool wxBitmapButton::Create(wxWindow *parent, wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
if( !CreateControl( parent, id, pos, size, style, validator, name ) )
return false;
PreCreation();
m_bitmaps[State_Normal] =
m_bitmapsOriginal[State_Normal] = bitmap;
m_bitmaps[State_Pressed] =
m_bitmapsOriginal[State_Pressed] = bitmap;
Widget parentWidget = (Widget) parent->GetClientWidget();
/*
* Patch Note (important)
* There is no major reason to put a defaultButtonThickness here.
* Not requesting it give the ability to put wxButton with a spacing
* as small as requested. However, if some button become a DefaultButton,
* other buttons are no more aligned -- This is why we set
* defaultButtonThickness of ALL buttons belonging to the same wxPanel,
* in the ::SetDefaultButton method.
*/
Widget buttonWidget = XtVaCreateManagedWidget ("button",
// Gadget causes problems for default button operation.
#if wxUSE_GADGETS
xmPushButtonGadgetClass, parentWidget,
#else
xmPushButtonWidgetClass, parentWidget,
#endif
// See comment for wxButton::SetDefault
// XmNdefaultButtonShadowThickness, 1,
XmNrecomputeSize, False,
NULL);
m_mainWidget = (WXWidget) buttonWidget;
XtAddCallback (buttonWidget,
XmNactivateCallback, (XtCallbackProc) wxButtonCallback,
(XtPointer) this);
wxSize best = GetBitmapLabel().IsOk() ? GetBestSize() : wxSize(30, 30);
if( size.x != -1 ) best.x = size.x;
if( size.y != -1 ) best.y = size.y;
PostCreation();
OnSetBitmap();
AttachWidget (parent, m_mainWidget, (WXWidget) NULL,
pos.x, pos.y, best.x, best.y);
return true;
}
wxMenuBar::wxMenuBar(size_t count, wxMenu *menus[], const wxString titles[], long WXUNUSED( style ))
{
m_qtMenuBar = new QMenuBar();
for ( size_t i = 0; i < count; ++i )
Append( menus[ i ], titles[ i ] );
PostCreation();
}
bool wxPopupWindow::Create( wxWindow *parent, int style )
{
if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
!CreateBase( parent, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("popup") ))
{
wxFAIL_MSG( wxT("wxPopupWindow creation failed") );
return false;
}
// Unlike windows, top level windows are created hidden by default.
m_isShown = false;
// All dialogs should really have this style
m_windowStyle |= wxTAB_TRAVERSAL;
m_widget = gtk_window_new( GTK_WINDOW_POPUP );
g_object_ref( m_widget );
gtk_widget_set_name( m_widget, "wxPopupWindow" );
// wxPopupWindow is used for different windows as well
// gtk_window_set_type_hint( GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_COMBO );
GtkWidget *toplevel = gtk_widget_get_toplevel( parent->m_widget );
if (GTK_IS_WINDOW (toplevel))
{
#if GTK_CHECK_VERSION(2,10,0)
#ifndef __WXGTK3__
if (!gtk_check_version(2,10,0))
#endif
{
gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)), GTK_WINDOW (m_widget));
}
#endif
gtk_window_set_transient_for (GTK_WINDOW (m_widget), GTK_WINDOW (toplevel));
}
gtk_window_set_resizable (GTK_WINDOW (m_widget), FALSE);
gtk_window_set_screen (GTK_WINDOW (m_widget), gtk_widget_get_screen (GTK_WIDGET (parent->m_widget)));
g_signal_connect (m_widget, "delete_event",
G_CALLBACK (gtk_dialog_delete_callback), this);
m_wxwindow = wxPizza::New();
gtk_widget_show( m_wxwindow );
gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
if (m_parent) m_parent->AddChild( this );
PostCreation();
m_time = gtk_get_current_event_time();
g_signal_connect (m_widget, "button_press_event",
G_CALLBACK (gtk_popup_button_press), this);
return true;
}
bool wxCheckBox::Create(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos,
const wxSize &size,
long style,
const wxValidator& validator,
const wxString &name )
{
m_needParent = true;
m_acceptsFocus = true;
m_blockEvent = false;
WXValidateStyle(&style);
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxCheckBox creation failed") );
return false;
}
if ( style & wxALIGN_RIGHT )
{
// VZ: as I don't know a way to create a right aligned checkbox with
// GTK we will create a checkbox without label and a label at the
// left of it
m_widgetCheckbox = gtk_check_button_new();
m_widgetLabel = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(m_widgetLabel), 0.0, 0.5);
m_widget = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetLabel, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetCheckbox, FALSE, FALSE, 3);
gtk_widget_show( m_widgetLabel );
gtk_widget_show( m_widgetCheckbox );
}
else
{
m_widgetCheckbox = gtk_check_button_new_with_label("");
m_widgetLabel = BUTTON_CHILD( m_widgetCheckbox );
m_widget = m_widgetCheckbox;
}
SetLabel( label );
gtk_signal_connect( GTK_OBJECT(m_widgetCheckbox),
"toggled",
GTK_SIGNAL_FUNC(gtk_checkbox_toggled_callback),
(gpointer *)this );
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
bool wxToolBar::Create( wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name )
{
m_needParent = true;
m_insertCallback = (wxInsertChildFunction)wxInsertChildInToolBar;
if ( !PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxToolBar creation failed") );
return false;
}
FixupStyle();
GtkOrientation orient;
GtkToolbarStyle gtkStyle;
GetGtkStyle(style, &orient, >kStyle);
m_toolbar = GTK_TOOLBAR( gtk_toolbar_new(orient, gtkStyle) );
SetToolSeparation(7);
if (style & wxTB_DOCKABLE)
{
m_widget = gtk_handle_box_new();
gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
gtk_widget_show( GTK_WIDGET(m_toolbar) );
if (style & wxTB_FLAT)
gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
}
else
{
m_widget = gtk_event_box_new();
gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
ConnectWidget( m_widget );
gtk_widget_show(GTK_WIDGET(m_toolbar));
}
gtk_toolbar_set_tooltips( GTK_TOOLBAR(m_toolbar), TRUE );
if (style & wxTB_FLAT)
gtk_toolbar_set_button_relief( GTK_TOOLBAR(m_toolbar), GTK_RELIEF_NONE );
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
bool wxGauge::Create(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name)
{
if( !CreateControl( parent, id, pos, size, style, validator, name ) )
return false;
PreCreation();
Widget parentWidget = (Widget) parent->GetClientWidget();
Arg args[7];
int count = 4;
if (style & wxGA_HORIZONTAL)
{
XtSetArg (args[0], XmNorientation, XmHORIZONTAL);
XtSetArg (args[1], XmNprocessingDirection, XmMAX_ON_RIGHT);
}
else
{
XtSetArg (args[0], XmNorientation, XmVERTICAL);
XtSetArg (args[1], XmNprocessingDirection, XmMAX_ON_TOP);
}
XtSetArg(args[2], XmNminimum, 0);
XtSetArg(args[3], XmNmaximum, range);
#if wxCHECK_MOTIF_VERSION( 2, 0 ) && !wxCHECK_LESSTIF()
XtSetArg(args[4], XmNeditable, False); ++count;
XtSetArg(args[5], XmNslidingMode, XmTHERMOMETER); ++count;
// XtSetArg(args[6], XmNsliderVisual, XmFOREGROUND_COLOR ); ++count;
Widget gaugeWidget =
XtCreateManagedWidget("gauge", xmScaleWidgetClass,
parentWidget, args, count);
#else
Widget gaugeWidget =
XtCreateManagedWidget("gauge", xmGaugeWidgetClass,
parentWidget, args, count);
#endif
m_mainWidget = (WXWidget) gaugeWidget ;
XtManageChild (gaugeWidget);
int x = pos.x; int y = pos.y;
wxSize best = GetBestSize();
if( size.x != wxDefaultCoord ) best.x = size.x;
if( size.y != wxDefaultCoord ) best.y = size.y;
PostCreation();
AttachWidget (parent, m_mainWidget, (WXWidget) NULL, x, y,
best.x, best.y);
return true;
}
bool wxDialog::Create(wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
SetExtraStyle(GetExtraStyle() | wxTOPLEVEL_EX_DIALOG);
if( !wxTopLevelWindow::Create( parent, id, title, pos, size, style,
name ) )
return false;
m_modalShowing = false;
m_eventLoop = NULL;
Widget dialogShell = (Widget) m_mainWidget;
SetTitle( title );
// Can't remember what this was about... but I think it's necessary.
#if wxUSE_INVISIBLE_RESIZE
if (pos.x > -1)
XtVaSetValues(dialogShell, XmNx, pos.x,
NULL);
if (pos.y > -1)
XtVaSetValues(dialogShell, XmNy, pos.y,
NULL);
if (size.x > -1)
XtVaSetValues(dialogShell, XmNwidth, size.x, NULL);
if (size.y > -1)
XtVaSetValues(dialogShell, XmNheight, size.y, NULL);
#endif
// Positioning of the dialog doesn't work properly unless the dialog
// is managed, so we manage without mapping to the screen.
// To show, we map the shell (actually it's parent).
#if !wxUSE_INVISIBLE_RESIZE
Widget shell = XtParent(dialogShell) ;
XtVaSetValues(shell, XmNmappedWhenManaged, False, NULL);
#endif
#if !wxUSE_INVISIBLE_RESIZE
XtManageChild(dialogShell);
SetSize(pos.x, pos.y, size.x, size.y);
#endif
XtAddEventHandler(dialogShell,ExposureMask,False,
wxUniversalRepaintProc, (XtPointer) this);
PostCreation();
return true;
}
// Create menubar
bool wxMenuBar::CreateMenuBar(wxFrame* parent)
{
m_parent = parent; // bleach... override it!
PreCreation();
m_parent = NULL;
if (m_mainWidget)
{
XtVaSetValues((Widget) parent->GetMainWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
/*
if (!XtIsManaged((Widget) m_mainWidget))
XtManageChild((Widget) m_mainWidget);
*/
XtMapWidget((Widget) m_mainWidget);
return true;
}
Widget menuBarW = XmCreateMenuBar ((Widget) parent->GetMainWidget(),
wxMOTIF_STR("MenuBar"), NULL, 0);
m_mainWidget = (WXWidget) menuBarW;
size_t menuCount = GetMenuCount();
for (size_t i = 0; i < menuCount; i++)
{
wxMenu *menu = GetMenu(i);
wxString title(m_titles[i]);
menu->SetButtonWidget(menu->CreateMenu (this, menuBarW, menu, i, title, true));
if (strcmp (wxStripMenuCodes(title), "Help") == 0)
XtVaSetValues ((Widget) menuBarW, XmNmenuHelpWidget, (Widget) menu->GetButtonWidget(), NULL);
// tear off menu support
#if (XmVersion >= 1002)
if ( menu->IsTearOff() )
{
XtVaSetValues(GetWidget(menu),
XmNtearOffModel, XmTEAR_OFF_ENABLED,
NULL);
Widget tearOff = XmGetTearOffControl(GetWidget(menu));
wxDoChangeForegroundColour((Widget) tearOff, m_foregroundColour);
wxDoChangeBackgroundColour((Widget) tearOff, m_backgroundColour, true);
}
#endif
}
PostCreation();
XtVaSetValues((Widget) parent->GetMainWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
XtRealizeWidget ((Widget) menuBarW);
XtManageChild ((Widget) menuBarW);
SetMenuBarFrame(parent);
return true;
}
bool wxGtkCalendarCtrl::Create(wxWindow *parent,
wxWindowID id,
const wxDateTime& date,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
if (!PreCreation(parent, pos, size) ||
!CreateBase(parent, id, pos, size, style, wxDefaultValidator, name))
{
wxFAIL_MSG(wxT("wxGtkCalendarCtrl creation failed"));
return false;
}
m_widget = gtk_calendar_new();
g_object_ref(m_widget);
SetDate(date.IsValid() ? date : wxDateTime::Today());
if (style & wxCAL_NO_MONTH_CHANGE)
g_object_set (G_OBJECT (m_widget), "no-month-change", true, NULL);
if (style & wxCAL_SHOW_WEEK_NUMBERS)
g_object_set (G_OBJECT (m_widget), "show-week-numbers", true, NULL);
g_signal_connect_after(m_widget, "day-selected",
G_CALLBACK (gtk_day_selected_callback),
this);
g_signal_connect_after(m_widget, "day-selected-double-click",
G_CALLBACK (gtk_day_selected_double_click_callback),
this);
g_signal_connect_after(m_widget, "month-changed",
G_CALLBACK (gtk_month_changed_callback),
this);
// connect callbacks that send deprecated events
g_signal_connect_after(m_widget, "prev-month",
G_CALLBACK (gtk_prev_month_callback),
this);
g_signal_connect_after(m_widget, "next-month",
G_CALLBACK (gtk_prev_month_callback),
this);
g_signal_connect_after(m_widget, "prev-year",
G_CALLBACK (gtk_prev_year_callback),
this);
g_signal_connect_after(m_widget, "next-year",
G_CALLBACK (gtk_prev_year_callback),
this);
m_parent->DoAddChild(this);
PostCreation(size);
return true;
}
bool wxArrowButton::Create( wxSpinButton* parent,
wxWindowID WXUNUSED(id),
ArrowDirection d,
const wxPoint& pos, const wxSize& size )
{
wxCHECK_MSG( parent, false, wxT("must have a valid parent") );
int arrow_dir = XmARROW_UP;
switch( d )
{
case wxARROW_UP:
arrow_dir = XmARROW_UP;
break;
case wxARROW_DOWN:
arrow_dir = XmARROW_DOWN;
break;
case wxARROW_LEFT:
arrow_dir = XmARROW_LEFT;
break;
case wxARROW_RIGHT:
arrow_dir = XmARROW_RIGHT;
break;
}
parent->AddChild( this );
PreCreation();
Widget parentWidget = (Widget) parent->GetClientWidget();
m_mainWidget = (WXWidget) XtVaCreateManagedWidget( "XmArrowButton",
xmArrowButtonWidgetClass,
parentWidget,
XmNarrowDirection, arrow_dir,
XmNborderWidth, 0,
XmNshadowThickness, 0,
NULL );
XtAddCallback( (Widget) m_mainWidget,
XmNactivateCallback, (XtCallbackProc) SpinButtonCallback,
(XtPointer) this );
XtAddCallback( (Widget) m_mainWidget,
XmNarmCallback, (XtCallbackProc) StartTimerCallback,
(XtPointer) this );
XtAddCallback( (Widget) m_mainWidget,
XmNactivateCallback, (XtCallbackProc) StopTimerCallback,
(XtPointer) this );
PostCreation();
AttachWidget( parent, m_mainWidget, (WXWidget) NULL,
pos.x, pos.y, size.x, size.y );
return true;
}
bool wxPopupWindow::Create( wxWindow *parent, int style )
{
m_needParent = false;
if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
!CreateBase( parent, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("popup") ))
{
wxFAIL_MSG( wxT("wxPopupWindow creation failed") );
return false;
}
// Unlike windows, top level windows are created hidden by default.
m_isShown = false;
// All dialogs should really have this style
m_windowStyle |= wxTAB_TRAVERSAL;
m_insertCallback = (wxInsertChildFunction) wxInsertChildInDialog;
m_widget = gtk_window_new( GTK_WINDOW_POPUP );
if ((m_parent) && (GTK_IS_WINDOW(m_parent->m_widget)))
gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
GTK_SIGNAL_FUNC(gtk_dialog_delete_callback), (gpointer)this );
m_wxwindow = gtk_pizza_new();
gtk_widget_show( m_wxwindow );
GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
if (m_parent) m_parent->AddChild( this );
PostCreation();
/* we cannot set MWM hints before the widget has
been realized, so we do this directly after realization */
gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
GTK_SIGNAL_FUNC(gtk_dialog_realized_callback), (gpointer) this );
// disable native tab traversal
gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
GTK_SIGNAL_FUNC(gtk_dialog_focus_callback), (gpointer)this );
gtk_signal_connect (GTK_OBJECT(m_widget), "button_press_event",
GTK_SIGNAL_FUNC(gtk_popup_button_press), (gpointer)this );
return true;
}