static void
_ddisplay_setup_scrollbars (DDisplay *ddisp, GtkWidget *table, int width, int height)
{
/* The adjustment datums */
ddisp->hsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, width, 1, (width-1)/4, width-1));
ddisp->vsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, height, 1, (height-1)/4, height-1));
ddisp->hsb = gtk_hscrollbar_new (ddisp->hsbdata);
#if GTK_CHECK_VERSION(2,18,0)
gtk_widget_set_can_focus (ddisp->hsb, FALSE);
#else
GTK_WIDGET_UNSET_FLAGS (ddisp->hsb, GTK_CAN_FOCUS);
#endif
ddisp->vsb = gtk_vscrollbar_new (ddisp->vsbdata);
#if GTK_CHECK_VERSION(2,18,0)
gtk_widget_set_can_focus (ddisp->vsb, FALSE);
#else
GTK_WIDGET_UNSET_FLAGS (ddisp->vsb, GTK_CAN_FOCUS);
#endif
/* set up the scrollbar observers */
g_signal_connect (G_OBJECT (ddisp->hsbdata), "value_changed",
G_CALLBACK(ddisplay_hsb_update), ddisp);
g_signal_connect (G_OBJECT (ddisp->vsbdata), "value_changed",
G_CALLBACK(ddisplay_vsb_update), ddisp);
/* harder to change position in the table, but we did not do it for years ;) */
gtk_table_attach (GTK_TABLE (table), ddisp->hsb, 0, 2, 2, 3,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->vsb, 2, 3, 0, 2,
GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (ddisp->hsb);
gtk_widget_show (ddisp->vsb);
}
/*
* Standard Gtk+ function
*/
static void Dw_gtk_viewport_init (GtkDwViewport *viewport)
{
DBG_OBJ_CREATE (viewport, "GtkDwViewport");
GTK_WIDGET_UNSET_FLAGS (viewport, GTK_NO_WINDOW);
GTK_WIDGET_UNSET_FLAGS (viewport, GTK_CAN_FOCUS);
/* Without this, gtk_layout_{draw|expose} will clear the window.
Look at gtklayout.c */
GTK_WIDGET_SET_FLAGS (viewport, GTK_APP_PAINTABLE);
viewport->back_pixmap = NULL;
viewport->child = NULL;
viewport->last_entered = NULL;
viewport->draw_resize_idle_id = 0;
viewport->anchor = NULL;
viewport->anchor_idle_id = 0;
viewport->findtext_state = a_Findtext_state_new ();
viewport->selection = a_Selection_new ();
viewport->anchors_table = g_hash_table_new (g_str_hash, g_str_equal);
viewport->draw_areas = NULL;
viewport->num_draw_areas = 0;
viewport->num_draw_areas_max = 4;
DBG_OBJ_ASSOC (viewport->findtext_state, viewport);
DBG_OBJ_ASSOC (viewport->selection, viewport);
}
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;
}
static void
gdl_dock_item_grip_instance_init (GdlDockItemGrip *grip)
{
GtkWidget *image;
GTK_WIDGET_SET_FLAGS (grip, GTK_NO_WINDOW);
grip->_priv = g_new0 (GdlDockItemGripPrivate, 1);
grip->_priv->icon_pixbuf_valid = FALSE;
grip->_priv->icon_pixbuf = NULL;
grip->_priv->title_layout = NULL;
gtk_widget_push_composite_child ();
grip->_priv->close_button = gtk_button_new ();
gtk_widget_pop_composite_child ();
GTK_WIDGET_UNSET_FLAGS (grip->_priv->close_button, GTK_CAN_FOCUS);
gtk_widget_set_parent (grip->_priv->close_button, GTK_WIDGET (grip));
gtk_button_set_relief (GTK_BUTTON (grip->_priv->close_button), GTK_RELIEF_NONE);
gtk_widget_show (grip->_priv->close_button);
image = gtk_image_new_from_stock (GDL_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (grip->_priv->close_button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (grip->_priv->close_button), "clicked",
G_CALLBACK (gdl_dock_item_grip_close_clicked), grip);
gtk_widget_push_composite_child ();
grip->_priv->iconify_button = gtk_button_new ();
gtk_widget_pop_composite_child ();
GTK_WIDGET_UNSET_FLAGS (grip->_priv->iconify_button, GTK_CAN_FOCUS);
gtk_widget_set_parent (grip->_priv->iconify_button, GTK_WIDGET (grip));
gtk_button_set_relief (GTK_BUTTON (grip->_priv->iconify_button), GTK_RELIEF_NONE);
gtk_widget_show (grip->_priv->iconify_button);
image = gtk_image_new_from_stock (GDL_STOCK_MENU_RIGHT, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (grip->_priv->iconify_button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (grip->_priv->iconify_button), "clicked",
G_CALLBACK (gdl_dock_item_grip_iconify_clicked), grip);
grip->_priv->tooltips = gtk_tooltips_new ();
g_object_ref (grip->_priv->tooltips);
gtk_object_sink (GTK_OBJECT (grip->_priv->tooltips));
gtk_tooltips_set_tip (grip->_priv->tooltips, grip->_priv->iconify_button,
_("Iconify"), _("Iconify this dock"));
gtk_tooltips_set_tip (grip->_priv->tooltips, grip->_priv->close_button,
_("Close"), _("Close this dock"));
}
static void
sp_button_init (SPButton *button)
{
button->action = NULL;
button->doubleclick_action = NULL;
button->tooltips = NULL;
gtk_container_set_border_width (GTK_CONTAINER (button), 0);
GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (button), GTK_CAN_FOCUS);
GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (button), GTK_CAN_DEFAULT);
g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (sp_button_perform_action), NULL);
g_signal_connect_after (G_OBJECT (button), "event", G_CALLBACK (sp_button_process_event), NULL);
}
static gint
canvas_focus_out_event (GtkWidget *widget,
GdkEventFocus *event)
{
GnomeCanvas *canvas;
ECanvas *ecanvas;
GdkEvent full_event = { 0 };
canvas = GNOME_CANVAS (widget);
ecanvas = E_CANVAS (widget);
/* XXX Can't access flags directly anymore, but is it really needed?
* If so, could we call gtk_widget_send_focus_change() instead? */
#if 0
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
#endif
gtk_im_context_focus_out (ecanvas->im_context);
if (canvas->focused_item) {
full_event.type = event->type;
full_event.focus_change = *event;
return canvas_emit_event (canvas, &full_event);
} else {
return FALSE;
}
}
static void
mate_druid_unmap (GtkWidget *widget)
{
MateDruid *druid;
g_return_if_fail (widget != NULL);
g_return_if_fail (MATE_IS_DRUID (widget));
druid = MATE_DRUID (widget);
GTK_WIDGET_UNSET_FLAGS (druid, GTK_MAPPED);
#if 0
gtk_widget_unmap (druid->back);
if (druid->_priv->show_finish)
gtk_widget_unmap (druid->finish);
else
gtk_widget_unmap (druid->next);
gtk_widget_unmap (druid->cancel);
if (druid->_priv->show_help)
gtk_widget_unmap (druid->help);
#endif
gtk_widget_unmap (druid->_priv->bbox);
if (druid->_priv->current &&
GTK_WIDGET_VISIBLE (druid->_priv->current) &&
GTK_WIDGET_MAPPED (druid->_priv->current))
gtk_widget_unmap (GTK_WIDGET (druid->_priv->current));
}
static GtkWidget *toolbar_add_zoom(GtkWidget *box) // Add zoom combo box
{
int i;
static char *txt[] = { "10%", "20%", "25%", "33%", "50%", "100%",
"200%", "300%", "400%", "800%", "1200%", "1600%", "2000%", NULL };
GtkWidget *combo, *combo_entry;
GList *combo_list = NULL;
combo = gtk_combo_new();
gtk_combo_set_value_in_list (GTK_COMBO (combo), FALSE, FALSE);
gtk_widget_show (combo);
combo_entry = GTK_COMBO (combo)->entry;
GTK_WIDGET_UNSET_FLAGS (combo_entry, GTK_CAN_FOCUS);
gtk_widget_set_usize(GTK_COMBO(combo)->button, 18, -1);
#if GTK_MAJOR_VERSION == 1
gtk_widget_set_usize(combo, 75, -1);
#else /* #if GTK_MAJOR_VERSION == 2 */
gtk_entry_set_width_chars(GTK_ENTRY(combo_entry), 6);
#endif
gtk_entry_set_editable( GTK_ENTRY(combo_entry), FALSE );
for ( i=0; txt[i]; i++ ) combo_list = g_list_append( combo_list, txt[i] );
gtk_combo_set_popdown_strings( GTK_COMBO(combo), combo_list );
g_list_free( combo_list );
gtk_entry_set_text( GTK_ENTRY(combo_entry), "100%" );
pack(box, combo);
return (combo);
}
/* Zru¹ení GDK/X oken widgetu */
static void gtk_ev_unrealize(GtkWidget *widget)
{
GtkEv *ev;
g_return_if_fail(GTK_IS_EV(widget));
ev = GTK_EV(widget);
/* Schovat okna */
if(GTK_WIDGET_MAPPED(widget))
gtk_widget_unmap(widget);
GTK_WIDGET_UNSET_FLAGS(widget, GTK_MAPPED);
/* Zru¹it vnitøní okno (GtkEv.ev_win) */
if(ev->ev_win) {
gdk_window_set_user_data(ev->ev_win, NULL);
gdk_window_destroy(ev->ev_win);
ev->ev_win = NULL;
}
/* Zru¹it hlavní okno widgetu (GtkEv.window), zru¹it pøíznak realizace */
if(GTK_WIDGET_CLASS(parent_class))
GTK_WIDGET_CLASS(parent_class)->unrealize(widget);
}
/* Cut and paste from gtkwindow.c */
static void
send_focus_change (GtkWidget *widget,
gboolean in)
{
GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
#if !GTK_CHECK_VERSION (2,21,0)
g_object_ref (widget);
if (in)
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
else
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
#endif
fevent->focus_change.type = GDK_FOCUS_CHANGE;
fevent->focus_change.window = g_object_ref (gtk_widget_get_window (widget));
fevent->focus_change.in = in;
#if !GTK_CHECK_VERSION (2,21,0)
gtk_widget_event (widget, fevent);
g_object_notify (G_OBJECT (widget), "has-focus");
g_object_unref (widget);
#else
gtk_widget_send_focus_change (widget, fevent);
#endif
gdk_event_free (fevent);
}
void gtk_widget_set_can_focus(GtkWidget* wid, gboolean can)
{
if(can)
GTK_WIDGET_SET_FLAGS(wid, GTK_CAN_FOCUS);
else
GTK_WIDGET_UNSET_FLAGS(wid, GTK_CAN_FOCUS);
}
void
_exo_gtk_widget_send_focus_change (GtkWidget *widget,
gboolean in)
{
GdkEvent *fevent;
g_object_ref (G_OBJECT (widget));
if (in)
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
else
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
fevent = gdk_event_new (GDK_FOCUS_CHANGE);
fevent->focus_change.type = GDK_FOCUS_CHANGE;
fevent->focus_change.window = g_object_ref (widget->window);
fevent->focus_change.in = in;
gtk_widget_event (widget, fevent);
g_object_notify (G_OBJECT (widget), "has-focus");
g_object_unref (G_OBJECT (widget));
gdk_event_free (fevent);
}
void
panel_menu_button_set_dnd_enabled (PanelMenuButton *button,
gboolean dnd_enabled)
{
g_return_if_fail (PANEL_IS_MENU_BUTTON (button));
dnd_enabled = dnd_enabled != FALSE;
if (button->priv->dnd_enabled == dnd_enabled)
return;
if (dnd_enabled) {
static GtkTargetEntry dnd_targets [] = {
{ "application/x-panel-applet-internal", 0, 0 }
};
char *icon;
GTK_WIDGET_UNSET_FLAGS (button, GTK_NO_WINDOW);
gtk_drag_source_set (GTK_WIDGET (button), GDK_BUTTON1_MASK,
dnd_targets, 1,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
icon = panel_menu_button_get_icon (button);
if (icon != NULL) {
gtk_drag_source_set_icon_name (GTK_WIDGET (button),
icon);
g_free (icon);
}
GTK_WIDGET_SET_FLAGS (button, GTK_NO_WINDOW);
} else
gtk_drag_source_unset (GTK_WIDGET (button));
}
static void zbar_gtk_unrealize (GtkWidget *widget)
{
if(GTK_WIDGET_MAPPED(widget))
gtk_widget_unmap(widget);
ZBarGtk *self = ZBAR_GTK(widget);
if(!self->_private)
return;
ZBarGtkPrivate *zbar = ZBAR_GTK_PRIVATE(self->_private);
if(zbar->video_enabled) {
zbar->video_enabled = FALSE;
GValue *msg = zbar_gtk_new_value(G_TYPE_INT);
g_value_set_int(msg, 0);
g_async_queue_push(zbar->queue, msg);
}
zbar_window_attach(zbar->window, NULL, 0);
GTK_WIDGET_UNSET_FLAGS(widget, GTK_REALIZED);
gdk_window_set_user_data(widget->window, NULL);
gdk_window_destroy(widget->window);
widget->window = NULL;
}
static void zbar_gtk_realize (GtkWidget *widget)
{
ZBarGtk *self = ZBAR_GTK(widget);
if(!self->_private)
return;
ZBarGtkPrivate *zbar = ZBAR_GTK_PRIVATE(self->_private);
GTK_WIDGET_UNSET_FLAGS(widget, GTK_DOUBLE_BUFFERED);
GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
GdkWindowAttr attributes;
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.event_mask = (gtk_widget_get_events(widget) |
GDK_EXPOSURE_MASK);
widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
&attributes,
GDK_WA_X | GDK_WA_Y);
gdk_window_set_user_data(widget->window, widget);
gdk_window_set_back_pixmap(widget->window, NULL, TRUE);
/* attach zbar_window to underlying X window */
if(zbar_window_attach(zbar->window,
gdk_x11_drawable_get_xdisplay(widget->window),
gdk_x11_drawable_get_xid(widget->window)))
zbar_window_error_spew(zbar->window, 0);
}
/* Object initialization function for the image view */
static void
image_view_instance_init (ImageView *view)
{
ImageViewPrivate *priv;
priv = g_new0 (ImageViewPrivate, 1);
view->priv = priv;
GTK_WIDGET_UNSET_FLAGS (view, GTK_NO_WINDOW);
GTK_WIDGET_SET_FLAGS (view, GTK_CAN_FOCUS);
priv->pixbuf = NULL;
priv->zoomx = priv->zoomy = 1.0;
priv->hadj = NULL;
priv->vadj = NULL;
priv->uta = NULL;
/* Defaults for rendering */
priv->interp_type = GDK_INTERP_BILINEAR;
priv->check_type = CHECK_TYPE_MIDTONE;
priv->check_size = CHECK_SIZE_LARGE;
priv->dither = GDK_RGB_DITHER_MAX;
/* We don't want to be double-buffered as we are SuperSmart(tm) */
gtk_widget_set_double_buffered (GTK_WIDGET (view), FALSE);
}
static void
gtk_pizza_init (GtkPizza *pizza)
{
GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);
pizza->shadow_type = GTK_MYSHADOW_NONE;
pizza->children = NULL;
pizza->width = 20;
pizza->height = 20;
pizza->bin_window = NULL;
pizza->xoffset = 0;
pizza->yoffset = 0;
pizza->configure_serial = 0;
pizza->scroll_x = 0;
pizza->scroll_y = 0;
pizza->visibility = GDK_VISIBILITY_PARTIAL;
pizza->clear_on_draw = TRUE;
pizza->use_filter = TRUE;
pizza->external_expose = FALSE;
}
static void
awt_gtk_panel_init (AWTGtkPanel *panel)
{
GTK_WIDGET_UNSET_FLAGS (panel, GTK_NO_WINDOW);
panel->children = NULL;
}
/* The window is being destroyed. */
static void
vga_unrealize(GtkWidget *widget)
{
VGAText * vga;
#ifdef VGA_DEBUG
fprintf(stderr, "vga_unrealize()\n");
#endif
g_return_if_fail(widget != NULL);
g_return_if_fail(VGA_IS_TEXT(widget));
vga = VGA_TEXT(widget);
if (GTK_WIDGET_MAPPED(widget))
{
gtk_widget_unmap(widget);
}
/* Remove the GDK Window */
if (widget->window != NULL)
{
gdk_window_destroy(widget->window);
widget->window = NULL;
}
/* Mark that we no longer have a GDK window */
GTK_WIDGET_UNSET_FLAGS(widget, GTK_REALIZED);
}
tile_expose (GtkWidget * widget, GdkEventExpose * event)
#endif
{
/* FIXME: there ought to be a better way to prevent the focus from being rendered. */
gboolean has_focus;
gboolean retval;
if ((has_focus = gtk_widget_has_focus (widget)))
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_FOCUSED);
#else
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
retval = (*GTK_WIDGET_CLASS (tile_parent_class)->draw) (widget, cr);
#else
retval = (*GTK_WIDGET_CLASS (tile_parent_class)->expose_event) (widget, event);
#endif
if (has_focus)
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_FOCUSED, TRUE);
#else
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
#endif
return retval;
}
static void
gtk_check_item_init (GtkCheckItem *check_item)
{
GTK_WIDGET_SET_FLAGS (check_item, GTK_NO_WINDOW);
GTK_WIDGET_UNSET_FLAGS (check_item, GTK_RECEIVES_DEFAULT);
GTK_TOGGLE_BUTTON (check_item)->draw_indicator = TRUE;
}
GtkWidget *
nh_message_new()
{
GtkWidget *message_h;
GtkWidget *sw;
GtkTextIter iter;
GtkTextBuffer *t;
message_h = gtk_handle_box_new();
GTK_HANDLE_BOX(message_h)->shrink_on_detach = 1;
message_text = gtk_text_view_new();
gtk_widget_show(message_text);
GTK_WIDGET_UNSET_FLAGS(message_text, GTK_CAN_FOCUS);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(message_text), GTK_WRAP_WORD);
t = gtk_text_view_get_buffer(GTK_TEXT_VIEW(message_text));
gtk_text_buffer_create_tag(t, "warning", "foreground", "red", NULL);
gtk_text_buffer_get_end_iter(t, &iter);
gtk_text_buffer_create_mark(t, "nh_end", &iter, FALSE);
sw = nh_gtk_new_and_add(gtk_scrolled_window_new(NULL, NULL), message_h, "");
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(sw), message_text);
return message_h;
}
void init_app( App *a )
{
GtkWidget *menubar;
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group = gtk_accel_group_new();
signed int nitems = sizeof ( menu_items ) / sizeof ( menu_items[0] );
GtkWidget *vbox, *hbox;
// Create the top-level root window
a->rootwindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_signal_connect( GTK_OBJECT( a->rootwindow ), "delete_event", gtk_main_quit,
NULL );
// A toplevel box to hold things
vbox = gtk_vbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER( a->rootwindow ), vbox );
// Construct the main menu structure
item_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>", accel_group );
gtk_item_factory_create_items( item_factory, (guint) nitems, menu_items, NULL );
gtk_window_add_accel_group( GTK_WINDOW( a->rootwindow ), accel_group );
menubar = gtk_item_factory_get_widget( item_factory, "<main>" );
gtk_box_pack_start( GTK_BOX( vbox ), menubar, FALSE, FALSE, 0 );
gtk_widget_show( menubar );
// Fiddle with boxes to effect an indent from the edges of the root window
hbox = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, TRUE, TRUE, 10 );
vbox = gtk_vbox_new( FALSE, 10 );
gtk_box_pack_start( GTK_BOX( hbox ), vbox, TRUE, TRUE, 10 );
// Add an area to plot into
a->plotwindow = gtk_drawing_area_new();
a->plotwindow_pixmap = NULL;
#if TO_PIXMAP != 1
// Turn off double buffering if we are plotting direct to the plotwindow
// in setup_plot_drawable().
//
GTK_WIDGET_UNSET_FLAGS( a->plotwindow, GTK_DOUBLE_BUFFERED );
#endif
// By experiment, 3x3 seems to be the smallest size plplot can cope with.
// Here we utilise the side effect that gtk_widget_set_size_request()
// effectively sets the minimum size of the widget.
//
gtk_widget_set_size_request( a->plotwindow, 3, 3 );
gtk_box_pack_start( GTK_BOX( vbox ), a->plotwindow, TRUE, TRUE, 0 );
// Set the initial size of the application
gtk_window_set_default_size( GTK_WINDOW( a->rootwindow ), APP_INITIAL_WIDTH, APP_INITIAL_HEIGHT );
g_signal_connect( G_OBJECT( a->plotwindow ), "configure_event",
G_CALLBACK( ev_plotwindow_conf ), NULL );
g_signal_connect( G_OBJECT( a->plotwindow ), "expose_event",
G_CALLBACK( ev_plotwindow_expose ), NULL );
gtk_widget_show_all( a->rootwindow );
}
wxSize wxButton::DoGetBestSize() const
{
// the default button in wxGTK is bigger than the other ones because of an
// extra border around it, but we don't want to take it into account in
// our size calculations (otherwsie the result is visually ugly), so
// always return the size of non default button from here
const bool isDefault = GTK_WIDGET_HAS_DEFAULT(m_widget);
if ( isDefault )
{
// temporarily unset default flag
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_DEFAULT );
}
wxSize ret( wxControl::DoGetBestSize() );
if ( isDefault )
{
// set it back again
GTK_WIDGET_SET_FLAGS( m_widget, GTK_CAN_DEFAULT );
}
ret.x += 10; // add a few pixels for sloppy (but common) themes
if (!HasFlag(wxBU_EXACTFIT))
{
wxSize defaultSize = GetDefaultSize();
if (ret.x < defaultSize.x) ret.x = defaultSize.x;
if (ret.y < defaultSize.y) ret.y = defaultSize.y;
}
CacheBestSize(ret);
return ret;
}
void ZLGtkApplicationWindow::addToolbarItem(ZLApplication::Toolbar::ItemPtr item) {
if (item->type() == ZLApplication::Toolbar::Item::BUTTON) {
const ZLApplication::Toolbar::ButtonItem &buttonItem = (const ZLApplication::Toolbar::ButtonItem&)*item;
static const std::string imagePrefix = ZLibrary::ApplicationImageDirectory() + ZLibrary::FileNameDelimiter;
GtkWidget *image = gtk_image_new_from_file((imagePrefix + buttonItem.iconName() + ".png").c_str());
GtkWidget *button = gtk_button_new();
gtk_button_set_relief((GtkButton*)button, GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
gtk_container_add(GTK_CONTAINER(button), image);
// toolbar with standard buttons is too wide for zaurus screen
GdkImage *gdkImage = GTK_IMAGE(image)->data.image.image;
int w = gdkImage->width;
int h = gdkImage->height;
gtk_widget_set_usize(button, w + 6, h + 6);
gtk_container_add(GTK_CONTAINER(myToolbar), button);
shared_ptr<ZLApplication::Action> action = application().action(buttonItem.actionId());
if (!action.isNull()) {
ZLGtkSignalUtil::connectSignal(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(actionSlot), &*action);
}
myButtons[item] = button;
gtk_widget_show_all(GTK_WIDGET(button));
}
}
GList *
get_children (GtkWidget *submenu)
{
GList *children;
children = gtk_container_get_children (GTK_CONTAINER (submenu));
if (g_list_length (children) == 0)
{
/*
* If menu is empty it may be because the menu items are created only
* on demand. For example, in gnome-panel the menu items are created
* only when "show" signal is emitted on the menu.
*
* The following hack forces the menu items to be created.
*/
if (!GTK_WIDGET_VISIBLE (submenu))
{
GTK_WIDGET_SET_FLAGS (submenu, GTK_VISIBLE);
g_signal_emit_by_name (submenu, "show");
GTK_WIDGET_UNSET_FLAGS (submenu, GTK_VISIBLE);
}
g_list_free (children);
children = gtk_container_get_children (GTK_CONTAINER (submenu));
}
return children;
}
static void cache_manager_render_dialog(GtkWidget *widget, const gchar *path)
{
CleanData *cd;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
cd = g_new0(CleanData, 1);
cd->gd = generic_dialog_new(_("Create thumbnails"),
"create_thumbnails",
widget, FALSE,
NULL, cd);
gtk_window_set_default_size(GTK_WINDOW(cd->gd->dialog), PURGE_DIALOG_WIDTH, -1);
cd->gd->cancel_cb = cache_manager_render_close_cb;
cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, NULL,
cache_manager_render_close_cb, FALSE);
cd->button_start = generic_dialog_add_button(cd->gd, GTK_STOCK_OK, _("S_tart"),
cache_manager_render_start_cb, FALSE);
cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, NULL,
cache_manager_render_stop_cb, FALSE);
gtk_widget_set_sensitive(cd->button_stop, FALSE);
generic_dialog_add_message(cd->gd, NULL, _("Create thumbnails"), NULL);
hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
pref_spacer(hbox, PREF_PAD_INDENT);
cd->group = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
hbox = pref_box_new(cd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
label = tab_completion_new(&cd->entry, path, NULL, NULL);
tab_completion_add_select_button(cd->entry,_("Select folder") , TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
pref_checkbox_new_int(cd->group, _("Include subfolders"), FALSE, &cd->recurse);
button = pref_checkbox_new_int(cd->group, _("Store thumbnails local to source images"), FALSE, &cd->local);
gtk_widget_set_sensitive(button, options->thumbnails.spec_standard);
pref_line(cd->gd->vbox, PREF_PAD_SPACE);
hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
cd->progress = gtk_entry_new();
GTK_WIDGET_UNSET_FLAGS(cd->progress, GTK_CAN_FOCUS);
gtk_editable_set_editable(GTK_EDITABLE(cd->progress), FALSE);
gtk_entry_set_text(GTK_ENTRY(cd->progress), _("click start to begin"));
gtk_box_pack_start(GTK_BOX(hbox), cd->progress, TRUE, TRUE, 0);
gtk_widget_show(cd->progress);
cd->spinner = spinner_new(NULL, -1);
gtk_box_pack_start(GTK_BOX(hbox), cd->spinner, FALSE, FALSE, 0);
gtk_widget_show(cd->spinner);
cd->list = NULL;
gtk_widget_show(cd->gd->dialog);
}
//__________________________________________________________________
void _HYPlatformButton::_SetButtonKind (unsigned char k)
{
if (buttonControl)
if (k==HY_BUTTON_OK)
GTK_WIDGET_SET_FLAGS (buttonControl, GTK_CAN_DEFAULT|GTK_HAS_DEFAULT);
else
GTK_WIDGET_UNSET_FLAGS (buttonControl, GTK_CAN_DEFAULT|GTK_HAS_DEFAULT);
}
void
go_gtk_widget_disable_focus (GtkWidget *w)
{
if (GTK_IS_CONTAINER (w))
gtk_container_foreach (GTK_CONTAINER (w),
(GtkCallback) go_gtk_widget_disable_focus, NULL);
GTK_WIDGET_UNSET_FLAGS (w, GTK_CAN_FOCUS);
}
static void
gtk_moz_embed_init(GtkMozEmbed *embed)
{
EmbedPrivate *priv = new EmbedPrivate();
embed->data = priv;
gtk_widget_set_name(GTK_WIDGET(embed), "gtkmozembed");
GTK_WIDGET_UNSET_FLAGS(GTK_WIDGET(embed), GTK_NO_WINDOW);
}
