static void wp_selected_changed_cb (GtkIconView *view, AppearanceData *data) { GtkCellRenderer *cr; GList *cells, *l; data->frame = -1; cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (data->wp_view)); for (l = cells; l; l = l->next) { cr = l->data; if (g_object_get_data (G_OBJECT (cr), "buttons")) g_object_set (cr, "pixbuf", buttons[0], NULL); } g_list_free (cells); }
/****************************************************************************\ * gnc_reconcile_view_new * * creates the account tree * * * * Args: account - the account to use in filling up the splits. * * type - the type of view, RECLIST_DEBIT or RECLIST_CREDIT * * statement_date - date of statement * * Returns: the account tree widget, or NULL if there was a problem. * \****************************************************************************/ static void gnc_reconcile_view_construct (GNCReconcileView *view, Query *query) { GNCQueryView *qview = GNC_QUERY_VIEW (view); GtkTreeViewColumn *col; GtkTreeSelection *selection; GList *renderers; GtkCellRenderer *cr0; gboolean inv_sort = FALSE; if (view->view_type == RECLIST_CREDIT) inv_sort = TRUE; /* Construct the view */ gnc_query_view_construct (qview, view->column_list, query); gnc_query_view_set_numerics (qview, TRUE, inv_sort); /* Set the description field to have spare space */ col = gtk_tree_view_get_column (GTK_TREE_VIEW (qview), 2); gtk_tree_view_column_set_expand (col, TRUE); /* Get the renderer of the description column and set ellipsize value */ renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col)); cr0 = g_list_nth_data (renderers, 0); g_list_free (renderers); g_object_set (cr0, "ellipsize", PANGO_ELLIPSIZE_END, NULL ); gtk_widget_set_has_tooltip (GTK_WIDGET (qview), TRUE); /* Set the selection method */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (qview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); /* Now set up the signals for the QueryView */ g_signal_connect (G_OBJECT (qview), "column_toggled", G_CALLBACK (gnc_reconcile_view_line_toggled), view); g_signal_connect (G_OBJECT (qview), "double_click_entry", G_CALLBACK (gnc_reconcile_view_double_click_entry), view); g_signal_connect (G_OBJECT (qview), "row_selected", G_CALLBACK (gnc_reconcile_view_row_selected), view); g_signal_connect (G_OBJECT (qview), "key_press_event", G_CALLBACK (gnc_reconcile_view_key_press_cb), view); g_signal_connect (G_OBJECT (qview), "query-tooltip", G_CALLBACK (gnc_reconcile_view_tooltip_cb), view); }
void gnc_reconcile_view_add_padding (GNCReconcileView *view, gint column, gint xpadding) { GNCQueryView *qview = GNC_QUERY_VIEW (view); GtkTreeViewColumn *col; GList *renderers; GtkCellRenderer *cr0; gint xpad, ypad; //allow for pointer model column at column 0 col = gtk_tree_view_get_column (GTK_TREE_VIEW (qview), (column - 1)); renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col)); cr0 = g_list_nth_data (renderers, 0); g_list_free (renderers); gtk_cell_renderer_get_padding (cr0, &xpad, &ypad); gtk_cell_renderer_set_padding (cr0, xpadding, ypad); }
static GList * gtk_cell_layout_default_get_cells (GtkCellLayout *cell_layout) { GtkCellLayoutIface *iface; GtkCellArea *area; iface = GTK_CELL_LAYOUT_GET_IFACE (cell_layout); if (iface->get_area) { area = iface->get_area (cell_layout); if (area) return gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area)); else warn_no_cell_area ("GtkCellLayoutIface->get_cells()"); } return NULL; }
static gchar * get_text_from_label_widget (GtkWidget *label) { if (GTK_IS_LABEL (label)) return g_strdup (gtk_label_get_text (GTK_LABEL (label))); else if (GTK_IS_CELL_VIEW (label)) { GList *cells, *l; GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *path; GtkCellArea *area; gchar *text; model = gtk_cell_view_get_model (GTK_CELL_VIEW (label)); path = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (label)); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (label)); gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (label)); text = NULL; for (l = cells; l; l = l->next) { GtkCellRenderer *cell = l->data; if (GTK_IS_CELL_RENDERER_TEXT (cell)) { g_object_get (cell, "text", &text, NULL); break; } } g_list_free (cells); return text; } return NULL; }
void cc_shell_item_view_update_cells (CcShellItemView *view) { GList *cells, *l; cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (view)); for (l = cells ; l != NULL; l = l->next) { GtkCellRenderer *cell = l->data; if (GTK_IS_CELL_RENDERER_TEXT (cell)) { g_object_set (G_OBJECT (cell), "wrap-mode", PANGO_WRAP_WORD, NULL); /* We only have one text cell */ break; } } g_list_free (cells); }
void list_store_set_align(GtkWidget *tview, int n, double align) { GtkTreeViewColumn *col; GList *list; col = gtk_tree_view_get_column(GTK_TREE_VIEW(tview), n); if (col == NULL) { return; } list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(col)); if (list == NULL || list->data == NULL) { return; } g_object_set((GObject *) list->data, "xalign", (gfloat) align, NULL); g_list_free(list); }
/** * ide_fancy_tree_view_set_data_func: * @self: a #IdeFancyTreeView * @func: (closure func_data) (scope async) (nullable): a callback * @func_data: data for @func * @func_data_destroy: destroy notify for @func_data * * Sets the data func to use to update the text for the * #IdeCellRendererFancy cell renderer. * * Since: 3.32 */ void ide_fancy_tree_view_set_data_func (IdeFancyTreeView *self, GtkCellLayoutDataFunc func, gpointer func_data, GDestroyNotify func_data_destroy) { GtkTreeViewColumn *column; GList *cells; g_return_if_fail (IDE_IS_FANCY_TREE_VIEW (self)); column = gtk_tree_view_get_column (GTK_TREE_VIEW (self), 0); cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column)); if (cells->data != NULL) gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (column), cells->data, func, func_data, func_data_destroy); g_list_free (cells); }
static gboolean on_item_list_view_query_tooltip (GtkWidget *widget, gint x, gint y, gboolean keyboard_mode, GtkTooltip *tooltip, GtkTreeViewColumn *headline_column) { GtkTreeView *view = GTK_TREE_VIEW (widget); GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; gboolean ret = FALSE; if (gtk_tree_view_get_tooltip_context (view, &x, &y, keyboard_mode, &model, &path, &iter)) { GtkTreeViewColumn *column; gint bx, by; gtk_tree_view_convert_widget_to_bin_window_coords (view, x, y, &bx, &by); gtk_tree_view_get_path_at_pos (view, x, y, NULL, &column, NULL, NULL); if (column == headline_column) { GtkCellRenderer *cell; GList *renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column)); cell = GTK_CELL_RENDERER (renderers->data); g_list_free (renderers); gchar *text; gint weight; gtk_tree_model_get (model, &iter, IS_LABEL, &text, ITEMSTORE_UNREAD, &weight, -1); gint full_width = get_cell_renderer_width (widget, cell, text, weight); gint column_width = gtk_tree_view_column_get_width (column); if (full_width > column_width) { gtk_tooltip_set_text (tooltip, text); ret = TRUE; } g_free (text); } gtk_tree_view_set_tooltip_row (view, tooltip, path); gtk_tree_path_free (path); } return ret; }
/** * gva_main_init_search_completion: * @error: return location for a #GError, or %NULL * * Initializes autocompletion in the search entry. This must be done * <emphasis>after</emphasis> the game database is built and ROMs are * analyzed. If an error occurs, the function returns %FALSE and sets * @error. * * Returns: %TRUE if autocompletion was initialized successfully, * %FALSE if an error occurred **/ gboolean gva_main_init_search_completion (GError **error) { GtkEntryCompletion *completion; GtkCellRenderer *renderer; GtkListStore *store; GtkTreeIter iter; GtkEntry *entry; sqlite3_stmt *stmt; gint errcode; GList *list; if (!gva_db_prepare (SQL_COMPLETION_LIST, &stmt, error)) return FALSE; store = gtk_list_store_new ( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); while ((errcode = sqlite3_step (stmt)) == SQLITE_ROW) { GvaGameStoreColumn column_id; const gchar *column_name; const gchar *column_title; const gchar *search_text; gchar *collation_key; search_text = (const gchar *) sqlite3_column_text (stmt, 0); column_name = (const gchar *) sqlite3_column_text (stmt, 1); gva_columns_lookup_id (column_name, &column_id); column_title = gva_columns_lookup_title (column_id); if (search_text == NULL || *search_text == '\0') continue; gtk_list_store_append (store, &iter); collation_key = gva_search_collate_key (search_text); gtk_list_store_set ( store, &iter, COLUMN_NAME, column_name, COLUMN_TEXT, search_text, COLUMN_TYPE, column_title, COLUMN_CKEY, collation_key, -1); g_free (collation_key); } sqlite3_finalize (stmt); if (errcode != SQLITE_DONE) { gva_db_set_error (error, 0, NULL); g_object_unref (store); return FALSE; } completion = gtk_entry_completion_new (); gtk_entry_completion_set_match_func ( completion, (GtkEntryCompletionMatchFunc) main_entry_completion_match, NULL, NULL); gtk_entry_completion_set_minimum_key_length (completion, 3); gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (store)); gtk_entry_completion_set_text_column (completion, COLUMN_TEXT); g_signal_connect ( completion, "match-selected", G_CALLBACK (main_entry_completion_match_selected_cb), NULL); list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (completion)); g_object_set (list->data, "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_list_free (list); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "sensitive", FALSE, "xalign", 1.0, NULL); gtk_cell_layout_pack_start ( GTK_CELL_LAYOUT (completion), renderer, FALSE); gtk_cell_layout_add_attribute ( GTK_CELL_LAYOUT (completion), renderer, "text", COLUMN_TYPE); entry = GTK_ENTRY (GVA_WIDGET_MAIN_SEARCH_ENTRY); gtk_entry_set_completion (entry, completion); return TRUE; }
static void mate_volume_applet_preferences_init (MateVolumeAppletPreferences *prefs) { GtkWidget *box, *label, *view; GtkListStore *store; GtkTreeSelection *sel; GtkTreeViewColumn *col; GtkCellRenderer *render; GList *cells; prefs->applet = NULL; prefs->mixer = NULL; /* make window look cute */ gtk_window_set_title (GTK_WINDOW (prefs), _("Volume Control Preferences")); gtk_dialog_set_has_separator (GTK_DIALOG (prefs), FALSE); gtk_container_set_border_width (GTK_CONTAINER (prefs), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG(prefs))), 2); gtk_dialog_add_buttons (GTK_DIALOG (prefs), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, /* help goes here (future) */ NULL); /* add a treeview for all the properties */ box = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (box), 5); label = gtk_label_new (_("Select the device and track to control.")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); /* optionmenu */ prefs->optionmenu = gtk_combo_box_new_text (); cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (prefs->optionmenu)); g_object_set (G_OBJECT (cells->data), "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_list_free (cells); gtk_box_pack_start (GTK_BOX (box), prefs->optionmenu, FALSE, FALSE, 0); gtk_widget_show (prefs->optionmenu); g_signal_connect (prefs->optionmenu, "changed", G_CALLBACK (cb_dev_selected), prefs); store = gtk_list_store_new (NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); prefs->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (prefs->treeview), FALSE); /* viewport for lots of tracks */ view = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (view), GTK_SHADOW_IN); gtk_widget_set_size_request (view, -1, 100); gtk_container_add (GTK_CONTAINER (view), prefs->treeview); gtk_box_pack_start (GTK_BOX (box), view, TRUE, TRUE, 0); gtk_widget_show (prefs->treeview); gtk_widget_show (view); /* treeview internals */ sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (prefs->treeview)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_MULTIPLE); gtk_tree_selection_set_select_function (sel, cb_track_select, prefs, NULL); render = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Track name", render, "text", COL_LABEL, NULL); gtk_tree_view_column_set_clickable (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (prefs->treeview), col); gtk_tree_view_set_search_column (GTK_TREE_VIEW (prefs->treeview), COL_LABEL); /* and show */ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (prefs))), box, TRUE, TRUE, 0); gtk_widget_show (box); }
static GtkCellEditable * parasite_property_cell_renderer_start_editing(GtkCellRenderer *renderer, GdkEvent *event, GtkWidget *widget, const gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags) { PangoFontDescription *font_desc; GtkCellEditable *editable = NULL; GObject *object; const char *name; GValue gvalue = {0}; GParamSpec *prop; g_object_get(renderer, "object", &object, "name", &name, NULL); prop = g_object_class_find_property(G_OBJECT_GET_CLASS(object), name); if (!(prop->flags & G_PARAM_WRITABLE)) return NULL; g_value_init(&gvalue, prop->value_type); g_object_get_property(object, name, &gvalue); if (G_VALUE_HOLDS_ENUM(&gvalue) || G_VALUE_HOLDS_BOOLEAN(&gvalue)) { GtkWidget *combobox = gtk_combo_box_new_text(); gtk_widget_show(combobox); g_object_set(G_OBJECT(combobox), "has-frame", FALSE, NULL); GList *renderers; if (G_VALUE_HOLDS_BOOLEAN(&gvalue)) { gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), "FALSE"); gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), "TRUE"); gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), g_value_get_boolean(&gvalue) ? 1 : 0); } else if (G_VALUE_HOLDS_ENUM(&gvalue)) { gint value = g_value_get_enum(&gvalue); GEnumClass *enum_class = G_PARAM_SPEC_ENUM(prop)->enum_class; guint i; for (i = 0; i < enum_class->n_values; i++) { GEnumValue *enum_value = &enum_class->values[i]; gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), enum_value->value_name); if (enum_value->value == value) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), i); } } renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(combobox)); g_object_set(G_OBJECT(renderers->data), "scale", TREE_TEXT_SCALE, NULL); g_list_free(renderers); editable = GTK_CELL_EDITABLE(combobox); } else if (G_VALUE_HOLDS_STRING(&gvalue)) { GtkWidget *entry = gtk_entry_new(); gtk_widget_show(entry); gtk_entry_set_text(GTK_ENTRY(entry), g_value_get_string(&gvalue)); editable = GTK_CELL_EDITABLE(entry); } else if (G_VALUE_HOLDS_INT(&gvalue) || G_VALUE_HOLDS_UINT(&gvalue) || G_VALUE_HOLDS_INT64(&gvalue) || G_VALUE_HOLDS_UINT64(&gvalue) || G_VALUE_HOLDS_LONG(&gvalue) || G_VALUE_HOLDS_ULONG(&gvalue) || G_VALUE_HOLDS_DOUBLE(&gvalue)) { double min, max, value; GtkWidget *spinbutton; guint digits = 0; if (G_VALUE_HOLDS_INT(&gvalue)) { GParamSpecInt *paramspec = G_PARAM_SPEC_INT(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_int(&gvalue); } else if (G_VALUE_HOLDS_UINT(&gvalue)) { GParamSpecUInt *paramspec = G_PARAM_SPEC_UINT(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_uint(&gvalue); } else if (G_VALUE_HOLDS_INT64(&gvalue)) { GParamSpecInt64 *paramspec = G_PARAM_SPEC_INT64(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_int64(&gvalue); } else if (G_VALUE_HOLDS_UINT64(&gvalue)) { GParamSpecUInt64 *paramspec = G_PARAM_SPEC_UINT64(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_uint64(&gvalue); } else if (G_VALUE_HOLDS_LONG(&gvalue)) { GParamSpecLong *paramspec = G_PARAM_SPEC_LONG(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_long(&gvalue); } else if (G_VALUE_HOLDS_ULONG(&gvalue)) { GParamSpecULong *paramspec = G_PARAM_SPEC_ULONG(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_ulong(&gvalue); } else if (G_VALUE_HOLDS_DOUBLE(&gvalue)) { GParamSpecDouble *paramspec = G_PARAM_SPEC_DOUBLE(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_double(&gvalue); digits = 2; } else { // Shouldn't really be able to happen. return NULL; } spinbutton = gtk_spin_button_new_with_range(min, max, 1); gtk_widget_show(spinbutton); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton), value); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spinbutton), digits); editable = GTK_CELL_EDITABLE(spinbutton); } font_desc = pango_font_description_new(); pango_font_description_set_size(font_desc, 8 * PANGO_SCALE); gtk_widget_modify_font(GTK_WIDGET(editable), font_desc); pango_font_description_free(font_desc); g_value_unset(&gvalue); g_signal_connect(G_OBJECT(editable), "editing_done", G_CALLBACK(parasite_property_cell_renderer_stop_editing), renderer); g_object_set_data_full(G_OBJECT(editable), "_prop_name", g_strdup(name), g_free); g_object_set_data(G_OBJECT(editable), "_prop_object", object); return editable; }
static void ip4_private_init (CEPageIP4 *self, NMConnection *connection) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkBuilder *builder; GtkTreeIter iter; NMSettingConnection *s_con; const char *connection_type; char *str_auto = NULL, *str_auto_only = NULL; GList *cells; builder = CE_PAGE (self)->builder; s_con = nm_connection_get_setting_connection (connection); g_assert (s_con); connection_type = nm_setting_connection_get_connection_type (s_con); g_assert (connection_type); priv->connection_type = nm_setting_lookup_type (connection_type); if (priv->connection_type == NM_TYPE_SETTING_VPN) { str_auto = _("Automatic (VPN)"); str_auto_only = _("Automatic (VPN) addresses only"); } else if ( priv->connection_type == NM_TYPE_SETTING_GSM || priv->connection_type == NM_TYPE_SETTING_CDMA) { str_auto = _("Automatic"); str_auto_only = _("Automatic, addresses only"); } else if (priv->connection_type == NM_TYPE_SETTING_PPPOE) { str_auto = _("Automatic (PPPoE)"); str_auto_only = _("Automatic (PPPoE) addresses only"); } else { str_auto = _("Automatic (DHCP)"); str_auto_only = _("Automatic (DHCP) addresses only"); } priv->method = GTK_COMBO_BOX (gtk_builder_get_object (builder, "ip4_method")); cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (priv->method)); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->method), cells->data, "sensitive", METHOD_COL_ENABLED); priv->method_store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_BOOLEAN); gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, str_auto, METHOD_COL_NUM, IP4_METHOD_AUTO, METHOD_COL_ENABLED, TRUE, -1); gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, str_auto_only, METHOD_COL_NUM, IP4_METHOD_AUTO_ADDRESSES, METHOD_COL_ENABLED, TRUE, -1); /* Manual is pointless for Mobile Broadband */ if ( priv->connection_type != NM_TYPE_SETTING_GSM && priv->connection_type != NM_TYPE_SETTING_CDMA && priv->connection_type != NM_TYPE_SETTING_VPN) { gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Manual"), METHOD_COL_NUM, IP4_METHOD_MANUAL, METHOD_COL_ENABLED, TRUE, -1); } /* Link-local is pointless for VPNs, Mobile Broadband, and PPPoE */ if ( priv->connection_type != NM_TYPE_SETTING_VPN && priv->connection_type != NM_TYPE_SETTING_PPPOE && priv->connection_type != NM_TYPE_SETTING_GSM && priv->connection_type != NM_TYPE_SETTING_CDMA) { gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Link-Local Only"), METHOD_COL_NUM, IP4_METHOD_LINK_LOCAL, METHOD_COL_ENABLED, TRUE, -1); gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Shared to other computers"), METHOD_COL_NUM, IP4_METHOD_SHARED, METHOD_COL_ENABLED, TRUE, -1); } /* Disabled is only supported for types that also support IPv6 */ if (connection_supports_ip6 (connection)) { gtk_list_store_append (priv->method_store, &iter); gtk_list_store_set (priv->method_store, &iter, METHOD_COL_NAME, _("Disabled"), METHOD_COL_NUM, IP4_METHOD_DISABLED, METHOD_COL_ENABLED, TRUE, -1); } gtk_combo_box_set_model (priv->method, GTK_TREE_MODEL (priv->method_store)); priv->addr_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_addr_label")); priv->addr_add = GTK_BUTTON (gtk_builder_get_object (builder, "ip4_addr_add_button")); priv->addr_delete = GTK_BUTTON (gtk_builder_get_object (builder, "ip4_addr_delete_button")); priv->addr_list = GTK_TREE_VIEW (gtk_builder_get_object (builder, "ip4_addresses")); priv->dns_servers_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_dns_servers_label")); priv->dns_servers = GTK_ENTRY (gtk_builder_get_object (builder, "ip4_dns_servers_entry")); priv->dns_searches_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_dns_searches_label")); priv->dns_searches = GTK_ENTRY (gtk_builder_get_object (builder, "ip4_dns_searches_entry")); priv->dhcp_client_id_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_dhcp_client_id_label")); priv->dhcp_client_id = GTK_ENTRY (gtk_builder_get_object (builder, "ip4_dhcp_client_id_entry")); /* Hide DHCP stuff if it'll never be used for a particular method */ if ( priv->connection_type == NM_TYPE_SETTING_VPN || priv->connection_type == NM_TYPE_SETTING_GSM || priv->connection_type == NM_TYPE_SETTING_CDMA || priv->connection_type == NM_TYPE_SETTING_PPPOE) { gtk_widget_hide (GTK_WIDGET (priv->dhcp_client_id_label)); gtk_widget_hide (GTK_WIDGET (priv->dhcp_client_id)); } priv->ip4_required = GTK_CHECK_BUTTON (gtk_builder_get_object (builder, "ip4_required_checkbutton")); /* Hide IP4-require button if it'll never be used for a particular method */ if ( priv->connection_type == NM_TYPE_SETTING_VPN || priv->connection_type == NM_TYPE_SETTING_GSM || priv->connection_type == NM_TYPE_SETTING_CDMA || priv->connection_type == NM_TYPE_SETTING_PPPOE) gtk_widget_hide (GTK_WIDGET (priv->ip4_required)); priv->routes_button = GTK_BUTTON (gtk_builder_get_object (builder, "ip4_routes_button")); }
/** * na_gtk_utils_set_editable: * @widget: the #GtkWdiget. * @editable: whether the @widget is editable or not. * * Try to set a visual indication of whether the @widget is editable or not. * * Having a GtkWidget should be enough, but we also deal with a GtkTreeViewColumn. * So the most-bottom common ancestor is just GObject (since GtkObject having been * deprecated in Gtk+-3.0) * * Note that using 'sensitivity' property is just a work-around because the * two things have distinct semantics: * - editable: whether we are allowed to modify the value (is not read-only) * - sensitive: whether the value is relevant (has a sense in this context) */ void na_gtk_utils_set_editable( GObject *widget, gboolean editable ) { GList *renderers, *irender; /* GtkComboBoxEntry is deprecated from Gtk+3 * see. http://git.gnome.org/browse/gtk+/commit/?id=9612c648176378bf237ad0e1a8c6c995b0ca7c61 * while 'has_entry' property exists since 2.24 */ #if GTK_CHECK_VERSION( 2,24,0 ) if( GTK_IS_COMBO_BOX( widget ) && gtk_combo_box_get_has_entry( GTK_COMBO_BOX( widget ))){ #else if( GTK_IS_COMBO_BOX_ENTRY( widget )){ #endif /* idem as GtkEntry */ gtk_editable_set_editable( GTK_EDITABLE( gtk_bin_get_child( GTK_BIN( widget ))), editable ); g_object_set( G_OBJECT( gtk_bin_get_child( GTK_BIN( widget ))), "can-focus", editable, NULL ); /* disable the listbox button itself */ gtk_combo_box_set_button_sensitivity( GTK_COMBO_BOX( widget ), editable ? GTK_SENSITIVITY_ON : GTK_SENSITIVITY_OFF ); } else if( GTK_IS_COMBO_BOX( widget )){ /* disable the listbox button itself */ gtk_combo_box_set_button_sensitivity( GTK_COMBO_BOX( widget ), editable ? GTK_SENSITIVITY_ON : GTK_SENSITIVITY_OFF ); } else if( GTK_IS_ENTRY( widget )){ gtk_editable_set_editable( GTK_EDITABLE( widget ), editable ); /* removing the frame leads to a disturbing modification of the * height of the control */ /*g_object_set( G_OBJECT( widget ), "has-frame", editable, NULL );*/ /* this prevents the caret to be displayed when we click in the entry */ g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL ); } else if( GTK_IS_TEXT_VIEW( widget )){ g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL ); gtk_text_view_set_editable( GTK_TEXT_VIEW( widget ), editable ); } else if( GTK_IS_TOGGLE_BUTTON( widget )){ /* transforms to a quasi standard GtkButton */ /*g_object_set( G_OBJECT( widget ), "draw-indicator", editable, NULL );*/ /* this at least prevent the keyboard focus to go to the button * (which is better than nothing) */ g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL ); } else if( GTK_IS_TREE_VIEW_COLUMN( widget )){ renderers = gtk_cell_layout_get_cells( GTK_CELL_LAYOUT( GTK_TREE_VIEW_COLUMN( widget ))); for( irender = renderers ; irender ; irender = irender->next ){ if( GTK_IS_CELL_RENDERER_TEXT( irender->data )){ g_object_set( G_OBJECT( irender->data ), "editable", editable, "editable-set", TRUE, NULL ); } } g_list_free( renderers ); } else if( GTK_IS_BUTTON( widget )){ gtk_widget_set_sensitive( GTK_WIDGET( widget ), editable ); } } /** * na_gtk_utils_radio_set_initial_state: * @button: the #GtkRadioButton button which is initially active. * @handler: the corresponding "toggled" handler. * @user_data: the user data associated to the handler. * @editable: whether this radio button group is editable. * @sensitive: whether this radio button group is sensitive. * * This function should be called for the button which is initially active * inside of a radio button group when the radio group may happen to not be * editable. * This function should be called only once for the radio button group. * * It does the following operations: * - set the button as active * - set other buttons of the radio button group as icactive * - set all buttons of radio button group as @editable * * The initially active @button, along with its @handler, are recorded * as properties of the radio button group (actually as properties of each * radio button of the group), so that they can later be used to reset the * initial state. */ void na_gtk_utils_radio_set_initial_state( GtkRadioButton *button, GCallback handler, void *user_data, gboolean editable, gboolean sensitive ) { GSList *group, *ig; GtkRadioButton *other; group = gtk_radio_button_get_group( button ); for( ig = group ; ig ; ig = ig->next ){ other = GTK_RADIO_BUTTON( ig->data ); g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_BUTTON, button ); g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_HANDLER, handler ); g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_USER_DATA, user_data ); g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_EDITABLE, GUINT_TO_POINTER( editable )); na_gtk_utils_set_editable( G_OBJECT( other ), editable ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( other ), FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( other ), sensitive ); } gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( button ), TRUE ); }
static int gtkListMapMethod(Ihandle* ih) { GtkScrolledWindow* scrolled_window = NULL; GtkListStore *store; store = gtk_list_store_new(1, G_TYPE_STRING); if (ih->data->is_dropdown) { GtkCellRenderer *renderer = NULL; if (ih->data->has_editbox) ih->handle = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(store), 0); else ih->handle = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); if (!ih->handle) return IUP_ERROR; g_object_set(G_OBJECT(ih->handle), "has-frame", TRUE, NULL); if (ih->data->has_editbox) { GtkWidget *entry; #if GTK_CHECK_VERSION(2, 12, 0) GList* list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(ih->handle)); renderer = list->data; g_list_free(list); #endif entry = gtk_bin_get_child(GTK_BIN(ih->handle)); iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry); g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih); g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih); g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */ g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih); g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */ g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih); if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; } else { /* had to add an event box just to get get/killfocus,enter/leave events */ GtkWidget *box = gtk_event_box_new(); gtk_container_add((GtkContainer*)box, ih->handle); iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)box); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ih->handle), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ih->handle), renderer, "text", 0, NULL); g_signal_connect(G_OBJECT(box), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(box), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(box), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(box), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; else GTK_WIDGET_FLAGS(box) |= GTK_CAN_FOCUS; } g_signal_connect(ih->handle, "changed", G_CALLBACK(gtkListComboBoxChanged), ih); g_signal_connect(ih->handle, "notify::popup-shown", G_CALLBACK(gtkListComboBoxPopupShownChanged), ih); if (renderer) { renderer->xpad = 0; renderer->ypad = 0; iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer); } } else { GtkCellRenderer *renderer; GtkTreeSelection* selection; GtkTreeViewColumn *column; GtkPolicyType scrollbar_policy; ih->handle = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); if (!ih->handle) return IUP_ERROR; scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL); if (ih->data->has_editbox) { GtkBox* vbox = (GtkBox*)gtk_vbox_new(FALSE, 0); GtkWidget *entry = gtk_entry_new(); gtk_widget_show(entry); gtk_box_pack_start(vbox, entry, FALSE, FALSE, 0); iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry); gtk_widget_show((GtkWidget*)vbox); gtk_box_pack_end(vbox, (GtkWidget*)scrolled_window, TRUE, TRUE, 0); iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)vbox); iupAttribSetStr(ih, "_IUPGTK_SCROLLED_WINDOW", (char*)scrolled_window); GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; /* focus goes only to the edit box */ if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(entry) &= ~GTK_CAN_FOCUS; g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih); g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih); g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */ g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(gtkListEditKeyPressEvent), ih); g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih); g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */ g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih); } else { iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)scrolled_window); if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkListSimpleKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); } column = gtk_tree_view_column_new(); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer, "text", 0, NULL); iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer); g_object_set(G_OBJECT(renderer), "xpad", 0, NULL); g_object_set(G_OBJECT(renderer), "ypad", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(ih->handle), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(ih->handle), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ih->handle), FALSE); gtk_container_add((GtkContainer*)scrolled_window, ih->handle); gtk_widget_show((GtkWidget*)scrolled_window); gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_IN); if (ih->data->sb) { if (iupStrBoolean(iupAttribGetStr(ih, "AUTOHIDE"))) scrollbar_policy = GTK_POLICY_AUTOMATIC; else scrollbar_policy = GTK_POLICY_ALWAYS; } else scrollbar_policy = GTK_POLICY_NEVER; gtk_scrolled_window_set_policy(scrolled_window, scrollbar_policy, scrollbar_policy); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle)); if (!ih->data->has_editbox && ih->data->is_multiple) { gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); #if GTK_CHECK_VERSION(2, 10, 0) gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(ih->handle), TRUE); #endif } else gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(gtkListSelectionChanged), ih); g_signal_connect(G_OBJECT(ih->handle), "row-activated", G_CALLBACK(gtkListRowActivated), ih); g_signal_connect(G_OBJECT(ih->handle), "motion-notify-event",G_CALLBACK(iupgtkMotionNotifyEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(iupgtkButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(iupgtkButtonEvent), ih); } /* add to the parent, all GTK controls must call this. */ iupgtkBaseAddToParent(ih); if (scrolled_window) gtk_widget_realize((GtkWidget*)scrolled_window); gtk_widget_realize(ih->handle); /* configure for DRAG&DROP */ if (IupGetCallback(ih, "DROPFILES_CB")) iupAttribSetStr(ih, "DRAGDROP", "YES"); iupListSetInitialItems(ih); return IUP_NOERROR; }
void gui_init (dt_lib_module_t *self) { dt_lib_export_t *d = (dt_lib_export_t *)malloc(sizeof(dt_lib_export_t)); self->data = (void *)d; self->widget = gtk_table_new(8, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(self->widget), 5); GtkWidget *label; label = dtgtk_label_new(_("target storage"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0, 0, 0); d->storage = GTK_COMBO_BOX(gtk_combo_box_new_text()); GList *it = darktable.imageio->plugins_storage; while(it) { dt_imageio_module_storage_t *module = (dt_imageio_module_storage_t *)it->data; gtk_combo_box_append_text(d->storage, module->name()); it = g_list_next(it); } gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->storage), 0, 2, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0); g_signal_connect (G_OBJECT (d->storage), "changed", G_CALLBACK (storage_changed), (gpointer)d); d->storage_box = GTK_CONTAINER(gtk_alignment_new(1.0, 1.0, 1.0, 1.0)); gtk_alignment_set_padding(GTK_ALIGNMENT(d->storage_box), 0, 0, 0, 0); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->storage_box), 0, 2, 2, 3, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = dtgtk_label_new(_("file format"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_set_row_spacing(GTK_TABLE(self->widget), 2, 20); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 2, 3, 4, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->format = GTK_COMBO_BOX(gtk_combo_box_new_text()); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->format), 0, 2, 4, 5, GTK_EXPAND|GTK_FILL, 0, 0, 0); g_signal_connect (G_OBJECT (d->format), "changed", G_CALLBACK (format_changed), (gpointer)d); d->format_box = GTK_CONTAINER(gtk_alignment_new(1.0, 1.0, 1.0, 1.0)); gtk_alignment_set_padding(GTK_ALIGNMENT(d->format_box), 0, 0, 0, 0); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->format_box), 0, 2, 5, 6, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = dtgtk_label_new(_("global options"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT); gtk_table_set_row_spacing(GTK_TABLE(self->widget), 5, 20); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 2, 6, 7, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->width = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 10000, 1)); g_object_set(G_OBJECT(d->width), "tooltip-text", _("maximum output width\nset to 0 for no scaling"), (char *)NULL); d->height = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 10000, 1)); g_object_set(G_OBJECT(d->height), "tooltip-text", _("maximum output height\nset to 0 for no scaling"), (char *)NULL); dt_gui_key_accel_block_on_focus (GTK_WIDGET (d->width)); dt_gui_key_accel_block_on_focus (GTK_WIDGET (d->height)); /* gtk_widget_add_events(GTK_WIDGET(d->width), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (d->width), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (d->width), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(d->height), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (d->height), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (d->height), "focus-out-event", G_CALLBACK(focus_out), NULL); */ label = gtk_label_new(_("max size")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 7, 8, GTK_EXPAND|GTK_FILL, 0, 0, 0); GtkBox *hbox = GTK_BOX(gtk_hbox_new(FALSE, 5)); gtk_box_pack_start(hbox, GTK_WIDGET(d->width), TRUE, TRUE, 0); gtk_box_pack_start(hbox, gtk_label_new(_("x")), FALSE, FALSE, 0); gtk_box_pack_start(hbox, GTK_WIDGET(d->height), TRUE, TRUE, 0); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(hbox), 1, 2, 7, 8, GTK_EXPAND|GTK_FILL, 0, 0, 0); label = gtk_label_new(_("intent")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 8, 9, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->intent = GTK_COMBO_BOX(gtk_combo_box_new_text()); gtk_combo_box_append_text(d->intent, _("image settings")); gtk_combo_box_append_text(d->intent, _("perceptual")); gtk_combo_box_append_text(d->intent, _("relative colorimetric")); gtk_combo_box_append_text(d->intent, C_("rendering intent", "saturation")); gtk_combo_box_append_text(d->intent, _("absolute colorimetric")); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->intent), 1, 2, 8, 9, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->profiles = NULL; dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t)); g_strlcpy(prof->filename, "sRGB", sizeof(prof->filename)); g_strlcpy(prof->name, _("sRGB (web-safe)"), sizeof(prof->name)); int pos; prof->pos = 1; d->profiles = g_list_append(d->profiles, prof); prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t)); g_strlcpy(prof->filename, "adobergb", sizeof(prof->filename)); g_strlcpy(prof->name, _("Adobe RGB"), sizeof(prof->name)); prof->pos = 2; d->profiles = g_list_append(d->profiles, prof); prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t)); g_strlcpy(prof->filename, "X profile", sizeof(prof->filename)); g_strlcpy(prof->name, "X profile", sizeof(prof->name)); prof->pos = 3; d->profiles = g_list_append(d->profiles, prof); prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t)); g_strlcpy(prof->filename, "linear_rgb", sizeof(prof->filename)); g_strlcpy(prof->name, _("linear RGB"), sizeof(prof->name)); pos = prof->pos = 4; d->profiles = g_list_append(d->profiles, prof); // read datadir/color/out/*.icc char datadir[DT_MAX_PATH_LEN]; char confdir[DT_MAX_PATH_LEN]; char dirname[DT_MAX_PATH_LEN]; char filename[DT_MAX_PATH_LEN]; dt_loc_get_user_config_dir(confdir, DT_MAX_PATH_LEN); dt_loc_get_datadir(datadir, DT_MAX_PATH_LEN); cmsHPROFILE tmpprof; const gchar *d_name; snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", confdir); if(!g_file_test(dirname, G_FILE_TEST_IS_DIR)) snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", datadir); GDir *dir = g_dir_open(dirname, 0, NULL); if(dir) { while((d_name = g_dir_read_name(dir))) { snprintf(filename, DT_MAX_PATH_LEN, "%s/%s", dirname, d_name); tmpprof = cmsOpenProfileFromFile(filename, "r"); if(tmpprof) { char *lang = getenv("LANG"); if (!lang) lang = "en_US"; dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t)); char name[1024]; cmsGetProfileInfoASCII(tmpprof, cmsInfoDescription, lang, lang+3, name, 1024); g_strlcpy(prof->name, name, sizeof(prof->name)); g_strlcpy(prof->filename, d_name, sizeof(prof->filename)); prof->pos = ++pos; cmsCloseProfile(tmpprof); d->profiles = g_list_append(d->profiles, prof); } } g_dir_close(dir); } GList *l = d->profiles; label = gtk_label_new(_("profile")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 9, 10, GTK_EXPAND|GTK_FILL, 0, 0, 0); d->profile = GTK_COMBO_BOX(gtk_combo_box_new_text()); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->profile), 1, 2, 9, 10, GTK_SHRINK|GTK_EXPAND|GTK_FILL, 0, 0, 0); // gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->profile), 1, 2, 9, 10, GTK_EXPAND|GTK_FILL, 0, 0, 0); gtk_combo_box_append_text(d->profile, _("image settings")); while(l) { dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)l->data; if(!strcmp(prof->name, "X profile")) gtk_combo_box_append_text(d->profile, _("system display profile")); else gtk_combo_box_append_text(d->profile, prof->name); l = g_list_next(l); } #if 0 // set ellipsisation: GList *renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(d->profile)); it = renderers; while(it) { GtkCellRendererText *tr = GTK_CELL_RENDERER_TEXT(it->data); g_object_set(G_OBJECT(tr), "ellipsize", PANGO_ELLIPSIZE_MIDDLE, (char *)NULL); it = g_list_next(it); } g_list_free(renderers); #endif gtk_widget_set_size_request(GTK_WIDGET(d->profile), 200, -1); gtk_combo_box_set_active(d->profile, 0); char tooltip[1024]; snprintf(tooltip, 1024, _("output icc profiles in %s/color/out or %s/color/out"), confdir, datadir); g_object_set(G_OBJECT(d->profile), "tooltip-text", tooltip, (char *)NULL); g_signal_connect (G_OBJECT (d->intent), "changed", G_CALLBACK (intent_changed), (gpointer)d); g_signal_connect (G_OBJECT (d->profile), "changed", G_CALLBACK (profile_changed), (gpointer)d); GtkButton *button = GTK_BUTTON(gtk_button_new_with_label(_("export"))); d->export_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("export with current settings (ctrl-e)"), (char *)NULL); gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(button), 1, 2, 10, 11, GTK_EXPAND|GTK_FILL, 0, 0, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (export_button_clicked), (gpointer)self); g_signal_connect (G_OBJECT (d->width), "value-changed", G_CALLBACK (width_changed), (gpointer)0); g_signal_connect (G_OBJECT (d->height), "value-changed", G_CALLBACK (height_changed), (gpointer)0); self->gui_reset(self); }
static void ygtk_help_dialog_init (YGtkHelpDialog *dialog) { gtk_container_set_border_width (GTK_CONTAINER (dialog), 6); gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_title (GTK_WINDOW (dialog), _("Help")); GdkPixbuf *icon = gtk_widget_render_icon ( GTK_WIDGET (dialog), GTK_STOCK_HELP, GTK_ICON_SIZE_MENU, NULL); gtk_window_set_icon (GTK_WINDOW (dialog), icon); g_object_unref (G_OBJECT (icon)); gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 450); // help text dialog->help_box = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->help_box), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->help_box), GTK_SHADOW_IN); dialog->help_text = ygtk_html_wrap_new(); gtk_container_add (GTK_CONTAINER (dialog->help_box), dialog->help_text); #if 0 // show a nice background image GtkIconTheme *theme = gtk_icon_theme_get_default(); GtkIconInfo *info = gtk_icon_theme_lookup_icon (theme, HELP_IMG_BG, 192, 0); if (info) { GdkPixbuf *pixbuf = gtk_icon_info_load_icon (info, NULL); if (pixbuf) { const gchar *filename = gtk_icon_info_get_filename (info); GdkPixbuf *transparent = ygutils_setOpacity (pixbuf, 60, FALSE); ygtk_html_wrap_set_background (dialog->help_text, transparent, filename); g_object_unref (pixbuf); g_object_unref (transparent); } gtk_icon_info_free (info); } #endif // bottom part (search entry + close button) dialog->search_entry = gtk_entry_new(); gtk_widget_set_size_request (dialog->search_entry, 140, -1); gtk_entry_set_icon_from_stock (GTK_ENTRY (dialog->search_entry), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND); gtk_entry_set_icon_activatable (GTK_ENTRY (dialog->search_entry), GTK_ENTRY_ICON_PRIMARY, TRUE); g_signal_connect (G_OBJECT (dialog->search_entry), "icon-press", G_CALLBACK (search_entry_icon_press_cb), dialog); g_signal_connect (G_OBJECT (dialog->search_entry), "changed", G_CALLBACK (search_entry_changed_cb), dialog); g_signal_connect (G_OBJECT (dialog->search_entry), "activate", G_CALLBACK (search_entry_activated_cb), dialog); dialog->close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); gtk_widget_set_can_default(dialog->close_button, TRUE); GtkWidget *close_box = gtk_hbutton_box_new(); gtk_container_add (GTK_CONTAINER (close_box), dialog->close_button); char *label_str = ygutils_mapKBAccel (_("&Find:")); GtkWidget *bottom_box, *label = gtk_label_new_with_mnemonic (label_str); g_free (label_str); gtk_misc_set_alignment (GTK_MISC (label), 0, .5); gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->search_entry); bottom_box = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (bottom_box), dialog->search_entry, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (bottom_box), close_box, FALSE, FALSE, 0); #ifdef SET_HELP_HISTORY dialog->history_combo = gtk_combo_box_new_text(); GList *cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (dialog->history_combo)); g_object_set (G_OBJECT (cells->data), "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_list_free (cells); #endif // glue it dialog->vbox = gtk_vbox_new (FALSE, 6); #ifdef SET_HELP_HISTORY GtkWidget *hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), gtk_image_new_from_stock (GTK_STOCK_HELP, GTK_ICON_SIZE_BUTTON), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), dialog->history_combo, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (dialog->vbox), hbox, FALSE, TRUE, 0); #endif gtk_box_pack_start (GTK_BOX (dialog->vbox), dialog->help_box, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (dialog->vbox), bottom_box, FALSE, TRUE, 0); gtk_container_add (GTK_CONTAINER (dialog), dialog->vbox); gtk_widget_show_all (dialog->vbox); g_signal_connect (G_OBJECT (dialog->close_button), "clicked", G_CALLBACK (close_button_clicked_cb), dialog); g_signal_connect (G_OBJECT (dialog), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); }
gboolean gnc_tree_util_split_reg_rotate (GncTreeViewSplitReg *view, GtkTreeViewColumn *col, Transaction *trans, Split *split) { GtkCellRenderer *cr0 = NULL; GList *renderers; ViewCol viewcol; // Get the first renderer, it has the view-column value. renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col)); cr0 = g_list_nth_data (renderers, 0); g_list_free (renderers); viewcol = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cr0), "view_column")); if (viewcol == COL_RECN) { const char recn_flags[] = {NREC, CREC, 0}; // List of reconciled flags const gchar *flags; const gchar *text; gchar *this_flag; gint index = 0; char rec; flags = recn_flags; text = g_strdup_printf("%c", xaccSplitGetReconcile (split)); /* Find the existing text in the list of flags */ this_flag = strstr (flags, text); if (this_flag != NULL && *this_flag != '\0') { /* In the list, choose the next item in the list (wrapping around as necessary). */ index = this_flag - flags; if (flags[index + 1] != '\0') index = index + 1; else index = 0; rec = recn_flags[index]; } else rec = NREC; gnc_tree_view_split_reg_set_dirty_trans (view, trans); if (!xaccTransIsOpen (trans)) xaccTransBeginEdit (trans); xaccSplitSetReconcile (split, rec); return TRUE; } if (viewcol == COL_TYPE) { const char type_flags[] = {TXN_TYPE_INVOICE, TXN_TYPE_PAYMENT, 0}; // list of type flags const gchar *flags; const gchar *text; gchar *this_flag; gint index = 0; char type; flags = type_flags; text = g_strdup_printf("%c", xaccTransGetTxnType (trans)); /* Find the existing text in the list of flags */ this_flag = strstr (flags, text); if (this_flag != NULL && *this_flag != '\0') { /* In the list, choose the next item in the list (wrapping around as necessary). */ index = this_flag - flags; if (flags[index + 1] != '\0') index = index + 1; else index = 0; type = type_flags[index]; } else type = TXN_TYPE_NONE; gnc_tree_view_split_reg_set_dirty_trans (view, trans); if (!xaccTransIsOpen (trans)) xaccTransBeginEdit (trans); xaccTransSetTxnType (trans, type); return TRUE; } return FALSE; }
void on_final_account_prepare (hierarchy_data *data) { GSList *actlist; GtkTreeView *tree_view; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gnc_commodity *com; /* Anything to do? */ if (!data->category_set_changed) return; data->category_set_changed = FALSE; gnc_suspend_gui_refresh (); /* Delete any existing account tree */ if (data->final_account_tree) { gtk_widget_destroy(GTK_WIDGET(data->final_account_tree)); data->final_account_tree = NULL; } delete_our_account_tree (data); /* Build a new account list */ actlist = get_selected_account_list (data->categories_tree); com = gnc_currency_edit_get_currency (GNC_CURRENCY_EDIT(data->currency_selector)); data->our_account_tree = hierarchy_merge_accounts (actlist, com); /* Now build a new account tree */ data->final_account_tree = GNC_TREE_VIEW_ACCOUNT(gnc_tree_view_account_new_with_root (data->our_account_tree, FALSE)); tree_view = GTK_TREE_VIEW(data->final_account_tree); gnc_tree_view_account_set_name_edited(data->final_account_tree, gnc_tree_view_account_name_edited_cb); gnc_tree_view_account_set_code_edited(data->final_account_tree, gnc_tree_view_account_code_edited_cb); gnc_tree_view_account_set_description_edited(data->final_account_tree, gnc_tree_view_account_description_edited_cb); gnc_tree_view_account_set_notes_edited(data->final_account_tree, gnc_tree_view_account_notes_edited_cb); gtk_tree_view_set_headers_visible (tree_view, TRUE); column = gnc_tree_view_find_column_by_name ( GNC_TREE_VIEW(data->final_account_tree), "type"); g_object_set_data(G_OBJECT(column), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); gnc_tree_view_configure_columns (GNC_TREE_VIEW(data->final_account_tree)); gnc_tree_view_set_show_column_menu (GNC_TREE_VIEW(data->final_account_tree), FALSE); selection = gtk_tree_view_get_selection (tree_view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); // This is a re-definition of the placeholder that the account-tree model // provides, reflecting the to-be-created state of the account tree // post-merge. { renderer = gtk_cell_renderer_toggle_new(); g_object_set(G_OBJECT (renderer), "activatable", FALSE, "sensitive", FALSE, NULL); column = gtk_tree_view_column_new_with_attributes(_("Placeholder"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, placeholder_cell_data_func, (gpointer)data, NULL); gnc_tree_view_append_column (GNC_TREE_VIEW(tree_view), column); } { renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "xalign", 1.0, (char *)NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (balance_cell_edited), data); column = gtk_tree_view_column_new_with_attributes (_("Opening Balance"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, balance_cell_data_func, (gpointer)data, NULL); gnc_tree_view_append_column (GNC_TREE_VIEW(tree_view), column); } // only in the case where there *are* existing accounts... if (gnc_account_n_descendants(gnc_book_get_root_account(gnc_get_current_book())) > 0) { GList *renderers; column = gnc_tree_view_add_text_column(GNC_TREE_VIEW(tree_view), _("Use Existing"), NULL, NULL, "yes", GNC_TREE_VIEW_COLUMN_DATA_NONE, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, NULL); renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column)); g_object_set(G_OBJECT(renderer), "xalign", 1.0, (char*)NULL); gtk_tree_view_column_set_cell_data_func(column, GTK_CELL_RENDERER(renderers->data), use_existing_account_data_func, (gpointer)data, NULL); g_list_free(renderers); } gtk_container_add(GTK_CONTAINER(data->final_account_tree_container), GTK_WIDGET(data->final_account_tree)); /* Expand the entire tree */ gtk_tree_view_expand_all (tree_view); gtk_widget_show(GTK_WIDGET(data->final_account_tree)); gnc_resume_gui_refresh (); }
static GtkWidget * ignore_treeview_new (GtkWidget *box) { GtkListStore *store; GtkWidget *view; GtkTreeViewColumn *col; GtkCellRenderer *render; int col_id; store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); g_return_val_if_fail (store != NULL, NULL); view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store), NULL, MASK_COLUMN, _("Mask"), CHAN_COLUMN, _("Channel"), PRIV_COLUMN, _("Private"), NOTICE_COLUMN, _("Notice"), CTCP_COLUMN, _("CTCP"), DCC_COLUMN, _("DCC"), INVITE_COLUMN, _("Invite"), UNIGNORE_COLUMN, _("Unignore"), -1); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (view), 0), TRUE); /* attach to signals and customise columns */ for (col_id=0; (col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), col_id)); col_id++) { GList *list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col)); GList *tmp; for (tmp = list; tmp; tmp = tmp->next) { render = static_cast<GtkCellRenderer*>(tmp->data); if (col_id > 0) /* it's a toggle button column */ { g_signal_connect (render, "toggled", G_CALLBACK (option_toggled), GINT_TO_POINTER (col_id)); } else /* mask column */ { g_object_set (G_OBJECT (render), "editable", TRUE, NULL); g_signal_connect (render, "edited", G_CALLBACK (mask_edited), NULL); /* make this column sortable */ gtk_tree_view_column_set_sort_column_id (col, col_id); gtk_tree_view_column_set_min_width (col, 272); } /* centre titles */ gtk_tree_view_column_set_alignment (col, 0.5); } g_list_free (list); } gtk_widget_show (view); return view; }