static gboolean gb_vim_command_cprevious (GtkWidget *active_widget, const gchar *command, const gchar *options, GError **error) { g_assert (GTK_IS_WIDGET (active_widget)); if (IDE_IS_EDITOR_PAGE (active_widget)) { IdeSourceView *source_view = ide_editor_page_get_view (IDE_EDITOR_PAGE (active_widget)); g_signal_emit_by_name (source_view, "move-error", GTK_DIR_UP); return TRUE; } else return gb_vim_set_source_view_error (error); }
gboolean gb_widget_activate_action (GtkWidget *widget, const gchar *prefix, const gchar *action_name, GVariant *parameter) { GApplication *app; GtkWidget *toplevel; GActionGroup *group = NULL; g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); g_return_val_if_fail (prefix, FALSE); g_return_val_if_fail (action_name, FALSE); app = g_application_get_default (); toplevel = gtk_widget_get_toplevel (widget); while ((group == NULL) && (widget != NULL)) { group = gtk_widget_get_action_group (widget, prefix); widget = gtk_widget_get_parent (widget); } if (!group && g_str_equal (prefix, "win") && G_IS_ACTION_GROUP (toplevel)) group = G_ACTION_GROUP (toplevel); if (!group && g_str_equal (prefix, "app") && G_IS_ACTION_GROUP (app)) group = G_ACTION_GROUP (app); if (group && g_action_group_has_action (group, action_name)) { g_action_group_activate_action (group, action_name, parameter); return TRUE; } if (parameter && g_variant_is_floating (parameter)) { parameter = g_variant_ref_sink (parameter); g_variant_unref (parameter); } return FALSE; }
void gtk_text_child_anchor_unregister_child (GtkTextChildAnchor *anchor, GtkWidget *child) { g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor)); g_return_if_fail (GTK_IS_WIDGET (child)); CHECK_IN_BUFFER (anchor); if (_gtk_anchored_child_get_layout (child)) { gtk_text_child_anchor_queue_resize (anchor, _gtk_anchored_child_get_layout (child)); } _gtk_anchored_child_set_layout (child, NULL); _gtk_widget_segment_remove (anchor->segment, child); }
static gboolean gb_vim_command_quit (GtkWidget *active_widget, const gchar *command, const gchar *options, GError **error) { g_assert (GTK_IS_WIDGET (active_widget)); if (IDE_IS_EDITOR_VIEW (active_widget)) { IdeSourceView *source_view = ide_editor_view_get_view (IDE_EDITOR_VIEW (active_widget)); dzl_gtk_widget_action (GTK_WIDGET (source_view), "editor-view", "save", NULL); } dzl_gtk_widget_action (GTK_WIDGET (active_widget), "layoutstack", "close-view", NULL); return TRUE; }
/** * gtk_expander_set_label_widget: * @expander: a #GtkExpander * @label_widget: (allow-none): the new label widget * * Set the label widget for the expander. This is the widget * that will appear embedded alongside the expander arrow. * * Since: 2.4 **/ void gtk_expander_set_label_widget (GtkExpander *expander, GtkWidget *label_widget) { GtkExpanderPrivate *priv; GtkWidget *widget; g_return_if_fail (GTK_IS_EXPANDER (expander)); g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget)); g_return_if_fail (label_widget == NULL || label_widget->parent == NULL); priv = expander->priv; if (priv->label_widget == label_widget) return; if (priv->label_widget) { gtk_widget_set_state (priv->label_widget, GTK_STATE_NORMAL); gtk_widget_unparent (priv->label_widget); } priv->label_widget = label_widget; widget = GTK_WIDGET (expander); if (label_widget) { priv->label_widget = label_widget; gtk_widget_set_parent (label_widget, widget); if (priv->prelight) gtk_widget_set_state (label_widget, GTK_STATE_PRELIGHT); } if (gtk_widget_get_visible (widget)) gtk_widget_queue_resize (widget); g_object_freeze_notify (G_OBJECT (expander)); g_object_notify (G_OBJECT (expander), "label-widget"); g_object_notify (G_OBJECT (expander), "label"); g_object_thaw_notify (G_OBJECT (expander)); }
G_MODULE_EXPORT gboolean checkbutton_handler(GtkWidget *widget, gpointer data) { gboolean state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); gint handler = (GINT)OBJ_GET((widget),"handler"); MtxGaugeFace *g = NULL; if (GTK_IS_WIDGET(gauge)) g = MTX_GAUGE_FACE(gauge); else return FALSE; if (hold_handlers) return TRUE; changed = TRUE; mtx_gauge_face_set_attribute(g,handler, state); return TRUE; }
static void on_file_view_show_popup_menu (AnjutaFileView* view, GFile* file, gboolean is_dir, guint button, guint32 time, AnjutaFileManager* file_manager) { GtkWidget *popup; GtkWidget *rename; AnjutaUI* ui = anjuta_shell_get_ui (ANJUTA_PLUGIN(file_manager)->shell, NULL); popup = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui), "/PopupFileManager"); rename = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui), "/PopupFileManager/PopupFileManagerRename"); /* TODO */ gtk_widget_hide (rename); g_return_if_fail (GTK_IS_WIDGET (popup)); gtk_menu_popup (GTK_MENU (popup), NULL, NULL, NULL, NULL, button, time); }
static void lyric_show_viewport_update_current_widget(LyricShowViewport *lsv) { if((!lsv->priv->is_pressed) && lsv->priv->current_widget) { GtkAllocation alc0,alc1; const gchar *color_string = "blue"; #if GTK_CHECK_VERSION(3,2,0) GdkRGBA color = {0}; gdk_rgba_parse(&color,color_string); #else GdkColor color = {0}; gdk_color_parse(color_string,&color); #endif if(lsv->priv->pre_widget && GTK_IS_WIDGET(lsv->priv->pre_widget) && lsv->priv->current_widget !=lsv->priv->pre_widget) { #if GTK_CHECK_VERSION(3,2,0) gtk_widget_override_color(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,NULL); gtk_widget_set_state_flags(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,FALSE); #else gtk_widget_modify_fg(lsv->priv->pre_widget,GTK_STATE_ACTIVE,NULL); gtk_widget_set_state(lsv->priv->pre_widget,GTK_STATE_NORMAL); #endif } #if GTK_CHECK_VERSION(3,2,0) gtk_widget_override_color(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,&color); gtk_widget_set_state_flags(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,FALSE); #else gtk_widget_modify_fg(lsv->priv->current_widget,GTK_STATE_ACTIVE,&color); gtk_widget_set_state(lsv->priv->current_widget,GTK_STATE_ACTIVE); #endif gtk_widget_get_allocation(lsv->priv->current_widget,&alc0); gtk_widget_get_allocation(lsv->priv->lyricbox,&alc1); lsv->priv->pos = (alc0.y - alc1.y)+alc0.height/2.0; gtk_widget_queue_resize(GTK_WIDGET(lsv)); } }
static void on_workbench_set_focus (GbCommandProvider *provider, GtkWidget *widget, GbWorkbench *workbench) { g_return_if_fail (GB_IS_COMMAND_PROVIDER (provider)); g_return_if_fail (GB_IS_WORKBENCH (workbench)); g_return_if_fail (!widget || GTK_IS_WIDGET (widget)); /* walk the hierarchy to find a tab */ if (widget) while (!GB_IS_VIEW (widget)) if (!(widget = gtk_widget_get_parent (widget))) break; if (GB_IS_VIEW (widget)) gb_command_provider_set_active_view (provider, GB_VIEW (widget)); }
static void _lib_backgroundjobs_progress(dt_lib_module_t *self, const guint *key, double progress) { if(!darktable.control->running) return; dt_lib_backgroundjobs_t *d = (dt_lib_backgroundjobs_t*)self->data; gboolean i_own_lock = dt_control_gdk_lock(); dt_bgjob_t *j = (dt_bgjob_t*)g_hash_table_lookup(d->jobs, key); if(j) { /* check if progress is above 1.0 and destroy bgjob if finished */ /* FIXME: actually we are having some rounding issues, where the */ /* FIXME: last item doesn't bring to total to 1.0 flat */ /* FIXME: so this is why we have the ugly kludge below */ if (progress > 0.999999) { if (GTK_IS_WIDGET(j->widget)) gtk_container_remove( GTK_CONTAINER(d->jobbox), j->widget ); #ifdef HAVE_UNITY unity_launcher_entry_set_progress( j->darktable_launcher, 1.0 ); unity_launcher_entry_set_progress_visible( j->darktable_launcher, FALSE ); #endif #ifdef MAC_INTEGRATION gtk_osxapplication_attention_request(g_object_new(GTK_TYPE_OSX_APPLICATION, NULL), INFO_REQUEST); #endif /* hide jobbox if theres no jobs left */ if (g_list_length(gtk_container_get_children(GTK_CONTAINER(d->jobbox))) == 0 ) gtk_widget_hide(d->jobbox); } else { if( j->type == 0 ) gtk_progress_bar_set_fraction( GTK_PROGRESS_BAR(j->progressbar), progress ); #ifdef HAVE_UNITY unity_launcher_entry_set_progress( j->darktable_launcher, progress ); #endif } } if(i_own_lock) dt_control_gdk_unlock(); }
GList * nautilus_menu_provider_get_file_items (NautilusMenuProvider *provider, GtkWidget *window, GList *files) { NautilusMenuProviderInterface *iface; iface = NAUTILUS_MENU_PROVIDER_GET_IFACE (provider); g_return_val_if_fail (NAUTILUS_IS_MENU_PROVIDER (provider), NULL); g_return_val_if_fail (GTK_IS_WIDGET (window), NULL); if (iface->get_file_items != NULL) { return iface->get_file_items (provider, window, files); } return NULL; }
/** * gel_ui_widget_disable_drop: * @widget: A #GtkWidget * * Disables DnD functions added by gel_ui_widget_enable_drop on @widget */ void gel_ui_widget_disable_drop(GtkWidget *widget) { g_return_if_fail(GTK_IS_WIDGET(widget)); if (g_object_get_data((GObject *) widget, "gel-ui-dnd-callback") == NULL) { g_warning(_("Widget has not been made droppable by GelUI, ignoring.")); return; } gtk_drag_dest_unset(widget); g_object_set_data((GObject *) widget, "gel-ui-dnd-callback", NULL); g_object_set_data((GObject *) widget, "gel-ui-dnd-user-data", NULL); g_signal_handlers_disconnect_by_func(widget, __gel_ui_drag_drop_cb, NULL); g_signal_handlers_disconnect_by_func(widget, __gel_ui_drag_data_received, NULL); }
void gdict_show_pref_dialog (GtkWidget *parent, const gchar *title, GdictSourceLoader *loader) { GtkWidget *dialog; g_return_if_fail (GTK_IS_WIDGET (parent)); g_return_if_fail (GDICT_IS_SOURCE_LOADER (loader)); if (parent != NULL) dialog = g_object_get_data (G_OBJECT (parent), "gdict-pref-dialog"); else dialog = global_dialog; if (dialog == NULL) { dialog = g_object_new (GDICT_TYPE_PREF_DIALOG, "source-loader", loader, "title", title, NULL); g_object_ref_sink (dialog); g_signal_connect (dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); if (parent != NULL && GTK_IS_WINDOW (parent)) { gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent)); gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE); g_object_set_data_full (G_OBJECT (parent), "gdict-pref-dialog", dialog, g_object_unref); } else global_dialog = dialog; } gtk_window_set_screen (GTK_WINDOW (dialog), gtk_widget_get_screen (parent)); gtk_window_present (GTK_WINDOW (dialog)); }
EXPORT gboolean close_current_gauge(GtkWidget * widget, gpointer data) { GtkWidget *tmp = NULL; GladeXML *xml = glade_get_widget_tree(widget); GtkWidget *parent = glade_xml_get_widget(xml,"gauge_frame"); if (GTK_IS_WIDGET(gauge)) { if (changed) prompt_to_save(); gtk_widget_destroy(gauge); gtk_widget_set_sensitive(glade_xml_get_widget(xml,"tab_notebook"),FALSE); gauge_loaded = FALSE; changed = FALSE; } gauge = NULL; tmp = glade_xml_get_widget(xml,"animate_frame"); gtk_widget_set_sensitive(tmp,FALSE); tmp = glade_xml_get_widget(xml,"new_gauge_menuitem"); gtk_widget_set_sensitive(tmp,TRUE); tmp = glade_xml_get_widget(xml,"load_gauge_menuitem"); gtk_widget_set_sensitive(tmp,TRUE); tmp = glade_xml_get_widget(xml,"close_gauge_menuitem"); gtk_widget_set_sensitive(tmp,FALSE); tmp = glade_xml_get_widget(xml,"save_gauge_menuitem"); gtk_widget_set_sensitive(tmp,FALSE); tmp = glade_xml_get_widget(xml,"save_as_menuitem"); gtk_widget_set_sensitive(tmp,FALSE); tmp = glade_xml_get_widget(xml,"animate_button"); gtk_widget_set_sensitive(tmp,TRUE); reset_onscreen_controls(); direct_path = FALSE; gtk_widget_show_all(parent); return (TRUE); }
static gboolean gb_vim_command_write (GtkWidget *active_widget, const gchar *command, const gchar *options, GError **error) { g_assert (GTK_IS_WIDGET (active_widget)); if (IDE_IS_EDITOR_PAGE (active_widget)) { IdeSourceView *source_view = ide_editor_page_get_view (IDE_EDITOR_PAGE (active_widget)); dzl_gtk_widget_action (GTK_WIDGET (source_view), "editor-page", "save", NULL); return TRUE; } else return gb_vim_set_source_view_error (error); }
static void refresh_window_cb (G_GNUC_UNUSED GtkWidget *widget, gpointer data) { DEBUG_FUNCTION ("refresh_window_cb"); DEBUG_ASSERT (data != NULL); GdkRectangle rect; if (GTK_IS_WIDGET(data)) { if (gtk_widget_get_window (GTK_WIDGET (data))) { rect.x = rect.y = 0; GtkAllocation allocation; gtk_widget_get_allocation (GTK_WIDGET (data), &allocation); rect.width = allocation.width; rect.height = allocation.height; gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET(data)), &rect, TRUE); } } }
GtkCssGadget * gtk_icon_helper_new_named (const char *name, GtkWidget *owner) { GtkIconHelper *result; GtkCssNode *node; g_return_val_if_fail (name != NULL, NULL); g_return_val_if_fail (GTK_IS_WIDGET (owner), NULL); node = gtk_css_node_new (); gtk_css_node_set_name (node, g_intern_string (name)); result = gtk_icon_helper_new (node, owner); g_object_unref (node); return GTK_CSS_GADGET (result); }
void ppg_util_load_ui (GtkWidget *widget, GtkActionGroup **actions, const gchar *ui_data, const gchar *first_widget, ...) { GtkUIManager *ui_manager; GtkActionGroup *action_group; GtkAccelGroup *accel_group; const gchar *name; GtkWidget **dst_widget; GError *error = NULL; GType type; va_list args; g_return_if_fail(GTK_IS_WIDGET(widget)); g_return_if_fail(ui_data != NULL); g_return_if_fail(first_widget != NULL); ui_manager = gtk_ui_manager_new(); if (!gtk_ui_manager_add_ui_from_string(ui_manager, ui_data, -1, &error)) { g_error("%s", error->message); /* Fatal */ } type = G_TYPE_FROM_INSTANCE(widget); accel_group = gtk_ui_manager_get_accel_group(ui_manager); action_group = gtk_action_group_new(g_type_name(type)); ppg_actions_load(widget, accel_group, action_group); gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); name = first_widget; va_start(args, first_widget); do { dst_widget = va_arg(args, GtkWidget**); *dst_widget = gtk_ui_manager_get_widget(ui_manager, name); } while ((name = va_arg(args, const gchar*))); if (actions) { *actions = action_group; } }
static gboolean gb_vim_command_edit (GtkWidget *active_widget, const gchar *command, const gchar *options, GError **error) { IdeWorkbench *workbench; IdeContext *context; IdeVcs *vcs; GFile *workdir; GFile *file = NULL; g_assert (GTK_IS_WIDGET (active_widget)); if (dzl_str_empty0 (options)) { dzl_gtk_widget_action (GTK_WIDGET (active_widget), "win", "open-with-dialog", NULL); return TRUE; } if (!(workbench = ide_widget_get_workbench (active_widget)) || !(context = ide_workbench_get_context (workbench)) || !(vcs = ide_context_get_vcs (context)) || !(workdir = ide_vcs_get_working_directory (vcs))) { g_set_error (error, GB_VIM_ERROR, GB_VIM_ERROR_NOT_SOURCE_VIEW, _("Failed to locate working directory")); return FALSE; } if (g_path_is_absolute (options)) file = g_file_new_for_path (options); else file = g_file_get_child (workdir, options); ide_workbench_open_files_async (workbench, &file, 1, "editor", IDE_WORKBENCH_OPEN_FLAGS_NONE, NULL, NULL, NULL); g_clear_object (&file); return TRUE; }
/** * eel_gtk_container_child_remove: * * @container: A GtkContainer widget. * @child: A non NULL child of @container. * * Remove @child from @container. The @container is resized if needed. * This is usually called from the "GtkContainer::remove" method of the * @container. The child cannot be NULL. */ void eel_gtk_container_child_remove (GtkContainer *container, GtkWidget *child) { gboolean child_was_visible; g_return_if_fail (GTK_IS_CONTAINER (container)); g_return_if_fail (GTK_IS_WIDGET (child)); g_return_if_fail (gtk_widget_get_parent (child) == GTK_WIDGET (container)); child_was_visible = gtk_widget_get_visible (child); gtk_widget_unparent (child); if (child_was_visible) { gtk_widget_queue_resize (GTK_WIDGET (container)); } }
GtkWidget * gimp_viewable_dialog_new (GimpViewable *viewable, GimpContext *context, const gchar *title, const gchar *role, const gchar *icon_name, const gchar *desc, GtkWidget *parent, GimpHelpFunc help_func, const gchar *help_id, ...) { GimpViewableDialog *dialog; va_list args; g_return_val_if_fail (viewable == NULL || GIMP_IS_VIEWABLE (viewable), NULL); g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (title != NULL, NULL); g_return_val_if_fail (role != NULL, NULL); g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent), NULL); if (! viewable) g_warning ("Use of GimpViewableDialog with a NULL viewable is depecrated!"); dialog = g_object_new (GIMP_TYPE_VIEWABLE_DIALOG, "viewable", viewable, "context", context, "title", title, "role", role, "help-func", help_func, "help-id", help_id, "icon-name", icon_name, "description", desc, "parent", parent, NULL); va_start (args, help_id); gimp_dialog_add_buttons_valist (GIMP_DIALOG (dialog), args); va_end (args); return GTK_WIDGET (dialog); }
static GtkWidget * contacts_edit_add_focus_events (GtkWidget *widget, GtkWidget *ebox, GList *widgets) { if (!ebox) { GtkWidget *align = gtk_alignment_new (0.5, 0.5, 1, 1); ebox = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (align), widget); gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 6, 6); gtk_container_add (GTK_CONTAINER (ebox), align); gtk_widget_show (align); gtk_widget_show (ebox); gtk_widget_set_name (ebox, gtk_widget_get_name (widget)); } if (!widget) return ebox; if (GTK_IS_CONTAINER (widget) && !GTK_IS_TEXT_VIEW (widget)) { GList *c, *children = gtk_container_get_children (GTK_CONTAINER (widget)); for (c = children; c; c = c->next) { contacts_edit_add_focus_events (GTK_WIDGET (c->data), ebox, widgets); } g_list_free (children); } else if (GTK_IS_WIDGET (widget)) { GList *w; g_signal_connect (G_OBJECT (widget), "focus-in-event", G_CALLBACK (contacts_edit_focus_in), ebox); g_signal_connect (G_OBJECT (widget), "focus-out-event", G_CALLBACK (contacts_edit_focus_out), ebox); for (w = widgets; w; w = w->next) { g_signal_connect (G_OBJECT (widget), "focus-in-event", G_CALLBACK (contacts_edit_focus_in), w->data); g_signal_connect (G_OBJECT (widget), "focus-out-event", G_CALLBACK (contacts_edit_focus_out), w->data); } } return ebox; }
/** * gimp_help_connect: * @widget: The widget you want to connect the help accelerator for. Will * be a #GtkWindow in most cases. * @help_func: The function which will be called if the user presses "F1". * @help_id: The @help_id which will be passed to @help_func. * @help_data: The @help_data pointer which will be passed to @help_func. * * Note that this function is automatically called by all libgimp dialog * constructors. You only have to call it for windows/dialogs you created * "manually". **/ void gimp_help_connect (GtkWidget *widget, GimpHelpFunc help_func, const gchar *help_id, gpointer help_data) { static gboolean initialized = FALSE; g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (help_func != NULL); /* set up the help signals */ if (! initialized) { GtkBindingSet *binding_set; binding_set = gtk_binding_set_by_class (g_type_class_peek (GTK_TYPE_WIDGET)); gtk_binding_entry_add_signal (binding_set, GDK_KEY_F1, 0, "show-help", 1, GTK_TYPE_WIDGET_HELP_TYPE, GIMP_WIDGET_HELP_TYPE_HELP); gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_F1, 0, "show-help", 1, GTK_TYPE_WIDGET_HELP_TYPE, GIMP_WIDGET_HELP_TYPE_HELP); initialized = TRUE; } gimp_help_set_help_data (widget, NULL, help_id); g_object_set_data (G_OBJECT (widget), "gimp-help-data", help_data); g_signal_connect (widget, "show-help", G_CALLBACK (gimp_help_callback), help_func); gtk_widget_add_events (widget, GDK_BUTTON_PRESS_MASK); }
void ucview_info_box_add_action_widget( UCViewInfoBox *box, GtkWidget *widget, gint response_id ) { ResponseData *rd; guint signal_id; g_return_if_fail( IS_UCVIEW_INFO_BOX( box ) ); g_return_if_fail( GTK_IS_WIDGET( widget ) ); rd = get_response_data( widget, TRUE ); rd->response_id = response_id; if( GTK_IS_BUTTON( widget ) ) { signal_id = g_signal_lookup( "clicked", GTK_TYPE_BUTTON ); } else { signal_id = GTK_WIDGET_GET_CLASS( widget )->activate_signal; } if( signal_id ) { GClosure *closure; closure = g_cclosure_new_object( G_CALLBACK( action_widget_activated ), G_OBJECT( box ) ); g_signal_connect_closure_by_id( widget, signal_id, 0, closure, FALSE ); } else { g_warning( "UCViewInfoBox: add_action_widget: Item not activatable" ); } if( response_id != GTK_RESPONSE_HELP ) { gtk_box_pack_start( GTK_BOX( box->priv->action_box ), widget, FALSE, FALSE, 12 ); } else { gtk_box_pack_end( GTK_BOX( box->priv->action_box ), widget, FALSE, FALSE, 12 ); } }
void gimp_dialog_factory_add_foreign (GimpDialogFactory *factory, const gchar *identifier, GtkWidget *dialog) { GimpDialogFactory *dialog_factory; GimpDialogFactoryEntry *entry; g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory)); g_return_if_fail (identifier != NULL); g_return_if_fail (GTK_IS_WIDGET (dialog)); g_return_if_fail (GTK_WIDGET_TOPLEVEL (dialog)); dialog_factory = gimp_dialog_factory_from_widget (dialog, &entry); if (dialog_factory || entry) { g_warning ("%s: dialog was created by a GimpDialogFactory", G_STRFUNC); return; } entry = gimp_dialog_factory_find_entry (factory, identifier); if (! entry) { g_warning ("%s: no entry registered for \"%s\"", G_STRFUNC, identifier); return; } if (entry->new_func) { g_warning ("%s: entry for \"%s\" has a constructor (is not foreign)", G_STRFUNC, identifier); return; } gimp_dialog_factory_set_widget_data (dialog, factory, entry); gimp_dialog_factory_add_dialog (factory, dialog); }
void go_combo_box_construct (GOComboBox *combo, GtkWidget *display_widget, GtkWidget *popdown_container, GtkWidget *popdown_focus) { GtkWidget *tearable; GtkWidget *vbox; g_return_if_fail (IS_GO_COMBO_BOX (combo)); g_return_if_fail (GTK_IS_WIDGET (display_widget)); GTK_BOX (combo)->spacing = 0; GTK_BOX (combo)->homogeneous = FALSE; combo->priv->popdown_container = popdown_container; combo->priv->display_widget = NULL; vbox = gtk_vbox_new (FALSE, 5); tearable = gtk_tearoff_menu_item_new (); g_signal_connect (tearable, "enter-notify-event", G_CALLBACK (cb_tearable_enter_leave), GINT_TO_POINTER (TRUE)); g_signal_connect (tearable, "leave-notify-event", G_CALLBACK (cb_tearable_enter_leave), GINT_TO_POINTER (FALSE)); g_signal_connect (tearable, "button-release-event", G_CALLBACK (cb_tearable_button_release), (gpointer) combo); gtk_box_pack_start (GTK_BOX (vbox), tearable, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), popdown_container, TRUE, TRUE, 0); combo->priv->tearable = tearable; g_object_set (tearable, "no-show-all", TRUE, NULL); go_combo_box_set_tearable (combo, FALSE); go_combo_box_set_relief (combo, GTK_RELIEF_NORMAL); go_combo_box_set_display (combo, display_widget); gtk_container_add (GTK_CONTAINER (combo->priv->frame), vbox); gtk_widget_show_all (combo->priv->frame); }
/*! \brief A generic function to returns the data from the representation of ECU memory. This will call an ECU specific function to do the heavy lifting \param data is either a GtkWidget pointer or a gconstpointer which contains name:value associations describng the location to return \returns the value requested or 0 if error */ G_MODULE_EXPORT gint get_ecu_data(gpointer data) { gint canID = 0; gint page = 0; gint offset = 0; DataSize size = MTX_U08; gint value = 0 ; GtkWidget *widget = NULL; gconstpointer *container = NULL; Firmware_Details *firmware = NULL; static gint (*_get_sized_data)(guint8 *, gint, DataSize, gboolean) = NULL; if (!_get_sized_data) get_symbol_f("_get_sized_data",(void*)&_get_sized_data); g_return_val_if_fail(_get_sized_data,0); firmware = DATA_GET(global_data,"firmware"); /* Sanity checking */ g_return_val_if_fail(data,0); g_return_val_if_fail(firmware,0); g_return_val_if_fail(firmware->page_params,0); g_return_val_if_fail(firmware->page_params[page],0); g_return_val_if_fail(((offset >= 0 ) && (offset < firmware->page_params[page]->length)),0); widget = (GtkWidget *)data; container = (gconstpointer *)data; if (GTK_IS_WIDGET(widget)) { canID = (GINT)OBJ_GET(widget,"canID"); page = (GINT)OBJ_GET(widget,"page"); offset = (GINT)OBJ_GET(widget,"offset"); size = (DataSize)OBJ_GET(widget,"size"); } else { canID = (GINT)DATA_GET(container,"canID"); page = (GINT)DATA_GET(container,"page"); offset = (GINT)DATA_GET(container,"offset"); size = (DataSize)DATA_GET(container,"size"); } return _get_sized_data(firmware->ecu_data[page],offset,size,firmware->bigendian); }
static void pgpug_window_content_pane_switch_page (PgpugContentPane *pane, GtkWidget *child, guint page_num, PgpugWindow *window) { g_return_if_fail (PGPUG_IS_WINDOW (window)); g_return_if_fail (PGPUG_IS_CONTENT_PANE (pane)); g_return_if_fail (GTK_IS_WIDGET (child)); /* remove all detail panes if any */ pgpug_window_detail_pane_clear (window); PgpugWindowPrivate *priv = window->priv; PgpugPane *src_pane = g_hash_table_lookup (priv->view_pane_map, child); g_return_if_fail (PGPUG_IS_PANE (src_pane)); GList *elem, *detail_pane_list = NULL; g_object_get (src_pane, "detail-panes-list", &detail_pane_list, NULL); elem = detail_pane_list; while (elem != NULL){ PgpugPane *detail_pane = PGPUG_PANE (elem->data); /* check if pane state is active */ gboolean is_inactive = g_object_get_data (G_OBJECT (detail_pane), KEY_PGPUG_WINDOW_IS_PANE_INACTIVE) != NULL; if (!is_inactive) pgpug_window_install_pane (window, detail_pane, PGPUG_PANE_DETAIL); elem = g_list_next (elem); } g_list_free (detail_pane_list); pgpug_window_rebuild_view_menu (window); DEBG_MSG ("PgpugWindow: Page has been switched to %d in the content pane", page_num); }
static gboolean dma_data_view_goto_key_press_event (GtkWidget *widget, GdkEventKey *event, DmaDataView *view) { g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); g_return_val_if_fail (IS_DMA_DATA_VIEW (view), FALSE); /* Close window */ if (event->keyval == GDK_KEY_Escape || event->keyval == GDK_KEY_Tab || event->keyval == GDK_KEY_KP_Tab || event->keyval == GDK_KEY_ISO_Left_Tab) { dma_data_view_goto_window_hide (view); return TRUE; } /* Goto to address and close window */ if (event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_ISO_Enter || event->keyval == GDK_KEY_KP_Enter) { gulong adr; const gchar *text; gchar *end; text = gtk_entry_get_text (GTK_ENTRY (view->goto_entry)); adr = strtoul (text, &end, 0); if ((*text != '\0') && (*end == '\0')) { /* Valid input goto to address */ gtk_adjustment_set_value (view->buffer_range, adr); } dma_data_view_goto_window_hide (view); return TRUE; } return FALSE; }
void gimp_dialog_factory_hide_dialog (GtkWidget *dialog) { g_return_if_fail (GTK_IS_WIDGET (dialog)); g_return_if_fail (GTK_WIDGET_TOPLEVEL (dialog)); if (! gimp_dialog_factory_from_widget (dialog, NULL)) { g_warning ("%s: dialog was not created by a GimpDialogFactory", G_STRFUNC); return; } gtk_widget_hide (dialog); if (! dialogs_shown) g_object_set_data (G_OBJECT (dialog), GIMP_DIALOG_VISIBILITY_KEY, GINT_TO_POINTER (GIMP_DIALOG_VISIBILITY_INVISIBLE)); }