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;
}
