static gint search_highlight(uint32_t blk_beg, uint32_t blk_end, int state) { GtkNotebook *nb = GTK_NOTEBOOK(notebook); gint page = gtk_notebook_get_current_page(nb); GtkWidget *tab; GtkWidget *label; G_CONST_RETURN gchar *text; uint32_t tab_adr, addr, offset; gint i; gint start, stop; GList *l, *elt; GtkWidget *list; GtkTreeView *view; GtkTreeModel *model; GtkListStore *store; GtkTreeIter iter; gboolean valid; GdkColor white, green; gboolean success; gdk_color_parse("White", &white); gdk_colormap_alloc_colors(gdk_colormap_get_system(), &white, 1, FALSE, FALSE, &success); gdk_color_parse("Green", &green); gdk_colormap_alloc_colors(gdk_colormap_get_system(), &green, 1, FALSE, FALSE, &success); // retrieve addr by tab name tab = gtk_notebook_get_nth_page(nb, page); label = gtk_notebook_get_tab_label(nb, tab); text = gtk_label_get_text(GTK_LABEL(label)); sscanf(text, "%06x", &tab_adr); // get list pointer (we have 1 child) l = gtk_container_get_children(GTK_CONTAINER(nb)); elt = g_list_nth(l, page); list = GTK_WIDGET(elt->data); view = GTK_TREE_VIEW(list); model = gtk_tree_view_get_model(view); store = GTK_LIST_STORE(model); // scroll mem if(!IS_BOUNDED(tab_adr, blk_beg, tab_adr + DUMP_SIZE)) { nb = GTK_NOTEBOOK(notebook); page = gtk_notebook_get_current_page(nb); offset = (blk_beg - tab_adr) & 0xfffff0; refresh_page(page, offset); while(gtk_events_pending()) gtk_main_iteration(); tab_adr += offset; tab_adr &= 0xffffff; } // change background color for(valid = gtk_tree_model_get_iter_first(model, &iter), addr = tab_adr; valid && (addr - tab_adr < DUMP_SIZE); valid = gtk_tree_model_iter_next(model, &iter), addr += 0x10) { // clear selection for(i = 0; i < 16; i++) gtk_list_store_set(store, &iter, i + COL_S0, &white, -1); if(addr + 16 <= blk_beg) continue; if(addr > blk_end) continue; start = !addr ? blk_beg : blk_beg % addr; if(start > 15) start = 0; stop = !addr ? blk_end : blk_end % addr; if(stop > 15) stop = 16; // set selection for(i = start; (i < 16) && (i < stop); i++) gtk_list_store_set(store, &iter, i + COL_S0, &green, -1); } return 0; }
static GtkWidget * make_menubar (void) { GtkWidget *w, *menu; GtkWidget *menubar = gtk_menu_bar_new (); /* FIXME: add translatable string here */ w = gtk_menu_item_new_with_label ("Menu"); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), w); gtk_widget_show (GTK_WIDGET (w)); menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), menu); w = gtk_image_menu_item_new_with_mnemonic (_("Select _Language...")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w), gtk_image_new_from_icon_name ("preferences-desktop-locale", GTK_ICON_SIZE_MENU)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), w); gtk_widget_show (GTK_WIDGET (w)); g_signal_connect (G_OBJECT (w), "activate", G_CALLBACK (activate_button), "language_button"); w = gtk_image_menu_item_new_with_mnemonic (_("Select _Session...")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w), gtk_image_new_from_icon_name ("user-desktop", GTK_ICON_SIZE_MENU)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), w); gtk_widget_show (GTK_WIDGET (w)); g_signal_connect (G_OBJECT (w), "activate", G_CALLBACK (activate_button), "session_button"); greeter_system_append_system_menu (menu); /* Add a quit/disconnect item when in xdmcp mode or flexi mode */ /* Do note that the order is important, we always want "Quit" for * flexi, even if not local (non-local xnest). and Disconnect * only for xdmcp */ if ( ! ve_string_empty (g_getenv ("MDM_FLEXI_SERVER"))) { w = gtk_image_menu_item_new_with_mnemonic (_("_Quit")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w), gtk_image_new_from_icon_name ("system-log-out", GTK_ICON_SIZE_MENU)); } else if (ve_string_empty (g_getenv ("MDM_IS_LOCAL"))) { w = gtk_image_menu_item_new_with_mnemonic (_("D_isconnect")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w), gtk_image_new_from_icon_name ("system-log-out", GTK_ICON_SIZE_MENU)); } else { w = NULL; } if (w != NULL) { GtkWidget *sep; /* add separator before the quit */ sep = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep); gtk_widget_show (GTK_WIDGET (sep)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), w); gtk_widget_show (GTK_WIDGET (w)); g_signal_connect (G_OBJECT (w), "activate", G_CALLBACK (gtk_main_quit), NULL); } g_signal_connect (G_OBJECT(gtk_menu_item_get_submenu( gtk_container_get_children(GTK_CONTAINER(menubar))->data)), "selection-done", G_CALLBACK (menubar_done), NULL); return menubar; }
void panel_menu_items_append_lock_logout (GtkWidget *menu) { GList *children; GList *last; GtkWidget *item; children = gtk_container_get_children (GTK_CONTAINER (menu)); last = g_list_last (children); if (last != NULL && GTK_IS_SEPARATOR (last->data)) item = GTK_WIDGET (last->data); else item = add_menu_separator (menu); g_list_free (children); panel_lockdown_on_notify (panel_lockdown_get (), NULL, G_OBJECT (item), panel_menu_items_lock_logout_separator_notified, item); panel_menu_items_lock_logout_separator_notified (panel_lockdown_get (), item); item = panel_menu_items_create_action_item_full (PANEL_ACTION_LOCK, NULL, NULL, TRUE); if (item != NULL) { gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_bind_property (panel_lockdown_get (), "disable-lock-screen", item, "visible", G_BINDING_SYNC_CREATE|G_BINDING_INVERT_BOOLEAN); } item = panel_menu_items_create_switch_user (FALSE); if (item != NULL) { gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_bind_property (panel_lockdown_get (), "disable-switch-user", item, "visible", G_BINDING_SYNC_CREATE|G_BINDING_INVERT_BOOLEAN); } item = panel_menu_items_create_action_item_full (PANEL_ACTION_LOGOUT, NULL, NULL, TRUE); if (item != NULL) { gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_bind_property (panel_lockdown_get (), "disable-log-out", item, "visible", G_BINDING_SYNC_CREATE|G_BINDING_INVERT_BOOLEAN); } /* FIXME: should be dynamic */ if (panel_session_manager_is_shutdown_available (panel_session_manager_get ())) { item = panel_menu_items_create_action_item_full (PANEL_ACTION_SHUTDOWN, NULL, NULL, TRUE); if (item != NULL) { GtkWidget *sep; sep = add_menu_separator (menu); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_bind_property (panel_lockdown_get (), "disable-log-out", sep, "visible", G_BINDING_SYNC_CREATE|G_BINDING_INVERT_BOOLEAN); g_object_bind_property (panel_lockdown_get (), "disable-log-out", item, "visible", G_BINDING_SYNC_CREATE|G_BINDING_INVERT_BOOLEAN); } } }
void PopupMenuGtk::show(const IntRect& rect, FrameView* view, int index) { ASSERT(client()); if (!m_popup) { m_popup = GTK_MENU(gtk_menu_new()); g_signal_connect(m_popup.get(), "unmap", G_CALLBACK(menuUnmapped), this); } else gtk_container_foreach(GTK_CONTAINER(m_popup.get()), reinterpret_cast<GtkCallback>(menuRemoveItem), this); int x, y; gdk_window_get_origin(gtk_widget_get_window(GTK_WIDGET(view->hostWindow()->platformPageClient())), &x, &y); m_menuPosition = view->contentsToWindow(rect.location()); m_menuPosition = IntPoint(m_menuPosition.x() + x, m_menuPosition.y() + y + rect.height()); m_indexMap.clear(); const int size = client()->listSize(); for (int i = 0; i < size; ++i) { GtkWidget* item; if (client()->itemIsSeparator(i)) item = gtk_separator_menu_item_new(); else item = gtk_menu_item_new_with_label(client()->itemText(i).utf8().data()); m_indexMap.add(item, i); g_signal_connect(item, "activate", G_CALLBACK(menuItemActivated), this); // FIXME: Apply the PopupMenuStyle from client()->itemStyle(i) gtk_widget_set_sensitive(item, client()->itemIsEnabled(i)); gtk_menu_shell_append(GTK_MENU_SHELL(m_popup.get()), item); gtk_widget_show(item); } gtk_menu_set_active(m_popup.get(), index); // The size calls are directly copied from gtkcombobox.c which is LGPL GtkRequisition requisition; gtk_widget_set_size_request(GTK_WIDGET(m_popup.get()), -1, -1); gtk_widget_size_request(GTK_WIDGET(m_popup.get()), &requisition); gtk_widget_set_size_request(GTK_WIDGET(m_popup.get()), std::max(rect.width(), requisition.width), -1); GList* children = gtk_container_get_children(GTK_CONTAINER(m_popup.get())); GList* p = children; if (size) for (int i = 0; i < size; i++) { if (i > index) break; GtkWidget* item = reinterpret_cast<GtkWidget*>(p->data); GtkRequisition itemRequisition; gtk_widget_get_child_requisition(item, &itemRequisition); m_menuPosition.setY(m_menuPosition.y() - itemRequisition.height); p = g_list_next(p); } else // Center vertically the empty popup in the combo box area m_menuPosition.setY(m_menuPosition.y() - rect.height() / 2); g_list_free(children); gtk_menu_popup(m_popup.get(), 0, 0, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this, 0, gtk_get_current_event_time()); }
/** update the device list */ void _lib_import_ui_devices_update(dt_lib_module_t *self) { dt_lib_import_t *d = (dt_lib_import_t*)self->data; GList *citem; /* cleanup of widgets in devices container*/ GList *item; if((item=gtk_container_get_children(GTK_CONTAINER(d->devices)))!=NULL) do { gtk_container_remove(GTK_CONTAINER(d->devices),GTK_WIDGET(item->data)); } while((item=g_list_next(item))!=NULL); /* add the rescan button */ GtkButton *scan = GTK_BUTTON(gtk_button_new_with_label(_("scan for devices"))); d->scan_devices = scan; gtk_button_set_alignment(scan, 0.05, 0.5); g_object_set(G_OBJECT(scan), "tooltip-text", _("scan for newly attached devices"), (char *)NULL); g_signal_connect (G_OBJECT(scan), "clicked",G_CALLBACK (_lib_import_scan_devices_callback), self); gtk_box_pack_start(GTK_BOX(d->devices),GTK_WIDGET(scan),TRUE,TRUE,0); gtk_box_pack_start(GTK_BOX(d->devices),GTK_WIDGET(gtk_label_new("")),TRUE,TRUE,0); uint32_t count=0; /* FIXME: Verify that it's safe to access camctl->cameras list here ? */ if( (citem = g_list_first (darktable.camctl->cameras))!=NULL) { // Add detected supported devices char buffer[512]= {0}; do { dt_camera_t *camera=(dt_camera_t *)citem->data; count++; /* add camera label */ GtkWidget *label = GTK_WIDGET (dtgtk_label_new (camera->model,DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_LEFT)); gtk_box_pack_start (GTK_BOX (d->devices),label,TRUE,TRUE,0); /* set camera summary if available */ if( camera->summary.text !=NULL && strlen(camera->summary.text) >0 ) { g_object_set(G_OBJECT(label), "tooltip-text", camera->summary.text, (char *)NULL); } else { sprintf(buffer,_("device \"%s\" connected on port \"%s\"."),camera->model,camera->port); g_object_set(G_OBJECT(label), "tooltip-text", buffer, (char *)NULL); } /* add camera actions buttons */ GtkWidget *ib=NULL,*tb=NULL; GtkWidget *vbx=gtk_vbox_new(FALSE,5); if( camera->can_import==TRUE ) { gtk_box_pack_start (GTK_BOX (vbx),(ib=gtk_button_new_with_label (_("import from camera"))),FALSE,FALSE,0); d->import_camera = GTK_BUTTON(ib); } if( camera->can_tether==TRUE ) { gtk_box_pack_start (GTK_BOX (vbx),(tb=gtk_button_new_with_label (_("tethered shoot"))),FALSE,FALSE,0); d->tethered_shoot = GTK_BUTTON(tb); } if( ib ) { g_signal_connect (G_OBJECT (ib), "clicked",G_CALLBACK (_lib_import_from_camera_callback), camera); gtk_button_set_alignment(GTK_BUTTON(ib), 0.05, 0.5); } if( tb ) { g_signal_connect (G_OBJECT (tb), "clicked",G_CALLBACK (_lib_import_tethered_callback), camera); gtk_button_set_alignment(GTK_BUTTON(tb), 0.05, 0.5); } gtk_box_pack_start (GTK_BOX (d->devices),vbx,FALSE,FALSE,0); } while ((citem=g_list_next (citem))!=NULL); } if( count == 0 ) { // No supported devices is detected lets notice user.. gtk_box_pack_start(GTK_BOX(d->devices),gtk_label_new(_("no supported devices found")),TRUE,TRUE,0); } gtk_widget_show_all(GTK_WIDGET(d->devices)); }
extern void _change_cluster_main(GtkComboBox *combo, gpointer extra) { GtkTreeModel *model; display_data_t *display_data; GtkTreeIter iter; slurmdb_cluster_rec_t *cluster_rec = NULL; char *tmp, *ui_description; GError *error = NULL; GtkWidget *node_tab = NULL; int rc; bool got_grid = 0; if (!gtk_combo_box_get_active_iter(combo, &iter)) { g_print("nothing selected\n"); return; } model = gtk_combo_box_get_model(combo); if (!model) { g_print("nothing selected\n"); return; } gtk_tree_model_get(model, &iter, 1, &cluster_rec, -1); if (!cluster_rec) { g_print("no cluster_rec pointer here!"); return; } /* From testing it doesn't appear you can get here without a legitimate change, so there isn't a need to check if we are going back to the same cluster we were just at. */ /* if (working_cluster_rec) { */ /* if (!xstrcmp(cluster_rec->name, working_cluster_rec->name)) */ /* return; */ /* } */ /* free old info under last cluster */ slurm_free_block_info_msg(g_block_info_ptr); g_block_info_ptr = NULL; slurm_free_front_end_info_msg(g_front_end_info_ptr); g_front_end_info_ptr = NULL; slurm_free_burst_buffer_info_msg(g_bb_info_ptr); g_bb_info_ptr = NULL; slurm_free_job_info_msg(g_job_info_ptr); g_job_info_ptr = NULL; slurm_free_node_info_msg(g_node_info_ptr); g_node_info_ptr = NULL; slurm_free_partition_info_msg(g_part_info_ptr); g_part_info_ptr = NULL; slurm_free_reservation_info_msg(g_resv_info_ptr); g_resv_info_ptr = NULL; slurm_free_ctl_conf(g_ctl_info_ptr); g_ctl_info_ptr = NULL; slurm_free_job_step_info_response_msg(g_step_info_ptr); g_step_info_ptr = NULL; slurm_free_topo_info_msg(g_topo_info_msg_ptr); g_topo_info_msg_ptr = NULL; /* set up working_cluster_rec */ if (cluster_dims > 1) { /* reset from a multi-dim cluster */ working_sview_config.grid_x_width = default_sview_config.grid_x_width; working_sview_config.grid_hori = default_sview_config.grid_hori; working_sview_config.grid_vert = default_sview_config.grid_vert; } gtk_table_set_col_spacings(main_grid_table, 0); gtk_table_set_row_spacings(main_grid_table, 0); if (!orig_cluster_name) orig_cluster_name = slurm_get_cluster_name(); if (!xstrcmp(cluster_rec->name, orig_cluster_name)) working_cluster_rec = NULL; else working_cluster_rec = cluster_rec; cluster_dims = slurmdb_setup_cluster_dims(); cluster_flags = slurmdb_setup_cluster_flags(); display_data = main_display_data; while (display_data++) { if (display_data->id == -1) break; if (cluster_flags & CLUSTER_FLAG_BG) { switch(display_data->id) { case BLOCK_PAGE: display_data->show = true; break; case NODE_PAGE: display_data->name = "Midplanes"; break; default: break; } } else { switch(display_data->id) { case BLOCK_PAGE: display_data->show = false; break; case NODE_PAGE: display_data->name = "Nodes"; break; default: break; } } } /* set up menu */ ui_description = _get_ui_description(); gtk_ui_manager_remove_ui(g_ui_manager, g_menu_id); if (!(g_menu_id = gtk_ui_manager_add_ui_from_string( g_ui_manager, ui_description, -1, &error))) { xfree(ui_description); g_error("building menus failed: %s", error->message); g_error_free (error); exit (0); } xfree(ui_description); /* make changes for each object */ cluster_change_block(); cluster_change_front_end(); cluster_change_resv(); cluster_change_part(); cluster_change_job(); cluster_change_node(); cluster_change_bb(); /* destroy old stuff */ if (grid_button_list) { FREE_NULL_LIST(grid_button_list); got_grid = 1; } select_g_ba_fini(); /* sorry popups can't survive a cluster change */ if (popup_list) list_flush(popup_list); if (signal_params_list) list_flush(signal_params_list); if (signal_params_list) list_flush(signal_params_list); if (g_switch_nodes_maps) free_switch_nodes_maps(g_switch_nodes_maps); /* change the node tab name if needed */ node_tab = gtk_notebook_get_nth_page( GTK_NOTEBOOK(main_notebook), NODE_PAGE); node_tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(main_notebook), node_tab); #ifdef GTK2_USE_GET_FOCUS /* ok, now we have a table which we have set up to contain an * event_box which contains the label we are interested. We * setup this label to be the focus child of the table, so all * we have to do is grab that and we are set. */ node_tab = gtk_container_get_focus_child(GTK_CONTAINER(node_tab)); #else /* See above comment. Since gtk_container_get_focus_child * doesn't exist yet we will just traverse the children until * we find the label widget and then break. */ { int i = 0; GList *children = gtk_container_get_children( GTK_CONTAINER(node_tab)); while ((node_tab = g_list_nth_data(children, i++))) { int j = 0; GList *children2 = gtk_container_get_children( GTK_CONTAINER(node_tab)); while ((node_tab = g_list_nth_data(children2, j++))) { if (GTK_IS_LABEL(node_tab)) break; } g_list_free(children2); if (node_tab) break; } g_list_free(children); } #endif if (node_tab) gtk_label_set_text(GTK_LABEL(node_tab), main_display_data[NODE_PAGE].name); /* The name in the visible tabs is easier since it is really just a button with a label on it. */ if (default_sview_config.page_check_widget[NODE_PAGE]) { gtk_button_set_label(GTK_BUTTON(default_sview_config. page_check_widget[NODE_PAGE]), main_display_data[NODE_PAGE].name); } /* reinit */ rc = get_system_stats(main_grid_table); if (rc == SLURM_SUCCESS) { /* It turns out if we didn't have the grid (cluster not responding) before the new grid doesn't get set up correctly. Redoing the system_stats fixes it. There is probably a better way of doing this, but it doesn't happen very often and isn't that bad to handle every once in a while. */ if (!got_grid) { /* I know we just did this before, but it needs to be done again here. */ FREE_NULL_LIST(grid_button_list); get_system_stats(main_grid_table); } refresh_main(NULL, NULL); } tmp = g_strdup_printf("Cluster changed to %s", cluster_rec->name); display_edit_note(tmp); g_free(tmp); }
static gboolean glade_gtk_box_configure_child (GladeFixed * fixed, GladeWidget * child, GdkRectangle * rect, GtkWidget * box) { GList *list, *children; GtkWidget *bchild; GtkAllocation allocation, bchild_allocation; gint point, trans_point, span, iter_span, position, old_position, offset, orig_offset; gboolean found = FALSE; gtk_widget_get_allocation (GTK_WIDGET (glade_widget_get_object (child)), &allocation); if (gtk_orientable_get_orientation (GTK_ORIENTABLE (box)) == GTK_ORIENTATION_HORIZONTAL) { point = fixed->mouse_x; span = allocation.width; offset = rect->x; orig_offset = fixed->child_x_origin; } else { point = fixed->mouse_y; span = allocation.height; offset = rect->y; orig_offset = fixed->child_y_origin; } glade_widget_pack_property_get (child, "position", &old_position); children = gtk_container_get_children (GTK_CONTAINER (box)); for (list = children; list; list = list->next) { bchild = list->data; if (bchild == GTK_WIDGET (glade_widget_get_object (child))) continue; /* Find the widget in the box where the center of * this rectangle fits... and set the position to that * position. */ gtk_widget_get_allocation (GTK_WIDGET (bchild), &bchild_allocation); if (gtk_orientable_get_orientation (GTK_ORIENTABLE (box)) == GTK_ORIENTATION_HORIZONTAL) { gtk_widget_translate_coordinates (GTK_WIDGET (box), bchild, point, 0, &trans_point, NULL); iter_span = bchild_allocation.width; } else { gtk_widget_translate_coordinates (GTK_WIDGET (box), bchild, 0, point, NULL, &trans_point); iter_span = bchild_allocation.height; } #if 0 gtk_container_child_get (GTK_CONTAINER (box), bchild, "position", &position, NULL); g_print ("widget: %p pos %d, point %d, trans_point %d, iter_span %d\n", bchild, position, point, trans_point, iter_span); #endif if (iter_span <= span) { found = trans_point >= 0 && trans_point < iter_span; } else { if (offset > orig_offset) found = trans_point >= iter_span - span && trans_point < iter_span; else if (offset < orig_offset) found = trans_point >= 0 && trans_point < span; } if (found) { gtk_container_child_get (GTK_CONTAINER (box), bchild, "position", &position, NULL); #if 0 g_print ("setting position of %s from %d to %d, " "(point %d iter_span %d)\n", glade_widget_get_name (child), old_position, position, trans_point, iter_span); #endif glade_widget_pack_property_set (child, "position", position); break; } } g_list_free (children); return TRUE; }
static void populate_spread_table_wrappy (EggSpreadTable *spread_table) { GList *children, *l; GtkWidget *widget, *frame; gsize i; const gchar *strings[] = { "These are", "some wrappy label", "texts", "of various", "lengths.", "They should always be", "shown", "consecutively. Except it's", "hard to say", "where exactly the", "label", "will wrap", "and where exactly", "the actual", "container", "will wrap.", "This label is really really really long !", "Let's add some more", "labels to the", "mix. Just to", "make sure we", "got something to work", "with here." }; /* Remove all children first */ children = gtk_container_get_children (GTK_CONTAINER (paper)); for (l = children; l; l = l->next) { GtkWidget *child = l->data; gtk_container_remove (GTK_CONTAINER (paper), child); } g_list_free (children); for (i = 0; i < G_N_ELEMENTS (strings); i++) { widget = gtk_label_new (strings[i]); frame = gtk_frame_new (NULL); gtk_widget_show (widget); gtk_widget_show (frame); gtk_container_add (GTK_CONTAINER (frame), widget); gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE); gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD); gtk_label_set_width_chars (GTK_LABEL (widget), 10); gtk_widget_set_halign (frame, child_halign); egg_spread_table_insert_child (EGG_SPREAD_TABLE (spread_table), frame, -1); } /* Insert an image into the mix */ if (test_image) { widget = gtk_image_new_from_file ("apple-red.png"); switch (test_image) { case IMAGE_SMALL: gtk_widget_set_size_request (widget, 100, 100); break; case IMAGE_LARGE: gtk_widget_set_size_request (widget, 150, 200); break; case IMAGE_HUGE: gtk_widget_set_size_request (widget, 200, 300); break; default: break; } frame = gtk_frame_new (NULL); gtk_widget_show (widget); gtk_widget_show (frame); gtk_container_add (GTK_CONTAINER (frame), widget); egg_spread_table_insert_child (EGG_SPREAD_TABLE (spread_table), frame, test_image_index); } }
/* This updates the box size to the given value, adding placeholders or deleting widgets as necessary. */ void gb_box_set_size (GtkWidget * widget, gint size) { GtkWidget *new_child; gint current_size = g_list_length (GTK_BOX (widget)->children); gint i; if (current_size < size) { /* This avoids any problems with redrawing the selection. */ editor_clear_selection (NULL); for (i = 0; i < size - current_size; i++) { if (GTK_IS_BUTTON_BOX (widget)) { new_child = gb_widget_new ("GtkButton", widget); GTK_WIDGET_SET_FLAGS (new_child, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (widget), new_child, TRUE, TRUE, 0); tree_add_widget (new_child); } else { new_child = editor_new_placeholder (); gtk_box_pack_start (GTK_BOX (widget), new_child, TRUE, TRUE, 0); } } } else if (current_size > size) { GList *children, *elem; GtkWidget *child; gchar *error = NULL; /* Get a list of children in the order they appear in the box, start at the end and move backwards until we find a widget that can be destroyed. If we can't find any, show a message box. */ children = gtk_container_get_children (GTK_CONTAINER (widget)); elem = g_list_last (children); while (elem) { child = elem->data; error = editor_can_delete_widget (child); if (!error) { gtk_container_remove (GTK_CONTAINER (widget), child); current_size--; if (current_size == size) break; } elem = elem->prev; } g_list_free (children); if (current_size > size) { glade_util_show_message_box (error ? error : _("Can't delete any children."), widget); } } }
GtkWidget * about_dialog_create (GimpContext *context) { static GimpAboutDialog dialog; g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); if (! dialog.dialog) { GtkWidget *widget; GtkWidget *container; GdkPixbuf *pixbuf; GList *children; gchar *copyright; dialog.n_authors = G_N_ELEMENTS (authors) - 1; pixbuf = about_dialog_load_logo (); copyright = g_strdup_printf (GIMP_COPYRIGHT, GIMP_GIT_LAST_COMMIT_YEAR); widget = g_object_new (GTK_TYPE_ABOUT_DIALOG, "role", "gimp-about", "window-position", GTK_WIN_POS_CENTER, "title", _("About GIMP"), "program-name", GIMP_ACRONYM, "version", GIMP_VERSION, "copyright", copyright, "comments", GIMP_NAME, "license", GIMP_LICENSE, "wrap-license", TRUE, "logo", pixbuf, "website", "http://www.gimp.org/", "website-label", _("Visit the GIMP website"), "authors", authors, "artists", artists, "documenters", documenters, /* Translators: insert your names here, separated by newline */ "translator-credits", _("translator-credits"), NULL); if (pixbuf) g_object_unref (pixbuf); g_free (copyright); dialog.dialog = widget; g_object_add_weak_pointer (G_OBJECT (widget), (gpointer) &dialog.dialog); g_signal_connect (widget, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_signal_connect (widget, "map", G_CALLBACK (about_dialog_map), &dialog); g_signal_connect (widget, "unmap", G_CALLBACK (about_dialog_unmap), &dialog); /* kids, don't try this at home! */ container = gtk_dialog_get_content_area (GTK_DIALOG (widget)); children = gtk_container_get_children (GTK_CONTAINER (container)); if (GTK_IS_BOX (children->data)) { about_dialog_add_animation (children->data, &dialog); #ifdef GIMP_UNSTABLE about_dialog_add_unstable_message (children->data); #endif /* GIMP_UNSTABLE */ } else g_warning ("%s: ooops, no box in this container?", G_STRLOC); g_list_free (children); } gtk_window_present (GTK_WINDOW (dialog.dialog)); return dialog.dialog; }
void dlg_preferences (GthBrowser *browser) { DialogData *data; GtkWidget *notebook; GList *children; GList *scan; int page_num; GtkWidget *list_box; GtkTreeSelection *selection; if (gth_browser_get_dialog (browser, "preferences") != NULL) { gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "preferences"))); return; } data = g_new0 (DialogData, 1); data->browser = browser; data->builder = _gtk_builder_new_from_file ("preferences.ui", NULL); data->dialog = GET_WIDGET ("preferences_dialog"); gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (data->dialog))), 0); gth_browser_set_dialog (browser, "preferences", data->dialog); gth_hook_invoke ("dlg-preferences-construct", data->dialog, data->browser, data->builder); /* widgets */ list_box = GET_WIDGET ("tabs_listbox"); notebook = GET_WIDGET ("notebook"); children = gtk_container_get_children (GTK_CONTAINER (notebook)); page_num = 0; for (scan = children; scan; scan = scan->next) { GtkWidget *child = scan->data; const char *name; GtkWidget *row; GtkWidget *box; GtkWidget *label; name = gtk_notebook_get_tab_label_text (GTK_NOTEBOOK (notebook), child); if (name == NULL) continue; if (scan != children) _gtk_list_box_add_separator (GTK_LIST_BOX (list_box)); row = gtk_list_box_row_new (); g_object_set_data (G_OBJECT (row), "gth.page_num", GINT_TO_POINTER (page_num)); gtk_widget_show (row); gtk_container_add (GTK_CONTAINER (list_box), row); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_set_border_width (GTK_CONTAINER (box), 10); gtk_widget_show (box); gtk_container_add (GTK_CONTAINER (row), box); label = gtk_label_new (name); gtk_label_set_ellipsize (GTK_LABEL(label), PANGO_ELLIPSIZE_END); gtk_widget_show (label); gtk_container_add (GTK_CONTAINER (box), label); page_num += 1; } /* Set the signals handlers. */ g_signal_connect (data->dialog, "destroy", G_CALLBACK (destroy_cb), data); g_signal_connect (list_box, "row-activated", G_CALLBACK (list_box_row_activated_cb), data); /* run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser)); gtk_widget_show (data->dialog); }
static void remove_notebook (GeditMultiNotebook *mnb, GtkWidget *notebook) { GtkWidget *parent; GtkWidget *grandpa; GList *children; GtkWidget *new_notebook; GList *current; if (mnb->priv->notebooks->next == NULL) { g_warning ("You are trying to remove the main notebook"); return; } current = g_list_find (mnb->priv->notebooks, notebook); if (current->next != NULL) { new_notebook = GTK_WIDGET (current->next->data); } else { new_notebook = GTK_WIDGET (mnb->priv->notebooks->data); } parent = gtk_widget_get_parent (notebook); /* Now we destroy the widget, we get the children of parent and we destroy parent too as the parent is an useless paned. Finally we add the child into the grand parent */ g_object_ref (notebook); mnb->priv->removing_notebook = TRUE; gtk_widget_destroy (notebook); mnb->priv->notebooks = g_list_remove (mnb->priv->notebooks, notebook); mnb->priv->removing_notebook = FALSE; children = gtk_container_get_children (GTK_CONTAINER (parent)); if (children->next != NULL) { g_warning ("The parent is not a paned"); return; } grandpa = gtk_widget_get_parent (parent); g_object_ref (children->data); gtk_container_remove (GTK_CONTAINER (parent), GTK_WIDGET (children->data)); gtk_widget_destroy (parent); gtk_container_add (GTK_CONTAINER (grandpa), GTK_WIDGET (children->data)); g_object_unref (children->data); g_list_free (children); disconnect_notebook_signals (mnb, notebook); g_signal_emit (G_OBJECT (mnb), signals[NOTEBOOK_REMOVED], 0, notebook); g_object_unref (notebook); /* Let's make the active notebook grab the focus */ gtk_widget_grab_focus (new_notebook); }
GtkWidget * about_dialog_create (GimpContext *context) { static GimpAboutDialog *dialog = NULL; g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); if (! dialog) { GtkWidget *widget; GtkWidget *container; GdkPixbuf *pixbuf; GList *children; if (gimp_pdb_lookup_procedure (context->gimp->pdb, PDB_URL_LOAD)) gtk_about_dialog_set_url_hook (about_dialog_load_url, g_object_ref (context), (GDestroyNotify) g_object_unref); dialog = g_new0 (GimpAboutDialog, 1); dialog->n_authors = G_N_ELEMENTS (authors) - 1; pixbuf = about_dialog_load_logo (); widget = g_object_new (GTK_TYPE_ABOUT_DIALOG, "role", "about-dialog", "window-position", GTK_WIN_POS_CENTER, "title", _("About GIMP"), (gtk_check_version (2, 12, 0) ? "name" : "program-name"), GIMP_ACRONYM, "version", GIMP_VERSION, "copyright", GIMP_COPYRIGHT, "comments", GIMP_NAME, "license", GIMP_LICENSE, "wrap-license", TRUE, "logo", pixbuf, "website", "http://www.gimp.org/", "website-label", _("Visit the GIMP website"), "authors", authors, "artists", artists, "documenters", documenters, /* Translators: insert your names here, * separated by newline */ "translator-credits", _("translator-credits"), NULL); if (pixbuf) g_object_unref (pixbuf); dialog->dialog = widget; g_object_add_weak_pointer (G_OBJECT (widget), (gpointer) &dialog); g_signal_connect (widget, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_signal_connect (widget, "map", G_CALLBACK (about_dialog_map), dialog); g_signal_connect (widget, "unmap", G_CALLBACK (about_dialog_unmap), dialog); /* kids, don't try this at home! */ container = GTK_DIALOG (widget)->vbox; children = gtk_container_get_children (GTK_CONTAINER (container)); if (GTK_IS_VBOX (children->data)) { about_dialog_add_animation (children->data, dialog); about_dialog_add_message (children->data); } else g_warning ("%s: ooops, no vbox in this container?", G_STRLOC); g_list_free (children); } gtk_window_present (GTK_WINDOW (dialog->dialog)); return dialog->dialog; }
static void refresh_page(int page, int offset) { GtkNotebook *nb = GTK_NOTEBOOK(notebook); GtkWidget *tab; GtkWidget *label; G_CONST_RETURN gchar *text; uint32_t addr, len = DUMP_SIZE; GList *l, *elt; GtkWidget *list; GtkTreeView *view; GtkTreeModel *model; GtkListStore *store; gchar *str; gint i; // retrieve addr by tab name tab = gtk_notebook_get_nth_page(nb, page); label = gtk_notebook_get_tab_label(nb, tab); text = gtk_label_get_text(GTK_LABEL(label)); // get list pointer (we have 1 child) l = gtk_container_get_children(GTK_CONTAINER(nb)); elt = g_list_nth(l, page); list = GTK_WIDGET(elt->data); view = GTK_TREE_VIEW(list); model = gtk_tree_view_get_model(view); store = GTK_LIST_STORE(model); // get new address sscanf(text, "%x", &addr); len = DUMP_SIZE; addr += offset; addr &= 0xffffff; // refresh only if mem changed (speed-up) #ifndef FORCE_REFRESH if(!offset) { static uint8_t old_array[DUMP_SIZE] = { 0 }; gint diff = 0; // can't use memcmp due to banking for(i = 0; i < DUMP_SIZE; i++) { uint8_t old = old_array[i]; uint8_t mem = mem_rd_byte(addr + i); if(old != mem) { old = mem; diff = !0; } } if(!diff) return; } #endif // refresh tab str = g_strdup_printf("%06x", addr); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); // and list clist_refresh(store, addr, len <= DUMP_SIZE ? len : DUMP_SIZE); // set column for(i = COL_0; i <= COL_F; i++) { GtkTreeViewColumn *col; col = gtk_tree_view_get_column(view, i); str = g_strdup_printf("%X", (addr + i - 1) & 0xf); gtk_tree_view_column_set_title(col, str); g_free(str); } }
static AtkRelationSet * gtk_label_accessible_ref_relation_set (AtkObject *obj) { GtkWidget *widget; AtkRelationSet *relation_set; g_return_val_if_fail (GTK_IS_LABEL_ACCESSIBLE (obj), NULL); widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); if (widget == NULL) return NULL; relation_set = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->ref_relation_set (obj); if (!atk_relation_set_contains (relation_set, ATK_RELATION_LABEL_FOR)) { /* Get the mnemonic widget. * The relation set is not updated if the mnemonic widget is changed */ GtkWidget *mnemonic_widget; mnemonic_widget = gtk_label_get_mnemonic_widget (GTK_LABEL (widget)); if (mnemonic_widget) { AtkObject *accessible_array[1]; AtkRelation* relation; if (!gtk_widget_get_can_focus (mnemonic_widget)) { /* * Handle the case where a GtkFileChooserButton is specified * as the mnemonic widget. use the combobox which is a child of the * GtkFileChooserButton as the mnemonic widget. See bug #359843. */ if (GTK_IS_BOX (mnemonic_widget)) { GList *list, *tmpl; list = gtk_container_get_children (GTK_CONTAINER (mnemonic_widget)); if (g_list_length (list) == 2) { tmpl = g_list_last (list); if (GTK_IS_COMBO_BOX(tmpl->data)) { mnemonic_widget = GTK_WIDGET(tmpl->data); } } g_list_free (list); } } accessible_array[0] = gtk_widget_get_accessible (mnemonic_widget); relation = atk_relation_new (accessible_array, 1, ATK_RELATION_LABEL_FOR); atk_relation_set_add (relation_set, relation); /* * Unref the relation so that it is not leaked. */ g_object_unref (relation); } } return relation_set; }
bool PopupMenuGtk::typeAheadFind(GdkEventKey* event) { // If we were given a non-printable character just skip it. gunichar unicodeCharacter = gdk_keyval_to_unicode(event->keyval); if (!unicodeCharacter) { resetTypeAheadFindState(); return false; } glong charactersWritten; GOwnPtr<gunichar2> utf16String(g_ucs4_to_utf16(&unicodeCharacter, 1, 0, &charactersWritten, 0)); if (!utf16String) { resetTypeAheadFindState(); return false; } // If the character is the same as the last character, the user is probably trying to // cycle through the menulist entries. This matches the WebCore behavior for collapsed // menulists. bool repeatingCharacter = unicodeCharacter != m_previousKeyEventCharacter; if (event->time - m_previousKeyEventTimestamp > gSearchTimeoutMs) m_currentSearchString = String(static_cast<UChar*>(utf16String.get()), charactersWritten); else if (repeatingCharacter) m_currentSearchString.append(String(static_cast<UChar*>(utf16String.get()), charactersWritten)); m_previousKeyEventTimestamp = event->time; m_previousKeyEventCharacter = unicodeCharacter; // Like the Chromium port, we case fold before searching, because // strncmp does not handle non-ASCII characters. GOwnPtr<gchar> searchStringWithCaseFolded(g_utf8_casefold(m_currentSearchString.utf8().data(), -1)); size_t prefixLength = strlen(searchStringWithCaseFolded.get()); GList* children = gtk_container_get_children(GTK_CONTAINER(m_popup.get())); if (!children) return true; // If a menu item has already been selected, start searching from the current // item down the list. This will make multiple key presses of the same character // advance the selection. GList* currentChild = children; if (m_currentlySelectedMenuItem) { currentChild = g_list_find(children, m_currentlySelectedMenuItem); if (!currentChild) { m_currentlySelectedMenuItem = 0; currentChild = children; } // Repeating characters should iterate. if (repeatingCharacter) { if (GList* nextChild = g_list_next(currentChild)) currentChild = nextChild; } } GList* firstChild = currentChild; do { currentChild = g_list_next(currentChild); if (!currentChild) currentChild = children; GOwnPtr<gchar> itemText(g_utf8_casefold(gtk_menu_item_get_label(GTK_MENU_ITEM(currentChild->data)), -1)); if (!strncmp(searchStringWithCaseFolded.get(), itemText.get(), prefixLength)) { gtk_menu_shell_select_item(GTK_MENU_SHELL(m_popup.get()), GTK_WIDGET(currentChild->data)); return true; } } while (currentChild != firstChild); return true; }
static void setup_romaji_theme_menu (GtkOptionMenu *omenu) { GtkWidget *menu = gtk_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu); gtk_widget_show (menu); // create menu items GtkWidget *menuitem = gtk_menu_item_new_with_label (_("User defined")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); menuitem = gtk_menu_item_new_with_label (_("Default")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); StyleFiles::iterator it; unsigned int i; for (i = 0, it = __style_list.begin (); it != __style_list.end (); i++, it++) { StyleLines section; if (!it->get_entry_list (section, __romaji_fund_table)) continue; menuitem = gtk_menu_item_new_with_label (_(it->get_title().c_str())); g_object_set_data (G_OBJECT (menuitem), INDEX_KEY, GINT_TO_POINTER (i)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); } // set default value g_signal_handlers_block_by_func ( G_OBJECT (omenu), (gpointer) (on_romaji_theme_menu_changed), NULL); gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), ROMAJI_THEME_INDEX_DEFAULT); if (__config_romaji_theme_file == __user_style_file.get_file_name ()) { gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), ROMAJI_THEME_INDEX_USER_DEFINED); } else { GList *node, *list = gtk_container_get_children (GTK_CONTAINER (menu)); for (i = 2, node = g_list_next (g_list_next (list)); node; i++, node = g_list_next (node)) { gint idx = GPOINTER_TO_INT ( g_object_get_data (G_OBJECT (node->data), INDEX_KEY)); if (__style_list[idx].get_file_name () == __config_romaji_theme_file) { gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), i); break; } } } g_signal_handlers_unblock_by_func ( G_OBJECT (omenu), (gpointer) (on_romaji_theme_menu_changed), NULL); }
static void wnck_selector_on_show (GtkWidget *widget, WnckSelector *selector) { GtkWidget *separator; WnckScreen *screen; WnckWorkspace *workspace; int nb_workspace; int i; GList **windows_per_workspace; GList *windows; GList *l, *children; /* Remove existing items */ children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) gtk_container_remove (GTK_CONTAINER (selector->priv->menu), l->data); g_list_free (children); if (selector->priv->window_hash) g_hash_table_destroy (selector->priv->window_hash); selector->priv->window_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free); screen = wnck_selector_get_screen (selector); nb_workspace = wnck_screen_get_workspace_count (screen); windows_per_workspace = g_malloc0 (nb_workspace * sizeof (GList *)); /* Get windows ordered by workspaces */ windows = wnck_screen_get_windows (screen); windows = g_list_sort (windows, wnck_selector_windows_compare); for (l = windows; l; l = l->next) { workspace = wnck_window_get_workspace (l->data); if (!workspace && wnck_window_is_pinned (l->data)) workspace = wnck_screen_get_active_workspace (screen); if (!workspace) continue; i = wnck_workspace_get_number (workspace); windows_per_workspace[i] = g_list_prepend (windows_per_workspace[i], l->data); } /* Add windows from the current workspace */ workspace = wnck_screen_get_active_workspace (screen); if (workspace) { i = wnck_workspace_get_number (workspace); windows_per_workspace[i] = g_list_reverse (windows_per_workspace[i]); for (l = windows_per_workspace[i]; l; l = l->next) wnck_selector_append_window (selector, l->data); g_list_free (windows_per_workspace[i]); windows_per_workspace[i] = NULL; } /* Add separator */ separator = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), separator); /* Add windows from other workspaces */ for (i = 0; i < nb_workspace; i++) { wnck_selector_add_workspace (selector, screen, i); windows_per_workspace[i] = g_list_reverse (windows_per_workspace[i]); for (l = windows_per_workspace[i]; l; l = l->next) wnck_selector_append_window (selector, l->data); g_list_free (windows_per_workspace[i]); windows_per_workspace[i] = NULL; } g_free (windows_per_workspace); selector->priv->no_windows_item = wnck_selector_item_new (selector, _("No Windows Open"), NULL); gtk_widget_set_sensitive (selector->priv->no_windows_item, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), selector->priv->no_windows_item); wnck_selector_make_menu_consistent (selector); }
void glade_gtk_box_add_child (GladeWidgetAdaptor * adaptor, GObject * object, GObject * child) { GladeWidget *gbox, *gchild; gint num_children; gchar *special_child_type; g_return_if_fail (GTK_IS_BOX (object)); g_return_if_fail (GTK_IS_WIDGET (child)); gbox = glade_widget_get_from_gobject (object); special_child_type = g_object_get_data (child, "special-child-type"); if (special_child_type && !strcmp (special_child_type, "center")) { gtk_box_set_center_widget (GTK_BOX (object), GTK_WIDGET (child)); return; } /* Try to remove the last placeholder if any, this way GtkBox`s size will not be changed. */ if (glade_widget_superuser () == FALSE && !GLADE_IS_PLACEHOLDER (child)) { GList *l, *children; GtkBox *box = GTK_BOX (object); children = gtk_container_get_children (GTK_CONTAINER (box)); for (l = g_list_last (children); l; l = g_list_previous (l)) { GtkWidget *child_widget = l->data; if (GLADE_IS_PLACEHOLDER (child_widget)) { gtk_container_remove (GTK_CONTAINER (box), child_widget); break; } } g_list_free (children); } gtk_container_add (GTK_CONTAINER (object), GTK_WIDGET (child)); num_children = glade_gtk_box_get_num_children (object); glade_widget_property_set (gbox, "size", num_children); gchild = glade_widget_get_from_gobject (child); /* The "Remove Slot" operation only makes sence on placeholders, * otherwise its a "Delete" operation on the child widget. */ if (gchild) glade_widget_set_pack_action_visible (gchild, "remove_slot", FALSE); fix_response_id_on_child (gbox, child, TRUE); if (glade_widget_superuser ()) return; /* Packing props arent around when parenting during a glade_widget_dup() */ if (gchild && glade_widget_get_packing_properties (gchild)) glade_widget_pack_property_set (gchild, "position", num_children - 1); }
static void wnck_selector_make_menu_consistent (WnckSelector *selector) { GList *l, *children; int workspace_n; GtkWidget *workspace_item; GtkWidget *separator; gboolean separator_is_first; gboolean separator_is_last; gboolean visible_window; workspace_n = -1; workspace_item = NULL; separator = NULL; separator_is_first = FALSE; separator_is_last = FALSE; visible_window = FALSE; children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) { int i; i = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (l->data), "wnck-selector-workspace-n")); if (i > 0) { workspace_n = i - 1; /* we have two consecutive workspace items => hide the first */ if (workspace_item) gtk_widget_hide (workspace_item); workspace_item = GTK_WIDGET (l->data); } else if (GTK_IS_SEPARATOR_MENU_ITEM (l->data)) { if (!visible_window) separator_is_first = TRUE; separator_is_last = TRUE; separator = GTK_WIDGET (l->data); } else if (gtk_widget_get_visible (l->data) && l->data != selector->priv->no_windows_item) { separator_is_last = FALSE; visible_window = TRUE; /* if we know of a workspace item that was not shown */ if (workspace_item) { WnckWindow *window; WnckWorkspace *workspace; window = g_object_get_data (G_OBJECT (l->data), "wnck-selector-window"); if (window) { workspace = wnck_window_get_workspace (window); if (workspace && workspace_n == wnck_workspace_get_number (workspace)) { gtk_widget_show (workspace_item); workspace_n = -1; workspace_item = NULL; } } } } /* end if (normal item) */ } g_list_free (children); /* do we have a trailing workspace item to be hidden? */ if (workspace_item) gtk_widget_hide (workspace_item); if (separator) { if (separator_is_first || separator_is_last) gtk_widget_hide (separator); else gtk_widget_show (separator); } if (visible_window) gtk_widget_hide (selector->priv->no_windows_item); else gtk_widget_show (selector->priv->no_windows_item); }
static GtkWidget * populate_menu_from_directory (GtkWidget *menu, GMenuTreeDirectory *directory) { GList *children; gboolean add_separator; GMenuTreeIter *iter; GMenuTreeItemType next_type; children = gtk_container_get_children (GTK_CONTAINER (menu)); add_separator = (children != NULL); g_list_free (children); iter = gmenu_tree_directory_iter (directory); while ((next_type = gmenu_tree_iter_next (iter)) != GMENU_TREE_ITEM_INVALID) { gpointer item = NULL; if (add_separator || next_type == GMENU_TREE_ITEM_SEPARATOR) { add_menu_separator (menu); add_separator = FALSE; } switch (next_type) { case GMENU_TREE_ITEM_DIRECTORY: item = gmenu_tree_iter_get_directory (iter); create_submenu (menu, item, NULL); break; case GMENU_TREE_ITEM_ENTRY: item = gmenu_tree_iter_get_entry (iter); create_menuitem (menu, item, NULL); break; case GMENU_TREE_ITEM_SEPARATOR : /* already added */ break; case GMENU_TREE_ITEM_ALIAS: item = gmenu_tree_iter_get_alias (iter); create_menuitem_from_alias (menu, item); break; case GMENU_TREE_ITEM_HEADER: item = gmenu_tree_iter_get_header (iter); create_header (menu, item); break; default: break; } if (item) gmenu_tree_item_unref (item); } gmenu_tree_iter_unref (iter); return menu; }
static void wnck_selector_insert_window (WnckSelector *selector, WnckWindow *window) { GtkWidget *item; WnckScreen *screen; WnckWorkspace *workspace; int workspace_n; int i; screen = wnck_selector_get_screen (selector); workspace = wnck_window_get_workspace (window); if (!workspace && !wnck_window_is_pinned (window)) return; item = wnck_selector_create_window (selector, window); if (!workspace || workspace == wnck_screen_get_active_workspace (screen)) { /* window is pinned or in the current workspace * => insert before the separator */ GList *l, *children; i = 0; children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) { if (GTK_IS_SEPARATOR_MENU_ITEM (l->data)) break; i++; } g_list_free (children); gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu), item, i); } else { workspace_n = wnck_workspace_get_number (workspace); if (workspace_n == wnck_screen_get_workspace_count (screen) - 1) /* window is in last workspace => just append */ gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), item); else { /* insert just before the next workspace item */ GList *l, *children; i = 0; children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) { int j; j = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (l->data), "wnck-selector-workspace-n")); if (j - 1 == workspace_n + 1) break; i++; } g_list_free (children); gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu), item, i); } } }
/* Determines the best dock item to dock a new item with the given placement. * It traverses the dock tree and (based on the placement) tries to find * the best located item wrt to the placement. The approach is to find the * largest item on/around the placement side (for side placements) and to * find the largest item for center placement. In most situations, this is * what user wants and the heuristic should be therefore sufficient. */ static GdlDockItem* gdl_dock_find_best_placement_item (GdlDockItem *dock_item, GdlDockPlacement placement, gint level /* for debugging */) { GdlDockItem *ret_item = NULL; if (GDL_IS_DOCK_PANED (dock_item)) { GtkOrientation orientation; GdlDockItem *dock_item_1, *dock_item_2; GList* children; children = gtk_container_get_children (GTK_CONTAINER (dock_item)); g_assert (g_list_length (children) == 2); g_object_get (dock_item, "orientation", &orientation, NULL); if ((orientation == GTK_ORIENTATION_HORIZONTAL && placement == GDL_DOCK_LEFT) || (orientation == GTK_ORIENTATION_VERTICAL && placement == GDL_DOCK_TOP)) { /* Return left or top pane widget */ ret_item = gdl_dock_find_best_placement_item (GDL_DOCK_ITEM (children->data), placement, level + 1); } else if ((orientation == GTK_ORIENTATION_HORIZONTAL && placement == GDL_DOCK_RIGHT) || (orientation == GTK_ORIENTATION_VERTICAL && placement == GDL_DOCK_BOTTOM)) { /* Return right or top pane widget */ ret_item = gdl_dock_find_best_placement_item (GDL_DOCK_ITEM (children->next->data), placement, level + 1); } else { /* Evaluate which of the two sides is bigger */ dock_item_1 = gdl_dock_find_best_placement_item (GDL_DOCK_ITEM (children->data), placement, level + 1); dock_item_2 = gdl_dock_find_best_placement_item (GDL_DOCK_ITEM (children->next->data), placement, level + 1); ret_item = gdl_dock_select_larger_item (dock_item_1, dock_item_2, placement, level); } g_list_free (children); } else if (GDL_IS_DOCK_ITEM (dock_item)) { ret_item = dock_item; } else { /* should not be here */ g_warning ("Should not reach here: %s:%d", __FUNCTION__, __LINE__); } return ret_item; }
static gboolean ui_to_setting (CEPageIP6 *page) { const gchar *method; gboolean ignore_auto_dns; gboolean ignore_auto_routes; gboolean never_default; GList *children, *l; gboolean ret = TRUE; if (!gtk_switch_get_active (page->enabled)) { method = NM_SETTING_IP6_CONFIG_METHOD_IGNORE; } else { switch (gtk_combo_box_get_active (page->method)) { case IP6_METHOD_MANUAL: method = NM_SETTING_IP6_CONFIG_METHOD_MANUAL; break; case IP6_METHOD_LINK_LOCAL: method = NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL; break; case IP6_METHOD_DHCP: method = NM_SETTING_IP6_CONFIG_METHOD_DHCP; break; default: case IP6_METHOD_AUTO: method = NM_SETTING_IP6_CONFIG_METHOD_AUTO; break; } } nm_setting_ip6_config_clear_addresses (page->setting); if (g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_MANUAL)) children = gtk_container_get_children (GTK_CONTAINER (page->address_list)); else children = NULL; for (l = children; l; l = l->next) { GtkWidget *row = l->data; GtkEntry *entry; const gchar *text_address; const gchar *text_prefix; const gchar *text_gateway; struct in6_addr tmp_addr; struct in6_addr tmp_gateway; guint32 prefix; gchar *end; NMIP6Address *addr; gboolean have_gateway = FALSE; entry = GTK_ENTRY (g_object_get_data (G_OBJECT (row), "address")); if (!entry) continue; text_address = gtk_entry_get_text (entry); text_prefix = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "prefix"))); text_gateway = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "gateway"))); if (!*text_address && !*text_prefix && !*text_gateway) { /* ignore empty rows */ widget_unset_error (GTK_WIDGET (entry)); widget_unset_error (g_object_get_data (G_OBJECT (row), "prefix")); widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); continue; } if (inet_pton (AF_INET6, text_address, &tmp_addr) <= 0) { widget_set_error (GTK_WIDGET (entry)); ret = FALSE; } else { widget_unset_error (GTK_WIDGET (entry)); } prefix = strtoul (text_prefix, &end, 10); if (!end || *end || prefix == 0 || prefix > 128) { widget_set_error (g_object_get_data (G_OBJECT (row), "prefix")); ret = FALSE; } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "prefix")); } if (text_gateway && *text_gateway) { if (inet_pton (AF_INET6, text_gateway, &tmp_gateway) <= 0) { widget_set_error (g_object_get_data (G_OBJECT (row), "gateway")); ret = FALSE; } else { if (!IN6_IS_ADDR_UNSPECIFIED (&tmp_gateway)) have_gateway = TRUE; widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); } } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); } if (!ret) continue; addr = nm_ip6_address_new (); nm_ip6_address_set_address (addr, &tmp_addr); nm_ip6_address_set_prefix (addr, prefix); if (have_gateway) nm_ip6_address_set_gateway (addr, &tmp_gateway); nm_setting_ip6_config_add_address (page->setting, addr); } g_list_free (children); nm_setting_ip6_config_clear_dns (page->setting); if (g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_AUTO) || g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_DHCP) || g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_MANUAL)) children = gtk_container_get_children (GTK_CONTAINER (page->dns_list)); else children = NULL; for (l = children; l; l = l->next) { GtkWidget *row = l->data; GtkEntry *entry; const gchar *text; struct in6_addr tmp_addr; entry = GTK_ENTRY (g_object_get_data (G_OBJECT (row), "address")); if (!entry) continue; text = gtk_entry_get_text (entry); if (!*text) { /* ignore empty rows */ widget_unset_error (GTK_WIDGET (entry)); continue; } if (inet_pton (AF_INET6, text, &tmp_addr) <= 0) { widget_set_error (GTK_WIDGET (entry)); ret = FALSE; } else { widget_unset_error (GTK_WIDGET (entry)); nm_setting_ip6_config_add_dns (page->setting, &tmp_addr); } } g_list_free (children); nm_setting_ip6_config_clear_routes (page->setting); if (g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_AUTO) || g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_DHCP) || g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_MANUAL)) children = gtk_container_get_children (GTK_CONTAINER (page->routes_list)); else children = NULL; for (l = children; l; l = l->next) { GtkWidget *row = l->data; GtkEntry *entry; const gchar *text_address; const gchar *text_prefix; const gchar *text_gateway; const gchar *text_metric; struct in6_addr dest, gateway; guint32 prefix, metric; gchar *end; NMIP6Route *route; entry = GTK_ENTRY (g_object_get_data (G_OBJECT (row), "address")); if (!entry) continue; text_address = gtk_entry_get_text (entry); text_prefix = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "prefix"))); text_gateway = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "gateway"))); text_metric = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "metric"))); if (!*text_address && !*text_prefix && !*text_gateway && !*text_metric) { /* ignore empty rows */ widget_unset_error (GTK_WIDGET (entry)); widget_unset_error (g_object_get_data (G_OBJECT (row), "prefix")); widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); widget_unset_error (g_object_get_data (G_OBJECT (row), "metric")); continue; } if (inet_pton (AF_INET6, text_address, &dest) <= 0) { widget_set_error (GTK_WIDGET (entry)); ret = FALSE; } else { widget_unset_error (GTK_WIDGET (entry)); } prefix = strtoul (text_prefix, &end, 10); if (!end || *end || prefix == 0 || prefix > 128) { widget_set_error (g_object_get_data (G_OBJECT (row), "prefix")); ret = FALSE; } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "prefix")); } if (inet_pton (AF_INET6, text_gateway, &gateway) <= 0) { widget_set_error (g_object_get_data (G_OBJECT (row), "gateway")); ret = FALSE; } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); } metric = 0; if (*text_metric) { errno = 0; metric = strtoul (text_metric, NULL, 10); if (errno) { widget_set_error (g_object_get_data (G_OBJECT (row), "metric")); ret = FALSE; } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "metric")); } } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "metric")); } if (!ret) continue; route = nm_ip6_route_new (); nm_ip6_route_set_dest (route, &dest); nm_ip6_route_set_prefix (route, prefix); nm_ip6_route_set_next_hop (route, &gateway); nm_ip6_route_set_metric (route, metric); nm_setting_ip6_config_add_route (page->setting, route); nm_ip6_route_unref (route); } g_list_free (children); if (!ret) goto out; ignore_auto_dns = !gtk_switch_get_active (page->auto_dns); ignore_auto_routes = !gtk_switch_get_active (page->auto_routes); never_default = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (page->never_default)); g_object_set (page->setting, NM_SETTING_IP6_CONFIG_METHOD, method, NM_SETTING_IP6_CONFIG_IGNORE_AUTO_DNS, ignore_auto_dns, NM_SETTING_IP6_CONFIG_IGNORE_AUTO_ROUTES, ignore_auto_routes, NM_SETTING_IP6_CONFIG_NEVER_DEFAULT, never_default, NULL); out: return ret; }
/** \brief Fill in a menu with controls for fliplist control. * * Fliplist controls are placed at the end of a menu, after a * separator. Any previously-existing fliplist controls within the * menu will be removed. * * \param menu The menu to be edited. * \param unit The drive unit (8-11) that this menu * will control. * \param separator_count The number of menu separators in the * part of the menu that does not involve * the fliplist. */ void ui_populate_fliplist_menu(GtkWidget *menu, int unit, int separator_count) { const char *fliplist_string; GtkWidget *menu_item; GList *children = gtk_container_get_children(GTK_CONTAINER(menu)); GList *child_iter = g_list_first(children); int separators_so_far = 0; while (child_iter) { if (GTK_IS_SEPARATOR_MENU_ITEM(child_iter->data)) { ++separators_so_far; } if (separators_so_far > separator_count) { gtk_container_remove(GTK_CONTAINER(menu), child_iter->data); } child_iter = child_iter->next; } g_list_free(children); /* Fliplist controls in GTK2/GNOME are next/previous and then the * full list of entries within it. For GTK3 we only show these if * the fliplist isn't empty for this drive. */ /* TODO: Add/Remove current image to/from fliplist should really * be here too. */ fliplist_string = fliplist_get_next(unit); if (fliplist_string) { char buf[128]; char *basename = NULL; fliplist_t fliplist_iterator; int index; gtk_container_add(GTK_CONTAINER(menu), gtk_separator_menu_item_new()); util_fname_split(fliplist_string, NULL, &basename); snprintf(buf, 128, "Next: %s", basename ? basename : fliplist_string); lib_free(basename); basename = NULL; buf[127] = 0; menu_item = gtk_menu_item_new_with_label(buf); g_signal_connect(menu_item, "activate", G_CALLBACK(ui_fliplist_next_cb), GINT_TO_POINTER(unit)); gtk_container_add(GTK_CONTAINER(menu), menu_item); fliplist_string = fliplist_get_prev(unit); if (fliplist_string) { util_fname_split(fliplist_string, NULL, &basename); snprintf(buf, 128, "Previous: %s", basename ? basename : fliplist_string); lib_free(basename); basename = NULL; buf[127] = 0; menu_item = gtk_menu_item_new_with_label(buf); g_signal_connect(menu_item, "activate", G_CALLBACK(ui_fliplist_prev_cb), GINT_TO_POINTER(unit)); gtk_container_add(GTK_CONTAINER(menu), menu_item); } gtk_container_add(GTK_CONTAINER(menu), gtk_separator_menu_item_new()); fliplist_iterator = fliplist_init_iterate(unit); index = 0; while (fliplist_iterator) { fliplist_string = fliplist_get_image(fliplist_iterator); util_fname_split(fliplist_string, NULL, &basename); menu_item = gtk_menu_item_new_with_label(basename ? basename : fliplist_string); lib_free(basename); basename = NULL; g_signal_connect(menu_item, "activate", G_CALLBACK(ui_fliplist_select_cb), GINT_TO_POINTER(unit+(index << 8))); gtk_container_add(GTK_CONTAINER(menu), menu_item); fliplist_iterator = fliplist_next_iterate(unit); ++index; } } }
GtkWidget * AP_UnixDialog_PageSetup::_constructWindow (void) { // get the path where our UI file is located std::string ui_path = static_cast<XAP_UnixApp*>(XAP_App::getApp())->getAbiSuiteAppUIDir() + "/ap_UnixDialog_PageSetup.xml"; // load the dialog from the UI file m_pBuilder = gtk_builder_new(); gtk_builder_add_from_file(m_pBuilder, ui_path.c_str(), NULL); const XAP_StringSet * pSS = m_pApp->getStringSet (); GList *glist; GtkLabel *orientation; m_window = _getWidget("ap_UnixDialog_PageSetup"); m_wHelp = _getWidget("wHelp"); m_comboPageSize = _getWidget("comboPageSize"); m_entryPageWidth = _getWidget("wWidthSpin"); m_entryPageHeight = _getWidget("wHeightSpin"); m_optionPageUnits = _getWidget("optionPageUnits"); m_radioPagePortrait = _getWidget("rbPortrait"); m_radioPageLandscape = _getWidget("rbLandscape"); m_spinPageScale = _getWidget("wPageScale"); m_optionMarginUnits = _getWidget("optionMarginUnits"); m_spinMarginTop = _getWidget("wTopSpin"); m_spinMarginBottom = _getWidget("wBottomSpin"); m_spinMarginLeft = _getWidget("wLeftSpin"); m_spinMarginRight = _getWidget("wRightSpin"); m_spinMarginHeader = _getWidget("wHeaderSpin"); m_spinMarginFooter = _getWidget("wFooterSpin"); m_MarginHbox = _getWidget("hbox15"); m_PageHbox = _getWidget("hbox16"); /* required for translations */ gtk_label_set_text (GTK_LABEL (_getWidget("lbPage")), _(AP, DLG_PageSetup_Page)); gtk_label_set_text (GTK_LABEL (_getWidget("lbMargin")), _(AP, DLG_PageSetup_Margin)); Markup (_getWidget("lbPaper"), pSS, _(AP, DLG_PageSetup_Paper)); gtk_label_set_text (GTK_LABEL (_getWidget("lbPaperSize")), _(AP, DLG_PageSetup_Paper_Size)); gtk_label_set_text (GTK_LABEL (_getWidget("lbPageUnits")), _(AP, DLG_PageSetup_Units)); gtk_label_set_text (GTK_LABEL (_getWidget("lbWidth")), _(AP, DLG_PageSetup_Width)); gtk_label_set_text (GTK_LABEL (_getWidget("lbHeight")), _(AP, DLG_PageSetup_Height)); Markup (_getWidget("lbOrientation"), pSS, _(AP, DLG_PageSetup_Orient)); /* radio button labels */ glist = gtk_container_get_children (GTK_CONTAINER (m_radioPagePortrait)); orientation = GTK_LABEL (g_list_nth_data (glist, 0)); gtk_label_set_text (GTK_LABEL (orientation), _(AP, DLG_PageSetup_Portrait)); glist = gtk_container_get_children (GTK_CONTAINER (m_radioPageLandscape)); orientation = GTK_LABEL (g_list_nth_data (glist, 0)); gtk_label_set_text (GTK_LABEL (orientation), _(AP, DLG_PageSetup_Landscape)); Markup (_getWidget("lbScale"), pSS, _(AP, DLG_PageSetup_Scale)); gtk_label_set_text (GTK_LABEL (_getWidget("lbAdjust")), _(AP, DLG_PageSetup_Adjust)); gtk_label_set_text (GTK_LABEL (_getWidget("lbPercentNormalSize")), _(AP, DLG_PageSetup_Percent)); gtk_label_set_text (GTK_LABEL (_getWidget("lbMarginUnits")), _(AP, DLG_PageSetup_Units)); gtk_label_set_text (GTK_LABEL (_getWidget("lbTop")), _(AP, DLG_PageSetup_Top)); gtk_label_set_text (GTK_LABEL (_getWidget("lbRight")), _(AP, DLG_PageSetup_Right)); gtk_label_set_text (GTK_LABEL (_getWidget("lbLeft")), _(AP, DLG_PageSetup_Left)); gtk_label_set_text (GTK_LABEL (_getWidget("lbBottom")), _(AP, DLG_PageSetup_Bottom)); gtk_label_set_text (GTK_LABEL (_getWidget("lbHeader")), _(AP, DLG_PageSetup_Header)); gtk_label_set_text (GTK_LABEL (_getWidget("lbFooter")), _(AP, DLG_PageSetup_Footer)); /* end translation req */ /* setup page width and height */ if (!getPageOrientation () == PORTRAIT) { m_PageSize.setLandscape(); } gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_entryPageWidth), m_PageSize.Width (getPageUnits ())); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_entryPageHeight), m_PageSize.Height (getPageUnits ())); /* setup margin numbers */ gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginTop), getMarginTop ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginBottom), getMarginBottom ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginLeft), getMarginLeft ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginRight), getMarginRight ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginHeader), getMarginHeader ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginFooter), getMarginFooter ()); /* setup scale number */ gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinPageScale), static_cast<float>(getPageScale ())); // fill the combobox all of our supported page sizes GtkListStore* pagesize_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); GtkTreeIter pagesize_iter; for (UT_uint32 i = fp_PageSize::_first_predefined_pagesize_; i < fp_PageSize::_last_predefined_pagesize_dont_use_; i++) { gtk_list_store_append(pagesize_store, &pagesize_iter); gtk_list_store_set(pagesize_store, &pagesize_iter, 0, fp_PageSize::PredefinedToName ((fp_PageSize::Predefined)i), 1, this, -1); } gtk_combo_box_set_model(GTK_COMBO_BOX(m_comboPageSize), GTK_TREE_MODEL(pagesize_store)); m_iComboPageSizeListID = g_signal_connect(G_OBJECT(m_comboPageSize), "changed", G_CALLBACK(s_page_size_changed), static_cast<gpointer>(this)); /* setup page units menu */ GtkComboBox *combo = GTK_COMBO_BOX(m_optionPageUnits); XAP_makeGtkComboBoxText(combo, G_TYPE_INT); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_inch), DIM_IN); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_cm), DIM_CM); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_mm), DIM_MM); XAP_comboBoxSetActiveFromIntCol(combo, 1, getPageUnits ()); /* setup margin units menu */ combo = GTK_COMBO_BOX(m_optionMarginUnits); XAP_makeGtkComboBoxText(combo, G_TYPE_INT); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_inch), DIM_IN); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_cm), DIM_CM); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_mm), DIM_MM); last_margin_unit = getMarginUnits (); XAP_comboBoxSetActiveFromIntCol(combo, 1, last_margin_unit); /* add margin XPM image to the margin window */ customPreview = create_pixmap (m_MarginHbox, margin_xpm); gtk_widget_show (customPreview); gtk_box_pack_start (GTK_BOX (m_MarginHbox), customPreview, FALSE, FALSE, 0); /* add correct page XPM image to the page window */ if (getPageOrientation () == PORTRAIT) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_radioPagePortrait), TRUE); customPreview = create_pixmap (m_PageHbox, orient_vertical_xpm); gtk_widget_show (customPreview); gtk_box_pack_start (GTK_BOX (m_PageHbox), customPreview, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (m_PageHbox), customPreview, 0); } else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_radioPageLandscape), TRUE); customPreview = create_pixmap (m_PageHbox, orient_horizontal_xpm); gtk_widget_show (customPreview); gtk_box_pack_start (GTK_BOX (m_PageHbox), customPreview, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (m_PageHbox), customPreview, 0); } abiAddStockButton(GTK_DIALOG(m_window), GTK_STOCK_CANCEL, BUTTON_CANCEL); abiAddStockButton(GTK_DIALOG(m_window), GTK_STOCK_OK, BUTTON_OK); _connectSignals (); return m_window; }
static void gdl_dock_object_real_reduce (GdlDockObject *object) { GdlDockObject *parent; GList *children; g_return_if_fail (object != NULL); if (!gdl_dock_object_is_compound (object)) return; parent = gdl_dock_object_get_parent_object (object); children = gtk_container_get_children (GTK_CONTAINER (object)); if (g_list_length (children) <= 1) { GList *l; GList *dchildren = NULL; /* detach ourselves and then re-attach our children to our current parent. if we are not currently attached, the children are detached */ if (parent) gdl_dock_object_freeze (parent); gdl_dock_object_freeze (object); /* Detach the children before detaching this object, since in this * way the children can have access to the whole object hierarchy. * Set the InDetach flag now, so the children know that this object * is going to be detached. */ GDL_DOCK_OBJECT_SET_FLAGS (object, GDL_DOCK_IN_DETACH); for (l = children; l; l = l->next) { GdlDockObject *child; if (!GDL_IS_DOCK_OBJECT (l->data)) continue; child = GDL_DOCK_OBJECT (l->data); g_object_ref (child); gdl_dock_object_detach (child, FALSE); GDL_DOCK_OBJECT_SET_FLAGS (child, GDL_DOCK_IN_REFLOW); if (parent) dchildren = g_list_append (dchildren, child); GDL_DOCK_OBJECT_UNSET_FLAGS (child, GDL_DOCK_IN_REFLOW); } /* Now it can be detached */ gdl_dock_object_detach (object, FALSE); /* After detaching the reduced object, we can add the children (the only child in fact) to the new parent */ for (l = dchildren; l; l = l->next) { gtk_container_add (GTK_CONTAINER (parent), l->data); g_object_unref (l->data); } g_list_free (dchildren); /* sink the widget, so any automatic floating widget is destroyed */ g_object_ref_sink (object); /* don't reenter */ object->reduce_pending = FALSE; gdl_dock_object_thaw (object); if (parent) gdl_dock_object_thaw (parent); } g_list_free (children); }
static gint midori_frontend_diagnostic_dialog (MidoriApp* app, MidoriWebSettings* settings, KatzeArray* session) { GtkWidget* dialog; GtkWidget* content_area; GtkWidget* align; GtkWidget* box; GtkWidget* button; MidoriStartup load_on_startup = katze_object_get_enum (settings, "load-on-startup"); gint response; dialog = gtk_message_dialog_new ( NULL, 0, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, _("Midori crashed the last time it was opened. You can report the problem at %s."), PACKAGE_BUGREPORT); gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dialog), FALSE); gtk_window_set_title (GTK_WINDOW (dialog), g_get_application_name ()); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); align = gtk_alignment_new (0.5, 0.5, 0.5, 0.5); gtk_box_pack_start (GTK_BOX (content_area), align, FALSE, TRUE, 0); box = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (align), box); button = gtk_button_new_with_mnemonic (_("Modify _preferences")); g_signal_connect (button, "clicked", G_CALLBACK (button_modify_preferences_clicked_cb), settings); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 4); button = gtk_button_new_with_mnemonic (_("Disable all _extensions")); if (g_object_get_data (G_OBJECT (app), "extensions")) g_signal_connect (button, "clicked", G_CALLBACK (button_disable_extensions_clicked_cb), app); else gtk_widget_set_sensitive (button, FALSE); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 4); gtk_widget_show_all (align); button = katze_property_proxy (settings, "show-crash-dialog", NULL); gtk_button_set_label (GTK_BUTTON (button), _("Show a dialog after Midori crashed")); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, TRUE, 0); gtk_container_set_focus_child (GTK_CONTAINER (dialog), gtk_dialog_get_action_area (GTK_DIALOG (dialog))); gtk_dialog_add_buttons (GTK_DIALOG (dialog), _("Discard old tabs"), MIDORI_STARTUP_BLANK_PAGE, _("Show last tabs without loading"), MIDORI_STARTUP_DELAYED_PAGES, _("Show last open tabs"), MIDORI_STARTUP_LAST_OPEN_PAGES, NULL); gchar* crash_log = g_build_filename (midori_paths_get_runtime_dir (), "gdb.bt", NULL); if (g_access (crash_log, F_OK) == 0) { GtkWidget* log_button = gtk_button_new_with_mnemonic (_("Show last crash _log")); g_signal_connect_data (log_button, "clicked", G_CALLBACK (midori_frontend_crash_log_cb), crash_log, (GClosureNotify)g_free, 0); gtk_widget_show (log_button); gtk_box_pack_start (GTK_BOX (box), log_button, FALSE, FALSE, 4); } else g_free (crash_log); gchar* gdb = g_find_program_in_path ("gdb"); if (gdb != NULL) { GtkWidget* gdb_button = gtk_button_new_with_mnemonic (_("Run in _debugger")); g_signal_connect (button, "clicked", G_CALLBACK (midori_frontend_debugger_cb), dialog); gtk_widget_show (gdb_button); gtk_box_pack_start (GTK_BOX (box), gdb_button, FALSE, FALSE, 4); } gtk_dialog_set_default_response (GTK_DIALOG (dialog), load_on_startup == MIDORI_STARTUP_HOMEPAGE ? MIDORI_STARTUP_BLANK_PAGE : load_on_startup); /* GtkLabel can't wrap the text properly. Until some day this works, we implement this hack to do it ourselves. */ GList* ch = gtk_container_get_children (GTK_CONTAINER (content_area)); GtkWidget* hbox = (GtkWidget*)g_list_nth_data (ch, 0); g_list_free (ch); ch = gtk_container_get_children (GTK_CONTAINER (hbox)); GtkWidget* vbox = (GtkWidget*)g_list_nth_data (ch, 1); g_list_free (ch); ch = gtk_container_get_children (GTK_CONTAINER (vbox)); GtkWidget* label = (GtkWidget*)g_list_nth_data (ch, 0); g_list_free (ch); GtkRequisition req; gtk_widget_size_request (content_area, &req); gtk_widget_set_size_request (label, req.width * 0.9, -1); response = midori_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); if (response == GTK_RESPONSE_DELETE_EVENT) response = G_MAXINT; else if (response == GTK_RESPONSE_HELP) { sokoke_spawn_gdb (gdb, FALSE); response = G_MAXINT; } else if (response == MIDORI_STARTUP_BLANK_PAGE) katze_array_clear (session); return response; }
GtkWidget * gimp_ink_options_gui (GimpToolOptions *tool_options) { GObject *config = G_OBJECT (tool_options); GimpInkOptions *ink_options = GIMP_INK_OPTIONS (tool_options); GtkWidget *vbox = gimp_paint_options_gui (tool_options); GtkWidget *frame; GtkWidget *table; GtkWidget *blob_vbox; GtkWidget *hbox; GtkWidget *editor; GtkObject *adj; /* adjust sliders */ frame = gimp_frame_new (_("Adjustment")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0); gtk_widget_show (frame); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); /* size slider */ adj = gimp_prop_scale_entry_new (config, "size", GTK_TABLE (table), 0, 0, _("Size:"), 1.0, 2.0, 1, FALSE, 0.0, 0.0); gimp_scale_entry_set_logarithmic (adj, TRUE); /* angle adjust slider */ gimp_prop_scale_entry_new (config, "tilt-angle", GTK_TABLE (table), 0, 1, _("Angle:"), 1.0, 10.0, 1, FALSE, 0.0, 0.0); /* sens sliders */ frame = gimp_frame_new (_("Sensitivity")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0); gtk_widget_show (frame); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); /* size sens slider */ gimp_prop_scale_entry_new (config, "size-sensitivity", GTK_TABLE (table), 0, 0, _("Size:"), 0.01, 0.1, 1, FALSE, 0.0, 0.0); /* tilt sens slider */ gimp_prop_scale_entry_new (config, "tilt-sensitivity", GTK_TABLE (table), 0, 1, _("Tilt:"), 0.01, 0.1, 1, FALSE, 0.0, 0.0); /* velocity sens slider */ gimp_prop_scale_entry_new (config, "vel-sensitivity", GTK_TABLE (table), 0, 2, _("Speed:"), 0.01, 0.1, 1, FALSE, 0.0, 0.0); /* bottom hbox */ hbox = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* Blob type radiobuttons */ frame = gimp_prop_enum_radio_frame_new (config, "blob-type", _("Type"), 0, 0); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); { GtkWidget *frame_child = gtk_bin_get_child (GTK_BIN (frame)); GList *children; GList *list; GimpInkBlobType blob_type; children = gtk_container_get_children (GTK_CONTAINER (frame_child)); for (list = children, blob_type = GIMP_INK_BLOB_TYPE_ELLIPSE; list; list = g_list_next (list), blob_type++) { GtkWidget *radio = GTK_WIDGET (list->data); GtkWidget *blob; gtk_container_remove (GTK_CONTAINER (radio), gtk_bin_get_child (GTK_BIN (radio))); blob = blob_image_new (blob_type); gtk_container_add (GTK_CONTAINER (radio), blob); gtk_widget_show (blob); } g_list_free (children); } /* Blob shape widget */ frame = gimp_frame_new (_("Shape")); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); blob_vbox = gtk_vbox_new (FALSE, 2); gtk_container_add (GTK_CONTAINER (frame), blob_vbox); gtk_widget_show (blob_vbox); frame = gtk_aspect_frame_new (NULL, 0.0, 0.5, 1.0, FALSE); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (blob_vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); editor = gimp_blob_editor_new (ink_options->blob_type, ink_options->blob_aspect, ink_options->blob_angle); gtk_widget_set_size_request (editor, 60, 60); gtk_container_add (GTK_CONTAINER (frame), editor); gtk_widget_show (editor); gimp_config_connect (config, G_OBJECT (editor), NULL); return vbox; }
bool sc_navigate_index(girara_session_t* session, girara_argument_t* argument, girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; g_return_val_if_fail(argument != NULL, false); g_return_val_if_fail(zathura->document != NULL, false); if(zathura->ui.index == NULL) { return false; } GtkTreeView *tree_view = gtk_container_get_children(GTK_CONTAINER(zathura->ui.index))->data; GtkTreePath *path; gtk_tree_view_get_cursor(tree_view, &path, NULL); if (path == NULL) { return false; } GtkTreeModel *model = gtk_tree_view_get_model(tree_view); GtkTreeIter iter; GtkTreeIter child_iter; gboolean is_valid_path = TRUE; switch(argument->n) { case UP: if (gtk_tree_path_prev(path) == FALSE) { /* For some reason gtk_tree_path_up returns TRUE although we're not * moving anywhere. */ is_valid_path = gtk_tree_path_up(path) && (gtk_tree_path_get_depth(path) > 0); } else { /* row above */ while(gtk_tree_view_row_expanded(tree_view, path)) { gtk_tree_model_get_iter(model, &iter, path); /* select last child */ gtk_tree_model_iter_nth_child(model, &child_iter, &iter, gtk_tree_model_iter_n_children(model, &iter)-1); gtk_tree_path_free(path); path = gtk_tree_model_get_path(model, &child_iter); } } break; case COLLAPSE: if (gtk_tree_view_collapse_row(tree_view, path) == FALSE && gtk_tree_path_get_depth(path) > 1) { gtk_tree_path_up(path); gtk_tree_view_collapse_row(tree_view, path); } break; case DOWN: if (gtk_tree_view_row_expanded(tree_view, path) == TRUE) { gtk_tree_path_down(path); } else { do { gtk_tree_model_get_iter(model, &iter, path); if (gtk_tree_model_iter_next(model, &iter)) { gtk_tree_path_free(path); path = gtk_tree_model_get_path(model, &iter); break; } } while((is_valid_path = (gtk_tree_path_get_depth(path) > 1)) && gtk_tree_path_up(path)); } break; case EXPAND: if (gtk_tree_view_expand_row(tree_view, path, FALSE)) { gtk_tree_path_down(path); } break; case EXPAND_ALL: gtk_tree_view_expand_all(tree_view); break; case COLLAPSE_ALL: gtk_tree_view_collapse_all(tree_view); gtk_tree_path_free(path); path = gtk_tree_path_new_first(); gtk_tree_view_set_cursor(tree_view, path, NULL, FALSE); break; case SELECT: cb_index_row_activated(tree_view, path, NULL, zathura); gtk_tree_path_free(path); return false; } if (is_valid_path) { gtk_tree_view_set_cursor(tree_view, path, NULL, FALSE); } gtk_tree_path_free(path); return false; }