static void
can_unload (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
PluginInfo *info;
gboolean loaded;
gtk_tree_model_get(tree_model, iter,
PLUGIN_COLUMN, &info, -1);
gtk_tree_model_get(tree_model, iter,
LOADED_COLUMN, &loaded, -1);
if (!loaded || (loaded && dia_plugin_can_unload(info)))
{
cell->mode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
GTK_CELL_RENDERER_TOGGLE(cell)->activatable = TRUE;
}
else
{
cell->mode = GTK_CELL_RENDERER_MODE_INERT;
GTK_CELL_RENDERER_TOGGLE(cell)->activatable = FALSE;
}
}
static void
global_vars_view_type_data_func (GtkTreeViewColumn *col,
GtkCellRenderer *cell,
GtkTreeModel *global_vars_model,
GtkTreeIter *iter,
gpointer user_data)
{
gboolean is_command = FALSE, is_internal = TRUE;
/* Assertions */
g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (cell));
/* Check if it's internal */
gtk_tree_model_get (global_vars_model, iter,
GLOBAL_VARS_MODEL_COL_IS_INTERNAL, &is_internal,
-1);
if (is_internal)
{
g_object_set (cell, "sensitive", FALSE, NULL);
gtk_cell_renderer_toggle_set_activatable (GTK_CELL_RENDERER_TOGGLE (cell), FALSE);
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell), FALSE);
}
else
{
gtk_tree_model_get (global_vars_model, iter,
GLOBAL_VARS_MODEL_COL_IS_COMMAND, &is_command,
-1);
g_object_set (cell, "sensitive", TRUE, NULL);
gtk_cell_renderer_toggle_set_activatable (GTK_CELL_RENDERER_TOGGLE (cell), TRUE);
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell), is_command);
}
}
static void
photos_organize_collection_view_check_toggled (PhotosOrganizeCollectionView *self, gchar *path)
{
GApplication *app;
GList *urns;
GtkTreeIter iter;
GtkTreePath *tree_path;
PhotosSearchContextState *state;
PhotosSetCollectionJob *job;
gboolean active;
gchar *coll_urn;
app = g_application_get_default ();
state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));
tree_path = gtk_tree_path_new_from_string (path);
gtk_tree_model_get_iter (GTK_TREE_MODEL (self->model), &iter, tree_path);
gtk_tree_model_get (GTK_TREE_MODEL (self->model), &iter, PHOTOS_ORGANIZE_MODEL_ID, &coll_urn, -1);
active = gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (self->renderer_check));
job = photos_set_collection_job_new (coll_urn, !active);
urns = photos_selection_controller_get_selection (self->sel_cntrlr);
photos_set_collection_job_run (job,
state,
urns,
self->cancellable,
photos_organize_collection_view_set_collection_executed,
self);
g_object_unref (job);
g_free (coll_urn);
}
static gboolean
gimp_cell_renderer_toggle_activate (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GtkCellRendererToggle *toggle = GTK_CELL_RENDERER_TOGGLE (cell);
if (gtk_cell_renderer_toggle_get_activatable (toggle))
{
GdkModifierType state = 0;
if (event && ((GdkEventAny *) event)->type == GDK_BUTTON_PRESS)
state = ((GdkEventButton *) event)->state;
gimp_cell_renderer_toggle_clicked (GIMP_CELL_RENDERER_TOGGLE (cell),
path, state);
return TRUE;
}
return FALSE;
}
static void
placeholder_cell_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
Account *account, *root;
gboolean willbe_placeholder = FALSE;
GncAccountMergeDisposition disp;
g_return_if_fail (GTK_TREE_MODEL (model));
account = gnc_tree_view_account_get_account_from_iter (model, iter);
root = gnc_book_get_root_account(gnc_get_current_book());
disp = determine_merge_disposition(root, account);
switch (disp)
{
case GNC_ACCOUNT_MERGE_DISPOSITION_USE_EXISTING:
{
/* find the existing account, do whatever it is. */
gchar *full_name;
Account *existing_acct;
full_name = gnc_account_get_full_name(account);
existing_acct = gnc_account_lookup_by_full_name(root, full_name);
willbe_placeholder = xaccAccountGetPlaceholder(existing_acct);
g_free(full_name);
}
break;
case GNC_ACCOUNT_MERGE_DISPOSITION_CREATE_NEW:
willbe_placeholder = xaccAccountGetPlaceholder(account);
break;
}
gtk_cell_renderer_toggle_set_active(GTK_CELL_RENDERER_TOGGLE(cell), willbe_placeholder);
}
static void
he_check_button_init (HeCheckButton *self)
{
HeCheckButtonPrivate *priv = HE_CHECK_BUTTON_GET_PRIVATE (self);
/* Store private part */
self->priv = priv;
priv->title = GTK_LABEL (gtk_label_new (NULL));
priv->value = GTK_LABEL (gtk_label_new (NULL));
priv->alignment = gtk_alignment_new (0.5, 0.5, 0, 0);
priv->toggle_renderer = GTK_CELL_RENDERER_TOGGLE (gtk_cell_renderer_toggle_new ());
priv->cell_view = gtk_cell_view_new ();
priv->hbox = NULL;
priv->label_box = NULL;
priv->style = HE_CHECK_BUTTON_STYLE_NORMAL;
priv->setting_style = FALSE;
/* Setup the cell renderer */
/* We need to set the correct style from the gtkrc file. Otherwise the check box
* does not look like a check box on a HildonCheckButton. */
GtkStyle *style = gtk_rc_get_style_by_paths(gtk_widget_get_settings(GTK_WIDGET(self)),
NULL, "*.HildonCheckButton.GtkAlignment.GtkHBox.GtkCellView", G_TYPE_NONE);
gtk_widget_set_style(priv->cell_view, style);
/* Make sure that the check box is always shown, no matter the value of gtk-button-images */
g_signal_connect (priv->cell_view, "notify::visible", G_CALLBACK (gtk_widget_show), NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->cell_view),
GTK_CELL_RENDERER (priv->toggle_renderer), TRUE);
/* Get checkbox-size style property of HildonCheckButton from theme */
style = gtk_rc_get_style_by_paths (gtk_widget_get_settings (GTK_WIDGET(self)),
NULL, "*.HildonCheckButton", HILDON_TYPE_CHECK_BUTTON);
glong checkbox_size = get_style_property_long (style, HILDON_TYPE_CHECK_BUTTON, "checkbox-size");
/* Set the indicator to the right size (the size of the pixmap) */
g_object_set (priv->toggle_renderer, "indicator-size", checkbox_size, NULL);
/* Setup the labels */
gtk_widget_set_name (GTK_WIDGET (priv->title), "hildon-button-title");
gtk_widget_set_name (GTK_WIDGET (priv->value), "hildon-button-value");
he_check_button_set_style (self, HE_CHECK_BUTTON_STYLE_NORMAL);
gtk_misc_set_alignment (GTK_MISC (priv->title), 0, 0.5);
gtk_misc_set_alignment (GTK_MISC (priv->value), 0, 0.5);
g_object_ref_sink (priv->alignment);
/* The labels are not shown automatically, see he_check_button_set_(title|value) */
gtk_widget_set_no_show_all (GTK_WIDGET (priv->title), TRUE);
gtk_widget_set_no_show_all (GTK_WIDGET (priv->value), TRUE);
gtk_button_set_focus_on_click (GTK_BUTTON (self), FALSE);
}
void activate_cell_renderer_toggle_tree_mode(void)
{
GtkCellRendererClass *cell_class;
GtkCellRendererToggle *toggle_renderer;
toggle_renderer = GTK_CELL_RENDERER_TOGGLE(gtk_cell_renderer_toggle_new());
cell_class = GTK_CELL_RENDERER_CLASS(GTK_WIDGET_GET_CLASS(toggle_renderer));
cell_class->activate = gtk_cell_renderer_toggle_activate;
gtk_object_destroy(GTK_OBJECT(toggle_renderer));
}
static GtkWidget *
_gtk_user_list_dialog_create_tree(GtkWidget *widget)
{
GtkWidget *tree;
GtkListStore *store;
GtkTreeModel *model;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* create treeview & model */
tree = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree), FALSE);
store = gtk_list_store_new(3, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING);
model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), GTK_USER_LIST_TREEVIEW_COLUMN_USERNAME, GTK_SORT_ASCENDING);
gtk_tree_view_set_model(GTK_TREE_VIEW(tree), model);
/* insert column to display checkbox */
column = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(renderer), TRUE);
g_signal_connect(G_OBJECT(renderer), "toggled", (GCallback)_gtk_user_list_dialog_tree_checkbox_toggled, widget);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "active", GTK_USER_LIST_TREEVIEW_COLUMN_CHECKBOX);
gtk_tree_view_insert_column(GTK_TREE_VIEW(tree), column, -1);
/* insert column to display icon & text */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "User");
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", GTK_USER_LIST_TREEVIEW_COLUMN_PIXBUF);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", GTK_USER_LIST_TREEVIEW_COLUMN_USERNAME);
gtk_tree_view_insert_column(GTK_TREE_VIEW(tree), column, -1);
/* free data */
g_object_unref(store);
g_object_unref(model);
return tree;
}
static void
can_inhibit (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
PluginInfo *info;
gtk_tree_model_get(tree_model, iter,
PLUGIN_COLUMN, &info, -1);
if ( 0 == strcmp(dia_plugin_get_name(info), "Standard")
|| 0 == strcmp(dia_plugin_get_name(info), "Internal"))
{
cell->mode = GTK_CELL_RENDERER_MODE_INERT;
GTK_CELL_RENDERER_TOGGLE(cell)->activatable = FALSE;
}
else
{
cell->mode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
GTK_CELL_RENDERER_TOGGLE(cell)->activatable = TRUE;
}
}
static void gtkhash_properties_init_objects(struct page_s *page,
GtkBuilder *builder)
{
// Main container
page->box = GTK_WIDGET(gtkhash_properties_get_object(builder,
"vbox"));
g_object_ref(page->box);
// Progress bar
page->progressbar = GTK_PROGRESS_BAR(gtkhash_properties_get_object(builder,
"progressbar"));
// Treeview
page->treeview = GTK_TREE_VIEW(gtkhash_properties_get_object(builder,
"treeview"));
page->treeselection = GTK_TREE_SELECTION(gtkhash_properties_get_object(builder,
"treeselection"));
page->cellrendtoggle = GTK_CELL_RENDERER_TOGGLE(gtkhash_properties_get_object(builder,
"cellrenderertoggle"));
// Popup menu
page->menu = GTK_MENU(gtkhash_properties_get_object(builder,
"menu"));
g_object_ref(page->menu);
page->menuitem_copy = GTK_MENU_ITEM(gtkhash_properties_get_object(builder,
"imagemenuitem_copy"));
page->menuitem_show_funcs = GTK_CHECK_MENU_ITEM(gtkhash_properties_get_object(builder,
"checkmenuitem_show_funcs"));
// Check/MAC inputs
page->hbox_inputs = GTK_WIDGET(gtkhash_properties_get_object(builder,
"hbox_inputs"));
page->entry_check = GTK_ENTRY(gtkhash_properties_get_object(builder,
"entry_check"));
page->togglebutton_hmac = GTK_TOGGLE_BUTTON(gtkhash_properties_get_object(builder,
"togglebutton_hmac"));
page->entry_hmac = GTK_ENTRY(gtkhash_properties_get_object(builder,
"entry_hmac"));
// Buttons
page->button_hash = GTK_BUTTON(gtkhash_properties_get_object(builder,
"button_hash"));
page->button_stop = GTK_BUTTON(gtkhash_properties_get_object(builder,
"button_stop"));
#if (GTK_MAJOR_VERSION > 2)
gtk_button_set_always_show_image(page->button_hash, true);
gtk_button_set_always_show_image(page->button_stop, true);
#endif
}
static void
get_visible (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
GtkTreeViewColumn *column;
gtk_tree_model_get (tree_model, iter, 1, &column, -1);
if (column)
{
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell),
gtk_tree_view_column_get_visible (column));
}
}
static void
enabled_cell_func (GtkTreeViewColumn *column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data)
{
GActionGroup *group = data;
gchar *name;
gboolean enabled;
gtk_tree_model_get (model, iter, 0, &name, -1);
enabled = g_action_group_get_action_enabled (group, name);
g_free (name);
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell), enabled);
}
static void
extract_cell_data_func (GtkTreeViewColumn *column,
GtkCellRenderer *renderer,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
RBAudioCdSource *source)
{
RBAudioCDEntryData *extra_data;
RhythmDBEntry *entry;
entry = rhythmdb_query_model_iter_to_entry (RHYTHMDB_QUERY_MODEL (tree_model), iter);
if (entry != NULL) {
extra_data = RHYTHMDB_ENTRY_GET_TYPE_DATA (entry, RBAudioCDEntryData);
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (renderer), extra_data->extract);
rhythmdb_entry_unref (entry);
}
}
static void
build_sources_view (GdictPrefDialog *dialog)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
if (dialog->sources_list)
return;
dialog->sources_list = gtk_list_store_new (SOURCES_N_COLUMNS,
G_TYPE_BOOLEAN, /* active */
G_TYPE_STRING, /* name */
G_TYPE_STRING /* description */);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dialog->sources_list),
SOURCES_DESCRIPTION_COLUMN,
GTK_SORT_ASCENDING);
renderer = gtk_cell_renderer_toggle_new ();
gtk_cell_renderer_toggle_set_radio (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE);
g_signal_connect (renderer, "toggled",
G_CALLBACK (source_renderer_toggled_cb),
dialog);
column = gtk_tree_view_column_new_with_attributes ("active",
renderer,
"active", SOURCES_ACTIVE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->sources_view), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("description",
renderer,
"text", SOURCES_DESCRIPTION_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->sources_view), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->sources_view), FALSE);
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->sources_view),
GTK_TREE_MODEL (dialog->sources_list));
g_signal_connect (dialog->sources_view, "row-activated",
G_CALLBACK (sources_view_row_activated_cb),
dialog);
}
static void
photos_organize_collection_view_check_cell (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell_renderer,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer user_data)
{
gchar *id;
gint state;
gtk_tree_model_get (tree_model, iter, PHOTOS_ORGANIZE_MODEL_ID, &id, PHOTOS_ORGANIZE_MODEL_STATE, &state, -1);
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell_renderer),
state & PHOTOS_COLLECTION_STATE_ACTIVE);
g_object_set (cell_renderer,
"inconsistent", (state & PHOTOS_COLLECTION_STATE_INCONSISTENT) != 0,
NULL);
gtk_cell_renderer_set_visible (cell_renderer, g_strcmp0 (id, PHOTOS_COLLECTION_PLACEHOLDER_ID));
}
/* callbacks */
void
on_service_toggled (GtkCellRenderer *renderer, gchar *path_str, gpointer data)
{
GtkTreeView *treeview = GTK_TREE_VIEW (gst_dialog_get_widget (tool->main_dialog, "services_list"));
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
GtkTreePath *path;
GstTool *tool = GST_TOOL (data);
GtkTreeIter iter;
OobsService *service;
gboolean value, new_value, dangerous;
path = gtk_tree_path_new_from_string (path_str);
value = gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (renderer));
new_value = !value;
if (!gtk_tree_model_get_iter (model, &iter, path))
return;
gtk_tree_model_get (model,
&iter,
COL_OBJECT, &service,
COL_DANGEROUS, &dangerous,
-1);
if (new_value || !dangerous || show_warning_dialog (tool, service)) {
OobsServicesRunlevel *rl;
rl = GST_SERVICES_TOOL (tool)->default_runlevel;
oobs_service_set_runlevel_configuration (service, rl,
(new_value) ? OOBS_SERVICE_START : OOBS_SERVICE_IGNORE,
/* FIXME: hardcoded value... */
50);
oobs_object_commit (GST_SERVICES_TOOL (tool)->services_config);
gtk_list_store_set (GTK_LIST_STORE (model),
&iter,
COL_ACTIVE, new_value,
-1);
}
gtk_tree_path_free (path);
}
static void
selected_renderer_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *renderer,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
gboolean selected;
/* Don't show the checkbox on the toplevel items--these are supposed to
* be placeholders to show the two sections, Changes to be committed and
* Changeed but not updated. */
gtk_cell_renderer_set_visible (renderer,
gtk_tree_store_iter_depth (GTK_TREE_STORE (model),
iter) > 0);
gtk_tree_model_get (model, iter, COL_SELECTED, &selected, -1);
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (renderer),
selected);
}
static void
state_cell_func (GtkTreeViewColumn *column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data)
{
GActionGroup *group = data;
gchar *name;
GVariant *state;
gtk_tree_model_get (model, iter, 0, &name, -1);
state = g_action_group_get_action_state (group, name);
g_free (name);
gtk_cell_renderer_set_visible (cell, FALSE);
g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
if (state == NULL)
return;
if (g_variant_is_of_type (state, G_VARIANT_TYPE_BOOLEAN) &&
GTK_IS_CELL_RENDERER_TOGGLE (cell))
{
gtk_cell_renderer_set_visible (cell, TRUE);
g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell),
g_variant_get_boolean (state));
}
else if (g_variant_is_of_type (state, G_VARIANT_TYPE_STRING) &&
GTK_IS_CELL_RENDERER_COMBO (cell))
{
gtk_cell_renderer_set_visible (cell, TRUE);
g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
g_object_set (cell, "text", g_variant_get_string (state, NULL), NULL);
}
g_variant_unref (state);
}
static GtkWidget* do_todos (MaintainrProjectbox *item)
{
GtkListStore *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
GtkTreeSelection *selection;
model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_INT);
item->priv->todos = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_widget_set_tooltip_text (item->priv->todos, "Press '+' to add an item, '-' to remove the selected one");
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (item->priv->todos), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (item->priv->todos), TRUE);
renderer = gtk_cell_renderer_toggle_new ();
gtk_cell_renderer_toggle_set_activatable (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE);
g_object_set (G_OBJECT (renderer), "yalign", 0, NULL);
col = gtk_tree_view_column_new_with_attributes ("Check", renderer, "active", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (item->priv->todos), col);
g_signal_connect (renderer, "toggled", G_CALLBACK (todo_check_changed), item);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "wrap-mode", PANGO_WRAP_WORD, "yalign", 0, NULL);
g_object_set (G_OBJECT (renderer), "editable", TRUE, "wrap-width", 200, NULL);
col = gtk_tree_view_column_new_with_attributes ("String", renderer, "text", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (item->priv->todos), col);
g_signal_connect (renderer, "edited", G_CALLBACK (todo_string_changed), item);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (item->priv->todos));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (item->priv->todos, "realize", G_CALLBACK (activate_focus_management), NULL);
g_signal_connect (item->priv->todos, "focus-out-event", G_CALLBACK (unselect_all_todos), NULL);
g_signal_connect (item->priv->todos, "key-press-event", G_CALLBACK (edit_todo_shortcuts), item);
return item->priv->todos;
}
void _fcitx_main_window_add_addon_page(FcitxMainWindow* self)
{
/* load addon */
FcitxAddon* addon;
utarray_new(self->addons, &addonicd);
FcitxAddonsLoad(self->addons);
GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
/* advance check box */
self->advancecheckbox = gtk_check_button_new_with_label(_("Advance"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->advancecheckbox), FALSE);
g_signal_connect(G_OBJECT(self->advancecheckbox), "toggled", G_CALLBACK(_fcitx_main_window_checkbox_changed), self);
/* filter entry */
self->filterentry = gtk_entry_new();
gtk_entry_set_icon_from_stock (GTK_ENTRY (self->filterentry),
GTK_ENTRY_ICON_SECONDARY,
GTK_STOCK_CLEAR);
g_object_set(G_OBJECT(self->filterentry), "margin", 5, NULL);
#if GTK_CHECK_VERSION(3,2,0)
gtk_entry_set_placeholder_text(GTK_ENTRY (self->filterentry), _("Search Addon"));
#endif
g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL);
gtk_box_pack_start(GTK_BOX(vbox), self->filterentry, FALSE, TRUE, 5);
/* list view */
self->addonstore = gtk_list_store_new(N_COLUMNS, G_TYPE_POINTER);
for (addon = (FcitxAddon *) utarray_front(self->addons);
addon != NULL;
addon = (FcitxAddon *) utarray_next(self->addons, addon)) {
GtkTreeIter iter;
gtk_list_store_append(self->addonstore, &iter);
gtk_list_store_set(self->addonstore, &iter, LIST_ADDON, addon, -1);
}
self->filtermodel = gtk_tree_model_filter_new(GTK_TREE_MODEL(self->addonstore), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel),
(GtkTreeModelFilterVisibleFunc) _filter_addon_func,
self,
NULL);
self->addonview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->filtermodel));
/* add column check box */
self->togglecell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE);
self->checkboxcolumn = gtk_tree_view_column_new_with_attributes("Enable", self->togglecell, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), self->checkboxcolumn);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(self->checkboxcolumn),
self->togglecell,
_fcitx_main_window_enabled_data_func,
NULL,
NULL);
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE);
/* add column text */
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Name", renderer, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), column);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column),
renderer,
_fcitx_main_window_name_data_func,
NULL,
NULL);
/* add addon list to vbox */
GtkWidget* swin = gtk_scrolled_window_new(NULL, NULL);
g_object_set(swin, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
g_object_set(self->addonview, "headers-visible", FALSE, NULL);
gtk_container_add(GTK_CONTAINER(swin), self->addonview);
gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);
g_object_set(G_OBJECT(swin), "margin-left", 5, "margin-right", 5, "shadow-type", GTK_SHADOW_IN, NULL);
g_signal_connect(G_OBJECT(self->togglecell), "toggled",
G_CALLBACK(_fcitx_main_window_toggled_cb), GTK_TREE_MODEL(self->addonstore));
gtk_box_pack_start(GTK_BOX(vbox), self->advancecheckbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(self->advancecheckbox), "margin-left", 5, "margin-right", 5, NULL);
/* configure button */
GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(hbuttonbox), "margin", 5, NULL);
self->button = gtk_button_new_with_label(_("Configure"));
gtk_widget_set_sensitive(self->button, FALSE);
gtk_button_set_image(GTK_BUTTON(self->button), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start(GTK_BOX(hbuttonbox), self->button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(self->button), "clicked", G_CALLBACK(_fcitx_main_window_configure_button_clicked), self);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->addonview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(_fcitx_main_window_addon_selection_changed), self);
g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_main_window_filtertext_changed), self);
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
_fcitx_main_window_add_page(self, _("Addon"), vbox, GTK_STOCK_ADD);
}
// Create and bind the tree model to the tree view for the subtitle track list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_subtitle_tree_model (signal_user_data_t *ud)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
GtkListStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkWidget *widget;
g_debug("bind_subtitle_tree_model ()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET (ud->builder, "subtitle_list"));
selection = gtk_tree_view_get_selection (treeview);
// 6 columns in model. 5 are visible, the other 1 is for storing
// values that I need
// Track, force, burn, default, type, srt offset, track short, source
// force visible, burn visible, offset visible
treestore = gtk_list_store_new(10,
G_TYPE_STRING,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_INT, G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Track"), cell, "text", 0, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 350);
gtk_tree_view_column_set_max_width (column, 350);
cell = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes(
_("Forced Only"), cell, "active", 1, "visible", 7, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(cell, "toggled", subtitle_forced_toggled_cb, ud);
cell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(cell), TRUE);
column = gtk_tree_view_column_new_with_attributes(
_("Burned In"), cell, "active", 2, "visible", 8, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(cell, "toggled", subtitle_burned_toggled_cb, ud);
cell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(cell), TRUE);
column = gtk_tree_view_column_new_with_attributes(
_("Default"), cell, "active", 3, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(cell, "toggled", subtitle_default_toggled_cb, ud);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Srt Offset"), cell, "text", 4, "visible", 9, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(selection, "changed", subtitle_list_selection_changed_cb, ud);
// Need to disable remove and update buttons since there are initially
// no selections
widget = GHB_WIDGET (ud->builder, "subtitle_remove");
gtk_widget_set_sensitive(widget, FALSE);
g_debug("Done\n");
}
void gglk_do_gestalt(GtkMenuItem *unused_menuitem,
gpointer unused_data)
{
static GtkWidget *dialog_gestalt;
GtkTreeView *tree;
GtkTreeStore *store;
if(dialog_gestalt) {
gtk_window_present(GTK_WINDOW(dialog_gestalt));
return;
}
dialog_gestalt = create_dialog_gestalt();
g_signal_connect(dialog_gestalt, "destroy",
G_CALLBACK(gtk_widget_destroyed),
&dialog_gestalt);
g_bindable_bind(
g_bindable_new_from_gconf("gestalt/Version"),
g_bindable_new_from_glade(dialog_gestalt, "gestalt_claim_version"),
NULL);
tree = GTK_TREE_VIEW(lookup_widget(dialog_gestalt,
"enable_disable_pretend"));
store = gtk_tree_store_new(5, G_TYPE_STRING, G_TYPE_INT,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
gtk_tree_view_set_model(tree, GTK_TREE_MODEL(store));
gtk_tree_view_insert_column_with_attributes(tree, -1, "Gestalt",
gtk_cell_renderer_text_new(),
"text", 0,
NULL);
{
int i;
static const char column_names[] =
"Enable" "\0" "Disable" "\0" "Pretend" "\0";
const char *p;
i = 2;
for(p = column_names; *p; p += strlen(p) + 1) {
GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_radio(
GTK_CELL_RENDERER_TOGGLE(renderer), TRUE);
g_object_set_data(G_OBJECT(renderer), "column",GINT_TO_POINTER(i));
g_signal_connect(renderer, "toggled",
G_CALLBACK(gglk_radio_toggled), store);
gtk_tree_view_insert_column_with_attributes(tree, -1, p,
renderer,
"active", i,
NULL);
i++;
}
}
{
static const char line_names[] =
"Mouse Input" "\0"
"Timer Events" "\0"
"Unicode" "\0"
"Graphics" "\0"
" Draw Image" "\0"
" Transparency" "\0"
"Sound" "\0"
" Volume" "\0"
" Notify Events" "\0"
" Music Resources" "\0"
"Hyperlinks" "\0"
" Input Events" "\0";
static const glui32 line_nums[] = {
gestalt_MouseInput,
gestalt_Timer,
gestalt_Unicode,
gestalt_Graphics,
gestalt_DrawImage,
gestalt_GraphicsTransparency,
gestalt_Sound,
gestalt_SoundVolume,
gestalt_SoundNotify,
gestalt_SoundMusic,
gestalt_Hyperlinks,
gestalt_HyperlinkInput
};
glui32 i;
const char *p;
GtkTreeIter parent_iter, iter;
i = 0;
for(p = line_names; *p; p += strlen(p) + 1) {
if(*p == ' ') {
gtk_tree_store_append(store, &iter, &parent_iter);
gglk_do_gestalt_line(store, &iter, p+1, line_nums[i]);
} else {
gtk_tree_store_append(store, &parent_iter, NULL);
gglk_do_gestalt_line(store, &parent_iter, p, line_nums[i]);
}
i++;
}
}
gtk_tree_view_expand_all(tree);
gtk_widget_show(dialog_gestalt);
}
static void
_gui_styles_dialog_run (gboolean edit,const char *name,int imgid)
{
char title[512];
/* check if style exists */
if (name && (dt_styles_exists (name))==0)
return;
/* initialize the dialog */
dt_gui_styles_dialog_t *sd=(dt_gui_styles_dialog_t *)g_malloc (sizeof (dt_gui_styles_dialog_t));
sd->nameorig = g_strdup(name);
if (edit)
{
sprintf (title,_("edit style"));
g_strlcat (title, " \"", 512);
g_strlcat(title, name, 512);
g_strlcat(title, "\"", 512);
sd->duplicate = gtk_check_button_new_with_label(_("duplicate style"));
g_object_set (sd->duplicate, "tooltip-text", _("creates a duplicate of the style before applying changes"), (char *)NULL);
}
else
{
sd->imgid = imgid;
sprintf (title,"%s",_("create new style"));
sd->duplicate = NULL;
}
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkDialog *dialog = GTK_DIALOG (gtk_dialog_new_with_buttons (title,
GTK_WINDOW(window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT,
NULL));
GtkContainer *content_area = GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog)));
GtkWidget *alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT(alignment), 5, 5, 5, 5);
gtk_container_add (content_area, alignment);
GtkBox *box = GTK_BOX (gtk_vbox_new(FALSE, 5));
gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (box));
sd->name = gtk_entry_new();
g_object_set (sd->name, "tooltip-text", _("enter a name for the new style"), (char *)NULL);
sd->description = gtk_entry_new();
g_object_set (sd->description, "tooltip-text", _("enter a description for the new style, this description is searchable"), (char *)NULL);
/*set values*/
if (edit)
{
/* name */
gtk_entry_set_text(GTK_ENTRY(sd->name), name);
/* description */
gchar *desc = dt_styles_get_description (name);
if (desc)
{
gtk_entry_set_text (GTK_ENTRY (sd->description),desc);
g_free (desc);
}
}
gtk_box_pack_start (box,sd->name,FALSE,FALSE,0);
gtk_box_pack_start (box,sd->description,FALSE,FALSE,0);
/* create the list of items */
sd->items = GTK_TREE_VIEW (gtk_tree_view_new ());
GtkListStore *liststore = gtk_list_store_new (DT_STYLE_ITEMS_NUM_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT);
/* enabled */
GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new ();
gtk_cell_renderer_toggle_set_activatable (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE);
g_object_set_data (G_OBJECT (renderer), "column", (gint *)DT_STYLE_ITEMS_COL_ENABLED);
g_signal_connect (renderer, "toggled", G_CALLBACK (_gui_styles_item_toggled), sd);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (sd->items),
-1, _("include"),
renderer,
"active",
DT_STYLE_ITEMS_COL_ENABLED,
NULL);
/* name */
renderer = gtk_cell_renderer_text_new ();
g_object_set_data (G_OBJECT (renderer), "column", (gint *)DT_STYLE_ITEMS_COL_NAME);
g_object_set (renderer, "xalign", 0.0, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (sd->items),
-1, _("item"),
renderer,
"text",
DT_STYLE_ITEMS_COL_NAME,
NULL);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->items)), GTK_SELECTION_SINGLE);
gtk_tree_view_set_model (GTK_TREE_VIEW(sd->items), GTK_TREE_MODEL(liststore));
gtk_box_pack_start (box,GTK_WIDGET (sd->items),TRUE,TRUE,0);
if (edit)
gtk_box_pack_start (box,GTK_WIDGET (sd->duplicate),FALSE,FALSE,0);
/* fill list with history items */
GtkTreeIter iter;
if (edit)
{
/* get history items for named style and populate the items list */
GList *items = dt_styles_get_item_list (name, FALSE);
if (items)
{
do
{
dt_style_item_t *item=(dt_style_item_t *)items->data;
gtk_list_store_append (GTK_LIST_STORE(liststore), &iter);
gtk_list_store_set (GTK_LIST_STORE(liststore), &iter,
DT_STYLE_ITEMS_COL_ENABLED, TRUE,
DT_STYLE_ITEMS_COL_NAME, item->name,
DT_STYLE_ITEMS_COL_NUM, (guint)item->num,
-1);
g_free(item->name);
g_free(item);
}
while ((items=g_list_next(items)));
}
}
else
{
GList *items = dt_history_get_items (imgid,FALSE);
if (items)
{
do
{
dt_history_item_t *item = (dt_history_item_t *)items->data;
/* lookup history item module */
gboolean enabled = TRUE;
dt_iop_module_t *module=NULL;
GList *modules = g_list_first(darktable.develop->iop);
if (modules)
{
GList *result = g_list_find_custom (modules, item->op, _g_list_find_module_by_name); // (dt_iop_module_t *)(modules->data);
if( result )
{
module = (dt_iop_module_t *)(result->data);
enabled = (module->flags() & IOP_FLAGS_INCLUDE_IN_STYLES)?TRUE:FALSE;
}
}
gchar name[256]= {0};
g_snprintf(name,256,"%s",item->name);
gtk_list_store_append (GTK_LIST_STORE(liststore), &iter);
gtk_list_store_set (GTK_LIST_STORE(liststore), &iter,
DT_STYLE_ITEMS_COL_ENABLED, enabled,
DT_STYLE_ITEMS_COL_NAME, name,
DT_STYLE_ITEMS_COL_NUM, (guint)item->num,
-1);
g_free(item->op);
g_free(item->name);
g_free(item);
}
while ((items=g_list_next(items)));
}
else
{
dt_control_log(_("can't create style out of unaltered image"));
return;
}
}
g_object_unref (liststore);
/* run dialog */
if (edit)
g_signal_connect (dialog, "response", G_CALLBACK (_gui_styles_edit_style_response), sd);
else
g_signal_connect (dialog, "response", G_CALLBACK (_gui_styles_new_style_response), sd);
gtk_widget_show_all (GTK_WIDGET (dialog));
gtk_dialog_run(GTK_DIALOG(dialog));
}
GtkCellRendererToggle* cast_GtkCellRendererToggle(GtkCellRenderer* cell_renderer) {
return GTK_CELL_RENDERER_TOGGLE(cell_renderer);
}
static void
gimp_cell_renderer_toggle_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell);
GdkRectangle toggle_rect;
GdkRectangle draw_rect;
GtkStyleContext *context = gtk_widget_get_style_context (widget);
GdkRectangle clip_rect;
GtkStateFlags state;
gboolean active;
gint xpad;
gint ypad;
if (! toggle->stock_id)
{
GTK_CELL_RENDERER_CLASS (parent_class)->render (cell,
cr,
widget,
background_area,
cell_area,
flags);
return;
}
gtk_cell_renderer_get_size (cell, widget, cell_area,
&toggle_rect.x,
&toggle_rect.y,
&toggle_rect.width,
&toggle_rect.height);
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
toggle_rect.x += cell_area->x + xpad;
toggle_rect.y += cell_area->y + ypad;
toggle_rect.width -= xpad * 2;
toggle_rect.height -= ypad * 2;
if (toggle_rect.width <= 0 || toggle_rect.height <= 0)
return;
active =
gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell));
if (!gtk_cell_renderer_get_sensitive (cell))
{
state = GTK_STATE_FLAG_INSENSITIVE;
}
else if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
{
if (gtk_widget_has_focus (widget))
state = GTK_STATE_FLAG_SELECTED;
else
state = GTK_STATE_FLAG_ACTIVE;
}
else
{
if (gtk_cell_renderer_toggle_get_activatable (GTK_CELL_RENDERER_TOGGLE (cell)))
state = GTK_STATE_FLAG_NORMAL;
else
state = GTK_STATE_FLAG_INSENSITIVE;
}
if ((flags & GTK_CELL_RENDERER_PRELIT) &&
gdk_cairo_get_clip_rectangle(cr, &clip_rect) &&
gdk_rectangle_intersect (&clip_rect, cell_area, &draw_rect))
{
cairo_save (cr);
gdk_cairo_rectangle (cr, &draw_rect);
cairo_clip (cr);
gtk_render_frame (context, //gtk_widget_get_style_context (widget),
cr,
toggle_rect.x, toggle_rect.y,
toggle_rect.width, toggle_rect.height);
gtk_style_context_restore (context);
cairo_restore (cr);
}
if (active)
{
GdkPixbuf *insensitive = NULL;
GdkPixbuf *pixbuf = toggle->pixbuf;
GtkBorder border = { 1, 1, 1, 1 };
#if 0
/* FIXME: for some reason calling gtk_style_context_get_border
* makes the icon only visible on hover, so use border = 1
* for now as a workaround
*/
gtk_style_context_get_border (context, state, &border);
#endif
toggle_rect.x += border.left;
toggle_rect.y += border.top;
toggle_rect.width -= (border.left + border.right);
toggle_rect.height -= (border.top + border.bottom);
if (state & GTK_STATE_FLAG_INSENSITIVE)
{
GtkIconSource *source;
source = gtk_icon_source_new ();
gtk_icon_source_set_pixbuf (source, pixbuf);
/* The size here is arbitrary; since size isn't
* wildcarded in the source, it isn't supposed to be
* scaled by the engine function
*/
gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_icon_source_set_size_wildcarded (source, FALSE);
gtk_style_context_save (context);
gtk_style_context_set_state (context, GTK_STATE_FLAG_INSENSITIVE);
insensitive = gtk_render_icon_pixbuf (context, source, (GtkIconSize)-1);
gtk_style_context_restore (context);
gtk_icon_source_free (source);
pixbuf = insensitive;
}
if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect))
{
gdk_cairo_set_source_pixbuf (cr, pixbuf, toggle_rect.x, toggle_rect.y);
gdk_cairo_rectangle (cr, &draw_rect);
cairo_fill (cr);
}
if (insensitive)
g_object_unref (insensitive);
}
}
static void
auth_methods_setup (GtkBuilder *builder, GHashTable *hash)
{
GtkWidget *widget;
GtkListStore *store;
GtkTreeIter iter;
const char *value;
gboolean allowed;
gboolean use_mppe = FALSE;
GtkCellRendererToggle *check_renderer;
GtkCellRenderer *text_renderer;
GtkTreeViewColumn *column;
gint offset;
gboolean mschap_state = TRUE;
gboolean mschap2_state = TRUE;
store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_UINT, G_TYPE_BOOLEAN);
/* Check for MPPE */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REQUIRE_MPPE);
if (value && !strcmp (value, "yes"))
use_mppe = TRUE;
/* Or MPPE-128 */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REQUIRE_MPPE_128);
if (value && !strcmp (value, "yes"))
use_mppe = TRUE;
/* Or MPPE-40 */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REQUIRE_MPPE_40);
if (value && !strcmp (value, "yes"))
use_mppe = TRUE;
/* PAP */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_PAP);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
if (use_mppe)
allowed = FALSE;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("PAP"),
COL_VALUE, allowed,
COL_TAG, TAG_PAP,
COL_SENSITIVE, !use_mppe,
-1);
/* CHAP */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_CHAP);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
if (use_mppe)
allowed = FALSE;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("CHAP"),
COL_VALUE, allowed,
COL_TAG, TAG_CHAP,
COL_SENSITIVE, !use_mppe,
-1);
/* MSCHAP */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_MSCHAP);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
mschap_state = allowed;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("MSCHAP"),
COL_VALUE, allowed,
COL_TAG, TAG_MSCHAP,
COL_SENSITIVE, TRUE,
-1);
/* MSCHAPv2 */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_MSCHAPV2);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
mschap2_state = allowed;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("MSCHAPv2"),
COL_VALUE, allowed,
COL_TAG, TAG_MSCHAPV2,
COL_SENSITIVE, TRUE,
-1);
/* EAP */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_EAP);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
if (use_mppe)
allowed = FALSE;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("EAP"),
COL_VALUE, allowed,
COL_TAG, TAG_EAP,
COL_SENSITIVE, !use_mppe,
-1);
/* Set up the tree view */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ppp_auth_methods"));
gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (store));
check_renderer = GTK_CELL_RENDERER_TOGGLE (gtk_cell_renderer_toggle_new ());
g_signal_connect (check_renderer, "toggled", G_CALLBACK (check_toggled_cb), builder);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, "", GTK_CELL_RENDERER (check_renderer),
"active", COL_VALUE,
"sensitive", COL_SENSITIVE,
"activatable", COL_SENSITIVE,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 30);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
text_renderer = gtk_cell_renderer_text_new ();
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, "", text_renderer,
"text", COL_NAME,
"sensitive", COL_SENSITIVE,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Make sure MPPE is non-sensitive if MSCHAP and MSCHAPv2 are disabled */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ppp_use_mppe"));
if (!mschap_state && !mschap2_state) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_set_sensitive (widget, FALSE);
} else
gtk_widget_set_sensitive (widget, TRUE);
}
static GtkWidget *
create_alert_treeview (GvcSoundThemeChooser *chooser)
{
GtkListStore *store;
GtkWidget *treeview;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
treeview = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
g_signal_connect (G_OBJECT (treeview),
"row-activated",
G_CALLBACK (on_treeview_row_activated),
chooser);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (selection),
"changed",
G_CALLBACK (on_treeview_selection_changed),
chooser);
/* Setup the tree model, 3 columns:
* - display name
* - sound id
* - sound type
*/
store = gtk_list_store_new (ALERT_NUM_COLS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
gtk_list_store_insert_with_values (store,
NULL,
G_MAXINT,
ALERT_IDENTIFIER_COL, DEFAULT_ALERT_ID,
ALERT_DISPLAY_COL, _("Default"),
ALERT_SOUND_TYPE_COL, _("From theme"),
ALERT_ACTIVE_COL, TRUE,
-1);
populate_model_from_dir (chooser, GTK_TREE_MODEL (store), SOUND_SET_DIR);
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview),
GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_toggle_new ();
gtk_cell_renderer_toggle_set_radio (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE);
column = gtk_tree_view_column_new_with_attributes (NULL,
renderer,
"active", ALERT_ACTIVE_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
g_signal_connect (renderer,
"toggled",
G_CALLBACK (on_alert_toggled),
chooser);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Name"),
renderer,
"text", ALERT_DISPLAY_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Type"),
renderer,
"text", ALERT_SOUND_TYPE_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
return treeview;
}
static void
setup_profile_pages (GtrPreferencesDialog *dlg)
{
GtkTreeViewColumn *name_column, *toggle_column;
GtkCellRenderer *text_renderer, *toggle_renderer;
GtkListStore *model;
model = gtk_list_store_new (PROFILE_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (dlg->priv->profile_treeview),
GTK_TREE_MODEL (model));
g_object_unref (model);
text_renderer = gtk_cell_renderer_text_new ();
toggle_renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (toggle_renderer,
"toggled", G_CALLBACK (active_toggled_cb), dlg);
gtk_cell_renderer_toggle_set_activatable (GTK_CELL_RENDERER_TOGGLE (toggle_renderer),
TRUE);
gtk_cell_renderer_toggle_set_radio (GTK_CELL_RENDERER_TOGGLE (toggle_renderer),
TRUE);
name_column = gtk_tree_view_column_new_with_attributes (_("Profile"),
text_renderer,
"text",
PROFILE_NAME_COLUMN,
NULL);
toggle_column = gtk_tree_view_column_new_with_attributes (_("Active"),
toggle_renderer,
"active",
ACTIVE_PROFILE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (toggle_column, TRUE);
gtk_tree_view_column_set_resizable (name_column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->profile_treeview),
name_column);
gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->profile_treeview),
toggle_column);
gtk_tree_view_column_set_expand (name_column, TRUE);
fill_profile_treeview (dlg, GTK_TREE_MODEL (model));
/* Connect the signals */
g_signal_connect (dlg->priv->add_button,
"clicked", G_CALLBACK (add_button_clicked), dlg);
g_signal_connect (dlg->priv->delete_button,
"clicked", G_CALLBACK (delete_button_clicked), dlg);
g_signal_connect (dlg->priv->edit_button,
"clicked", G_CALLBACK (edit_button_clicked), dlg);
}
static void
load_chain (PatrolDialogWindow *self, PatrolDialogRecord *r,
guint idx, GtkWidget *container)
{
/* build tree model */
GtkTreeStore *tree_store = gtk_tree_store_new(COLS_NUM, G_TYPE_STRING,
G_TYPE_BOOLEAN, G_TYPE_INT,
G_TYPE_POINTER, G_TYPE_POINTER);
GtkTreeIter *parent = NULL, iter;
gint i, num_certs = gcr_certificate_chain_get_length(r->chain);
GcrCertificate *cert = NULL;
for (i = num_certs - 1; i >= 0; i--) {
cert = gcr_certificate_chain_get_certificate(r->chain, i);
gchar *label = gcr_certificate_get_subject_name(cert);
gtk_tree_store_append(tree_store, &iter, parent);
gtk_tree_store_set(tree_store, &iter,
COL_NAME, label,
COL_PIN, i == r->pin_level,
COL_PIN_LEVEL, i,
COL_CERT, cert,
COL_REC, r,
-1);
parent = &iter;
g_free(label);
}
/* set hierarchy title */
GtkWidget *title_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(container), title_box, FALSE, FALSE, 0);
gchar *text, *str;
GtkWidget *label = gtk_label_new(NULL);
GtkWidget *value;
if (idx == 0) {
switch (self->pv->result) {
case PATROL_VERIFY_NEW:
case PATROL_VERIFY_CHANGE:
text = g_strdup_printf("<b>%s</b>", _("New Certificate"));
break;
case PATROL_VERIFY_REJECT:
text = g_strdup_printf("<b>%s</b>", _("Rejected Certificate"));
break;
default:
text = g_strdup_printf("<b>%s</b>", _("Selected Certificate"));
break;
}
} else {
text = g_strdup_printf("<b>%s #%d</b>", _("Stored Certificate"), idx);
gtk_widget_set_margin_bottom(GTK_WIDGET(label), 2);
}
gtk_label_set_markup(GTK_LABEL(label), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(title_box), label, FALSE, FALSE, 0);
GtkWidget *grid = gtk_grid_new();
gtk_widget_set_margin_left(GTK_WIDGET(grid), 5);
gtk_box_pack_start(GTK_BOX(title_box), grid, FALSE, FALSE, 0);
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), _("Seen: "));
str = g_strdup_printf("%" G_GINT64_FORMAT, r->rec.count_seen);
text = g_strdup_printf(g_dngettext(textdomain(NULL),
"%s time", "%s times",
r->rec.count_seen), str);
g_free(str);
value = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(value), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(value), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), value, 1, 0, 1, 1);
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), _("First seen: "));
GDateTime *dtime = g_date_time_new_from_unix_local(r->rec.first_seen);
text = g_date_time_format(dtime, "%c");
g_date_time_unref(dtime);
value = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(value), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(value), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid), value, 1, 1, 1, 1);
if (r->rec.first_seen != r->rec.last_seen) {
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), _("Last seen: "));
dtime = g_date_time_new_from_unix_local(r->rec.last_seen);
text = g_date_time_format(dtime, "%c");
g_date_time_unref(dtime);
value = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(value), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(value), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(grid), value, 1, 2, 1, 1);
}
if (cert) {
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), _("Validity: "));
GDate *expiry = gcr_certificate_get_expiry_date(cert);
GDate *now = g_date_new();
g_date_set_time_t(now, time(NULL));
gint diff = g_date_days_between(now, expiry);
g_date_free(now);
g_date_free(expiry);
if (diff > 0) {
text = g_strdup_printf(g_dngettext(textdomain(NULL),
"Certificate is valid for %d more day",
"Certificate is valid for %d more days",
diff), diff);
} else if (diff < 0) {
diff = abs(diff);
text = g_strdup_printf(g_dngettext(textdomain(NULL),
"Certificate <b>expired</b> %d day ago",
"Certificate <b>expired</b> %d days ago",
diff), diff);
} else {
text = g_strdup_printf("Certificate expires today");
}
value = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(value), text);
g_free(text);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(value), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(grid), value, 1, 3, 1, 1);
}
gtk_widget_show_all(title_box);
/* build tree view */
GtkWidget *tree_view;
tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_store));
gtk_tree_view_expand_all(GTK_TREE_VIEW(tree_view));
gtk_box_pack_start(GTK_BOX(container), tree_view, FALSE, FALSE, 0);
gtk_widget_show(tree_view);
g_signal_connect(tree_view, "focus-in-event",
G_CALLBACK(on_tree_view_focus), self);
g_signal_connect(self->pv->renderer, "data-changed",
G_CALLBACK(on_cert_changed), tree_view);
GtkTreeSelection *tree_sel
= gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
g_signal_connect(tree_sel, "changed",
G_CALLBACK(on_tree_selection_changed), self);
if (idx == 0) // new chain
gtk_tree_selection_select_iter(tree_sel, &iter);
/* first column */
GtkCellRenderer *tree_renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn *tree_column
= gtk_tree_view_column_new_with_attributes(_("Certificate Hierarchy"),
tree_renderer, "text",
COL_NAME, NULL);
gtk_tree_view_column_set_expand (tree_column, TRUE);
gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), tree_column, -1);
/* second column */
GtkCellRenderer *toggle_renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(toggle_renderer, "toggled",
G_CALLBACK(on_radio_toggled), tree_store);
gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(toggle_renderer),
TRUE);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree_view), -1,
_("Pin"), toggle_renderer,
"active", COL_PIN, NULL);
g_object_unref(tree_store);
}
static void
gimp_cell_renderer_toggle_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
GtkCellRendererState flags)
{
GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell);
GtkStyle *style = gtk_widget_get_style (widget);
GdkRectangle toggle_rect;
GdkRectangle draw_rect;
GtkStateType state;
gboolean active;
gint xpad;
gint ypad;
if (! toggle->stock_id)
{
GTK_CELL_RENDERER_CLASS (parent_class)->render (cell, window, widget,
background_area,
cell_area, expose_area,
flags);
return;
}
gimp_cell_renderer_toggle_get_size (cell, widget, cell_area,
&toggle_rect.x,
&toggle_rect.y,
&toggle_rect.width,
&toggle_rect.height);
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
toggle_rect.x += cell_area->x + xpad;
toggle_rect.y += cell_area->y + ypad;
toggle_rect.width -= xpad * 2;
toggle_rect.height -= ypad * 2;
if (toggle_rect.width <= 0 || toggle_rect.height <= 0)
return;
active =
gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell));
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
{
if (gtk_widget_has_focus (widget))
state = GTK_STATE_SELECTED;
else
state = GTK_STATE_ACTIVE;
}
else
{
if (gtk_cell_renderer_toggle_get_activatable (GTK_CELL_RENDERER_TOGGLE (cell)))
state = GTK_STATE_NORMAL;
else
state = GTK_STATE_INSENSITIVE;
}
if (gdk_rectangle_intersect (expose_area, cell_area, &draw_rect) &&
(flags & GTK_CELL_RENDERER_PRELIT))
gtk_paint_shadow (style,
window,
state,
active ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
&draw_rect,
widget, NULL,
toggle_rect.x, toggle_rect.y,
toggle_rect.width, toggle_rect.height);
if (active)
{
toggle_rect.x += style->xthickness;
toggle_rect.y += style->ythickness;
toggle_rect.width -= style->xthickness * 2;
toggle_rect.height -= style->ythickness * 2;
if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect))
{
cairo_t *cr = gdk_cairo_create (window);
gboolean inconsistent;
gdk_cairo_rectangle (cr, &draw_rect);
cairo_clip (cr);
gdk_cairo_set_source_pixbuf (cr, toggle->pixbuf,
toggle_rect.x, toggle_rect.y);
cairo_paint (cr);
g_object_get (toggle,
"inconsistent", &inconsistent,
NULL);
if (inconsistent)
{
gdk_cairo_set_source_color (cr, &style->fg[state]);
cairo_set_line_width (cr, 1.5);
cairo_move_to (cr,
toggle_rect.x + toggle_rect.width - 1,
toggle_rect.y + 1);
cairo_line_to (cr,
toggle_rect.x + 1,
toggle_rect.y + toggle_rect.height - 1);
cairo_stroke (cr);
}
cairo_destroy (cr);
}
}
}
