GtkWidget *
hitori_create_interface (Hitori *hitori)
{
GtkBuilder *builder;
GtkStyleContext *style_context;
GtkCssProvider *css_provider;
const PangoFontDescription *font;
GAction *action;
builder = gtk_builder_new_from_resource ("/org/gnome/Hitori/ui/hitori.ui");
gtk_builder_set_translation_domain (builder, PACKAGE);
gtk_builder_connect_signals (builder, hitori);
/* Setup the main window */
hitori->window = GTK_WIDGET (gtk_builder_get_object (builder, "hitori_main_window"));
hitori->drawing_area = GTK_WIDGET (gtk_builder_get_object (builder, "hitori_drawing_area"));
hitori->timer_label = GTK_LABEL (gtk_builder_get_object (builder, "hitori_timer"));
g_object_unref (builder);
/* Set up actions */
g_action_map_add_action_entries (G_ACTION_MAP (hitori), app_entries, G_N_ELEMENTS (app_entries), hitori);
g_action_map_add_action_entries (G_ACTION_MAP (hitori->window), win_entries, G_N_ELEMENTS (win_entries), hitori);
action = g_settings_create_action (hitori->settings, "board-size");
g_action_map_add_action (G_ACTION_MAP (hitori), action);
g_signal_connect (G_OBJECT (action), "notify::state", (GCallback) board_size_change_cb, hitori);
g_object_unref (action);
hitori->undo_action = G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (hitori->window), "undo"));
hitori->redo_action = G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (hitori->window), "redo"));
hitori->hint_action = G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (hitori->window), "hint"));
/* Set up font descriptions for the drawing area */
style_context = gtk_widget_get_style_context (hitori->drawing_area);
gtk_style_context_get (style_context,
gtk_style_context_get_state (style_context),
GTK_STYLE_PROPERTY_FONT, &font, NULL);
hitori->normal_font_desc = pango_font_description_copy (font);
hitori->painted_font_desc = pango_font_description_copy (font);
/* Load CSS for the drawing area */
css_provider = gtk_css_provider_new ();
gtk_css_provider_load_from_resource (css_provider, "/org/gnome/Hitori/ui/hitori.css");
gtk_style_context_add_provider (style_context, GTK_STYLE_PROVIDER (css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (css_provider);
/* Reset the timer */
hitori_reset_timer (hitori);
/* Disable undo/redo until a cell has been clicked. */
g_simple_action_set_enabled (hitori->undo_action, FALSE);
g_simple_action_set_enabled (hitori->redo_action, FALSE);
return hitori->window;
}
static GtkBuilder *
builder_get_file_valist (const gchar *filename,
const gchar *first_object,
va_list args)
{
GtkBuilder *gui;
const gchar *name;
GObject **object_ptr;
GError *error = NULL;
DEBUG ("Loading file %s", filename);
gui = gtk_builder_new ();
gtk_builder_set_translation_domain (gui, GETTEXT_PACKAGE);
if (!gtk_builder_add_from_file (gui, filename, &error)) {
g_critical ("GtkBuilder Error (%s): %s",
filename, error->message);
g_clear_error (&error);
g_object_unref (gui);
/* we need to iterate and set all of the pointers to NULL */
for (name = first_object; name;
name = va_arg (args, const gchar *)) {
object_ptr = va_arg (args, GObject**);
*object_ptr = NULL;
}
return NULL;
}
GtkWidget*
eog_save_as_dialog_new (GtkWindow *main, GList *images, GFile *base_file)
{
GtkBuilder *xml;
GtkWidget *dlg;
SaveAsData *data;
GtkWidget *label;
xml = gtk_builder_new_from_resource ("/org/gnome/eog/ui/eog-multiple-save-as-dialog.ui");
gtk_builder_set_translation_domain (xml, GETTEXT_PACKAGE);
dlg = GTK_WIDGET (g_object_ref (gtk_builder_get_object (xml, "eog_multiple_save_as_dialog")));
gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (main));
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER_ON_PARENT);
data = g_slice_new0 (SaveAsData);
/* init widget references */
data->dir_chooser = GTK_WIDGET (gtk_builder_get_object (xml,
"dir_chooser"));
data->token_entry = GTK_WIDGET (gtk_builder_get_object (xml,
"token_entry"));
data->replace_spaces_check = GTK_WIDGET (gtk_builder_get_object (xml,
"replace_spaces_check"));
data->counter_spin = GTK_WIDGET (gtk_builder_get_object (xml,
"counter_spin"));
data->preview_label = GTK_WIDGET (gtk_builder_get_object (xml,
"preview_label"));
data->format_combobox = GTK_WIDGET (gtk_builder_get_object (xml,
"format_combobox"));
/* init preview information */
data->idle_id = 0;
data->n_images = g_list_length (images);
data->nth_image = (int) ((float) data->n_images * rand() / (float) (RAND_MAX+1.0));
g_assert (data->nth_image >= 0 && data->nth_image < data->n_images);
data->image = g_object_ref (EOG_IMAGE (g_list_nth_data (images, data->nth_image)));
g_object_set_data_full (G_OBJECT (dlg), "data", data, destroy_data_cb);
g_signal_connect (G_OBJECT (data->format_combobox), "changed",
(GCallback) on_format_combobox_changed, dlg);
g_signal_connect (G_OBJECT (data->token_entry), "changed",
(GCallback) on_token_entry_changed, dlg);
g_signal_connect (G_OBJECT (data->replace_spaces_check), "toggled",
(GCallback) on_replace_spaces_check_clicked, dlg);
g_signal_connect (G_OBJECT (data->counter_spin), "changed",
(GCallback) on_counter_spin_changed, dlg);
label = GTK_WIDGET (gtk_builder_get_object (xml, "preview_label_from"));
gtk_label_set_text (GTK_LABEL (label), eog_image_get_caption (data->image));
prepare_format_combobox (data);
set_default_values (dlg, base_file);
g_object_unref (xml);
return dlg;
}
static void
cc_region_panel_init (CcRegionPanel * self)
{
CcRegionPanelPrivate *priv;
GtkWidget *prefs_widget;
const char *desktop;
GError *error = NULL;
priv = self->priv = REGION_PANEL_PRIVATE (self);
desktop = g_getenv ("XDG_CURRENT_DESKTOP");
priv->builder = gtk_builder_new ();
gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE);
gtk_builder_add_from_file (priv->builder,
SAGARMATHACC_UI_DIR "/sagarmatha-region-panel.ui",
&error);
if (error != NULL) {
g_warning ("Error loading UI file: %s", error->message);
g_error_free (error);
return;
}
prefs_widget = (GtkWidget *) gtk_builder_get_object (priv->builder, "vbox1");
gtk_widget_set_size_request (GTK_WIDGET (prefs_widget), -1, 400);
gtk_widget_reparent (prefs_widget, GTK_WIDGET (self));
setup_xkb_tabs (priv->builder);
}
static void
parse_interface (ParserData *data,
const gchar *element_name,
const gchar **names,
const gchar **values,
GError **error)
{
const gchar *domain = NULL;
if (!g_markup_collect_attributes (element_name, names, values, error,
G_MARKUP_COLLECT_STRING|G_MARKUP_COLLECT_OPTIONAL, "domain", &domain,
G_MARKUP_COLLECT_INVALID))
{
_gtk_builder_prefix_error (data->builder, data->ctx, error);
return;
}
if (domain)
{
if (data->domain && strcmp (data->domain, domain) != 0)
{
g_warning ("%s: interface domain '%s' overrides programmatic value '%s'",
data->filename, domain, data->domain);
g_free (data->domain);
}
data->domain = g_strdup (domain);
gtk_builder_set_translation_domain (data->builder, data->domain);
}
}
/**
* rb_builder_load:
* @file: filename, either absolute or relative to the data directory
* @user_data: user data to pass to autoconnected signal handlers
*
* Locates and reads a GtkBuilder file, automatically connecting
* signal handlers where possible. The caller can specify a path
* relative to the shared data directory, or its 'ui' or 'art'
* subdirectories.
*
* Return value: #GtkBuilder object built from the file
*/
GtkBuilder *
rb_builder_load (const char *file, gpointer user_data)
{
GtkBuilder *builder;
const char *name;
GError *error = NULL;
g_return_val_if_fail (file != NULL, NULL);
/* if the first character is /, it's an absolute path, otherwise locate it */
if (file[0] == G_DIR_SEPARATOR)
name = file;
else
name = rb_file (file);
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
if (gtk_builder_add_from_file (builder, name, &error) == 0) {
g_warning ("Error loading GtkBuilder file %s: %s", name, error->message);
g_error_free (error);
}
gtk_builder_connect_signals (builder, user_data);
return builder;
}
static void display_properties_dialog(GtkAction* action, TasklistData* tasklist)
{
if (tasklist->properties_dialog == NULL)
{
GtkBuilder* builder;
GError* error;
builder = gtk_builder_new();
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
error = NULL;
gtk_builder_add_from_file(builder, TASKLIST_BUILDERDIR "/window-list.ui", &error);
if (error)
{
g_warning("Error loading preferences: %s", error->message);
g_error_free(error);
return;
}
tasklist->properties_dialog = WID("tasklist_properties_dialog");
g_object_add_weak_pointer(G_OBJECT(tasklist->properties_dialog), (void**) &tasklist->properties_dialog);
setup_dialog(builder, tasklist);
g_object_unref(builder);
}
gtk_window_set_icon_name(GTK_WINDOW(tasklist->properties_dialog), WINDOW_LIST_ICON);
gtk_window_set_resizable(GTK_WINDOW(tasklist->properties_dialog), FALSE);
gtk_window_set_screen(GTK_WINDOW(tasklist->properties_dialog), gtk_widget_get_screen(tasklist->applet));
gtk_window_present(GTK_WINDOW(tasklist->properties_dialog));
}
static void display_properties_dialog(GtkAction* action, PagerData* pager)
{
if (pager->properties_dialog == NULL)
{
GtkBuilder* builder;
GError* error;
builder = gtk_builder_new();
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
error = NULL;
gtk_builder_add_from_file(builder, PAGER_BUILDERDIR "/workspace-switcher.ui", &error);
if (error)
{
g_warning("Error loading preferences: %s", error->message);
g_error_free(error);
return;
}
pager->properties_dialog = WID("pager_properties_dialog");
g_object_add_weak_pointer(G_OBJECT(pager->properties_dialog), (gpointer*) &pager->properties_dialog);
setup_dialog(builder, pager);
g_object_unref(builder);
}
gtk_window_set_icon_name(GTK_WINDOW(pager->properties_dialog), WORKSPACE_SWITCHER_ICON);
gtk_window_set_screen(GTK_WINDOW(pager->properties_dialog), gtk_widget_get_screen(pager->applet));
gtk_window_present(GTK_WINDOW(pager->properties_dialog));
}
GtkBuilder *
lmplayer_interface_load_with_full_path (const char *filename, gboolean fatal,
GtkWindow *parent, gpointer user_data)
{
GtkBuilder *builder = NULL;
GError *error = NULL;
if (filename != NULL) {
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
}
if (builder == NULL || gtk_builder_add_from_file (builder, filename, &error) == FALSE) {
char *msg;
msg = g_strdup_printf (_("Couldn't load the '%s' interface. %s"), filename, error->message);
if (fatal == FALSE)
lmplayer_interface_error (msg, _("Make sure that Lmplayer is properly installed."), parent);
else
lmplayer_interface_error_blocking (msg, _("Make sure that Lmplayer is properly installed."), parent);
g_free (msg);
g_error_free (error);
return NULL;
}
gtk_builder_connect_signals (builder, user_data);
return builder;
}
static void
display_properties_dialog (GtkAction *action,
PagerData *pager)
{
if (pager->properties_dialog == NULL) {
GtkBuilder *builder;
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
gtk_builder_add_from_resource (builder, WNCKLET_RESOURCE_PATH "workspace-switcher.ui", NULL);
pager->properties_dialog = WID ("pager_properties_dialog");
g_object_add_weak_pointer (G_OBJECT (pager->properties_dialog),
(gpointer *) &pager->properties_dialog);
setup_dialog (builder, pager);
g_object_unref (builder);
}
gtk_window_set_icon_name (GTK_WINDOW (pager->properties_dialog),
WORKSPACE_SWITCHER_ICON);
gtk_window_set_screen (GTK_WINDOW (pager->properties_dialog),
gtk_widget_get_screen (pager->applet));
gtk_window_present (GTK_WINDOW (pager->properties_dialog));
}
static void
parse_interface (ParserData *data,
const gchar *element_name,
const gchar **names,
const gchar **values,
GError **error)
{
int i;
for (i = 0; names[i] != NULL; i++)
{
if (strcmp (names[i], "domain") == 0)
{
if (data->domain)
{
if (strcmp (data->domain, values[i]) == 0)
continue;
else
g_warning ("%s: interface domain '%s' overrides "
"programically set domain '%s'",
data->filename,
values[i],
data->domain
);
g_free (data->domain);
}
data->domain = g_strdup (values[i]);
gtk_builder_set_translation_domain (data->builder, data->domain);
}
else
error_invalid_attribute (data, "interface", names[i], error);
}
}
/**
* swfdec_window_new:
* @uri: a valid UTF-8 encoded URI.
*
* Opens a new window. If a URI was specified, it will be shown. Otherwise the
* window will appear empty.
*
* Returns: The window that was just openend. You don't own a reference to it.
**/
SwfdecWindow *
swfdec_window_new (const char *url)
{
GError *error = NULL;
SwfdecWindow *window;
window = g_object_new (SWFDEC_TYPE_WINDOW, NULL);
window->builder = gtk_builder_new ();
gtk_builder_set_translation_domain (window->builder, GETTEXT_PACKAGE);
if (!gtk_builder_add_from_file (window->builder, BUILDER_FILE, &error)) {
swfdec_window_error (window, error->message);
return window;
}
gtk_builder_connect_signals (window->builder, window);
swfdec_window_add_recent_filter (GTK_RECENT_CHOOSER (
gtk_builder_get_object (window->builder, "recent")));
window->window = GTK_WIDGET (gtk_builder_get_object (window->builder, "player-window"));
if (window->window == NULL) {
swfdec_window_error (window, _("Broken user interface definition file"));
return window;
}
g_object_weak_ref (G_OBJECT (window->window), (GWeakNotify) g_object_unref, window);
if (url != NULL) {
swfdec_window_set_url (window, url);
}
swfdec_window_set_settings (window, &window->settings);
return window;
}
Splash *oregano_splash_new (GError **error)
{
GtkBuilder *gui;
Splash *sp;
GtkEventBox *event;
if ((gui = gtk_builder_new ()) == NULL) {
g_set_error_literal (error, OREGANO_ERROR, OREGANO_UI_ERROR_NO_BUILDER,
_ ("Failed to spawn builder"));
return NULL;
}
gtk_builder_set_translation_domain (gui, NULL);
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/splash.ui", error) <= 0) {
return NULL;
}
sp = g_new0 (Splash, 1);
sp->can_destroy = FALSE;
sp->win = GTK_WINDOW (gtk_builder_get_object (gui, "splash"));
sp->lbl = GTK_LABEL (gtk_builder_get_object (gui, "label"));
sp->progress = GTK_WIDGET (gtk_builder_get_object (gui, "pbar"));
event = GTK_EVENT_BOX (gtk_builder_get_object (gui, "event"));
sp->event = GTK_WIDGET (event);
gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (sp->progress), 0.07);
gtk_widget_show_all (GTK_WIDGET (sp->win));
while (gtk_events_pending ())
gtk_main_iteration ();
return sp;
}
void
gtkhtml_editor_private_init (GtkhtmlEditor *editor)
{
GtkhtmlEditorPrivate *priv = editor->priv;
gchar *filename;
GError *error = NULL;
priv->manager = gtk_ui_manager_new ();
priv->core_actions = gtk_action_group_new ("core");
priv->html_actions = gtk_action_group_new ("html");
priv->context_actions = gtk_action_group_new ("core-context");
priv->html_context_actions = gtk_action_group_new ("html-context");
priv->language_actions = gtk_action_group_new ("language");
priv->spell_check_actions = gtk_action_group_new ("spell-check");
priv->suggestion_actions = gtk_action_group_new ("suggestion");
/* GtkhtmlSpellLanguage -> GtkhtmlSpellChecker */
priv->available_spell_checkers = g_hash_table_new_full (
g_direct_hash, g_direct_equal,
(GDestroyNotify) NULL,
(GDestroyNotify) g_object_unref);
/* GtkhtmlSpellLanguage -> UI Merge ID */
priv->spell_suggestion_menus =
g_hash_table_new (g_direct_hash, g_direct_equal);
filename = gtkhtml_editor_find_data_file ("gtkhtml-editor-manager.ui");
if (!gtk_ui_manager_add_ui_from_file (priv->manager, filename, &error)) {
g_critical ("Couldn't load builder file: %s\n", error->message);
g_clear_error (&error);
}
g_free (filename);
filename = gtkhtml_editor_find_data_file ("gtkhtml-editor-builder.ui");
priv->builder = gtk_builder_new ();
/* To keep translated strings in subclasses */
gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE);
if (!gtk_builder_add_from_file (priv->builder, filename, &error)) {
g_critical ("Couldn't load builder file: %s\n", error->message);
g_clear_error (&error);
}
g_free (filename);
gtkhtml_editor_actions_init (editor);
gtk_window_add_accel_group (
GTK_WINDOW (editor),
gtk_ui_manager_get_accel_group (priv->manager));
gtk_builder_connect_signals (priv->builder, NULL);
/* Wait to construct the main window widgets
* until the 'html' property is initialized. */
}
NMVpnEditor *
nm_vpnc_editor_new (NMConnection *connection, GError **error)
{
NMVpnEditor *object;
VpncEditorPrivate *priv;
char *ui_file;
NMSettingVpn *s_vpn;
gboolean is_new = TRUE;
if (error)
g_return_val_if_fail (*error == NULL, NULL);
object = g_object_new (VPNC_TYPE_EDITOR, NULL);
if (!object) {
g_set_error (error, NMV_EDITOR_PLUGIN_ERROR, NMV_EDITOR_PLUGIN_ERROR_FAILED,
"could not create vpnc object");
return NULL;
}
priv = VPNC_EDITOR_GET_PRIVATE (object);
ui_file = g_strdup_printf ("%s/%s", UIDIR, "nm-vpnc-dialog.ui");
priv->builder = gtk_builder_new ();
gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE);
if (!gtk_builder_add_from_file (priv->builder, ui_file, error)) {
g_warning ("Couldn't load builder file: %s",
error && *error ? (*error)->message : "(unknown)");
g_clear_error (error);
g_set_error (error, NMV_EDITOR_PLUGIN_ERROR, NMV_EDITOR_PLUGIN_ERROR_FAILED,
"could not load required resources at %s", ui_file);
g_free (ui_file);
g_object_unref (object);
return NULL;
}
g_free (ui_file);
priv->widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "vpnc-vbox"));
if (!priv->widget) {
g_set_error (error, NMV_EDITOR_PLUGIN_ERROR, NMV_EDITOR_PLUGIN_ERROR_FAILED,
"could not load UI widget");
g_object_unref (object);
return NULL;
}
g_object_ref_sink (priv->widget);
s_vpn = nm_connection_get_setting_vpn (connection);
if (s_vpn)
nm_setting_vpn_foreach_data_item (s_vpn, is_new_func, &is_new);
if (!init_plugin_ui (VPNC_EDITOR (object), connection, is_new, error)) {
g_object_unref (object);
return NULL;
}
return object;
}
void simulation_show (GtkWidget *widget, SchematicView *sv)
{
GtkWidget *w;
GtkBuilder *gui;
GError *e = NULL;
Simulation *s;
Schematic *sm;
g_return_if_fail (sv != NULL);
sm = schematic_view_get_schematic (sv);
s = schematic_get_simulation (sm);
if ((gui = gtk_builder_new ()) == NULL) {
log_append (s->logstore, _ ("Simulation"),
_ ("Could not create simulation dialog - Builder creation failed."));
return;
}
gtk_builder_set_translation_domain (gui, NULL);
// Only allow one instance of the dialog box per schematic.
if (s->dialog) {
gdk_window_raise (gtk_widget_get_window (GTK_WIDGET (s->dialog)));
return;
}
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/simulation.ui", &e) <= 0) {
log_append_error (s->logstore, _ ("Simulation"), _ ("Could not create simulation dialog"),
e);
g_clear_error (&e);
return;
}
w = GTK_WIDGET (gtk_builder_get_object (gui, "toplevel"));
if (!w) {
log_append (s->logstore, _ ("Simulation"),
_ ("Could not create simulation dialog - .ui file lacks widget "
"called \"toplevel\"."));
return;
}
s->dialog = GTK_DIALOG (w);
g_signal_connect (G_OBJECT (w), "delete_event", G_CALLBACK (delete_event_cb), s);
w = GTK_WIDGET (gtk_builder_get_object (gui, "progressbar"));
s->progress = GTK_PROGRESS_BAR (w);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (s->progress), 0.0);
w = GTK_WIDGET (gtk_builder_get_object (gui, "progress_label"));
s->progress_label = GTK_LABEL (w);
g_signal_connect (G_OBJECT (s->dialog), "response", G_CALLBACK (cancel_cb), s);
gtk_widget_show_all (GTK_WIDGET (s->dialog));
s->sv = sv;
simulate_cmd (s);
}
static NMVpnPluginUiWidgetInterface *
nm_vpn_plugin_ui_widget_interface_new (NMConnection *connection, GError **error)
{
NMVpnPluginUiWidgetInterface *object;
OpenswanPluginUiWidgetPrivate *priv;
char *ui_file;
NMSettingVPN *s_vpn;
gboolean is_new = TRUE;
if (error)
g_return_val_if_fail (*error == NULL, NULL);
object = NM_VPN_PLUGIN_UI_WIDGET_INTERFACE (g_object_new (OPENSWAN_TYPE_PLUGIN_UI_WIDGET, NULL));
if (!object) {
g_set_error (error, OPENSWAN_PLUGIN_UI_ERROR, 0, "could not create openswan object");
return NULL;
}
priv = OPENSWAN_PLUGIN_UI_WIDGET_GET_PRIVATE (object);
ui_file = g_strdup_printf ("%s/%s", UIDIR, "nm-openswan-dialog.ui");
priv->builder = gtk_builder_new ();
g_assert (priv->builder);
gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE);
if (!gtk_builder_add_from_file (priv->builder, ui_file, error)) {
g_warning ("Couldn't load builder file: %s",
error && *error ? (*error)->message : "(unknown)");
g_clear_error (error);
g_set_error (error, OPENSWAN_PLUGIN_UI_ERROR, 0,
"could not load required resources at %s", ui_file);
g_free (ui_file);
g_object_unref (object);
return NULL;
}
g_free (ui_file);
priv->widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "openswan-vbox"));
if (!priv->widget) {
g_set_error (error, OPENSWAN_PLUGIN_UI_ERROR, 0, "could not load UI widget");
g_object_unref (object);
return NULL;
}
g_object_ref_sink (priv->widget);
s_vpn = nm_connection_get_setting_vpn (connection);
if (s_vpn)
nm_setting_vpn_foreach_data_item (s_vpn, is_new_func, &is_new);
if (!init_plugin_ui (OPENSWAN_PLUGIN_UI_WIDGET (object), connection, is_new, error)) {
g_object_unref (object);
return NULL;
}
return object;
}
void
panel_run_dialog_present (GdkScreen *screen,
guint32 activate_time)
{
GtkBuilder *gui;
GError *error;
if (panel_lockdown_get_disable_command_line ())
return;
if (static_dialog) {
gtk_window_set_screen (GTK_WINDOW (static_dialog->run_dialog), screen);
gtk_window_present_with_time (GTK_WINDOW (static_dialog->run_dialog),
activate_time);
gtk_widget_grab_focus (static_dialog->combobox);
return;
}
gui = gtk_builder_new ();
gtk_builder_set_translation_domain (gui, GETTEXT_PACKAGE);
error = NULL;
gtk_builder_add_from_file (gui,
BUILDERDIR "/panel-run-dialog.ui",
&error);
if (error) {
char *secondary;
secondary = g_strdup_printf (_("Unable to load file '%s': %s."),
BUILDERDIR"/panel-run-dialog.ui",
error->message);
panel_error_dialog (NULL, screen, "cannot_display_run_dialog",
TRUE,
_("Could not display run dialog"),
secondary);
g_free (secondary);
g_error_free (error);
g_object_unref (gui);
return;
}
static_dialog = panel_run_dialog_new (screen, gui, activate_time);
g_signal_connect_swapped (static_dialog->run_dialog, "destroy",
G_CALLBACK (panel_run_dialog_static_dialog_destroyed),
static_dialog);
gtk_window_present_with_time (GTK_WINDOW (static_dialog->run_dialog),
activate_time);
g_object_unref (gui);
}
static void
internal_init ()
{
if (builder == NULL)
{
builder = gtk_builder_new ();
ol_assert (builder != NULL);
gtk_builder_set_translation_domain (builder, PACKAGE);
gtk_builder_add_from_file (builder, BUILDER_FILE, NULL);
gtk_builder_connect_signals (builder, NULL);
}
}
/**
* uploads_get_dialog:
*
* Returns the a #GtkWindow representing the Uploads window. If it
* has not already been created, it creates it. The Uploads window is
* set to be hidden instead of destroyed when closed, to avoid having
* to recreate it and re-parse the UI file, etc.
**/
static GtkWindow *
uploads_get_dialog (XviewerPostasaPlugin *plugin)
{
GtkBuilder *builder;
GError *error = NULL;
GtkButton *cancel_button;
GtkButton *cancel_all_button;
if (plugin->priv->uploads_window == NULL) {
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
gtk_builder_add_from_resource (builder, GTKBUILDER_UPLOAD_FILE,
&error);
if (error != NULL) {
g_warning ("Couldn't load Postasa uploads UI file:%d:%s", error->code, error->message);
g_error_free (error);
return NULL;
}
/* note: do not unref gtk_builder_get_object() returns */
plugin->priv->uploads_window = GTK_WINDOW (gtk_builder_get_object (builder, "uploads_window"));
plugin->priv->uploads_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "uploads_view"));
plugin->priv->uploads_store = GTK_LIST_STORE (gtk_builder_get_object (builder, "uploads_store"));
cancel_button = GTK_BUTTON (gtk_builder_get_object (builder, "cancel_button"));
cancel_all_button = GTK_BUTTON (gtk_builder_get_object (builder, "cancel_all_button"));
/* TODO: can't set expand = TRUE when packing cells into columns via glade-3/GtkBuilder apparently?
bgo #602152 So for now, we take them, clear them out, and remap them. Ugh. Better solutions welcome. */
GtkTreeViewColumn *file_col = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder, "file_col"));
GtkCellRenderer *thumbnail_cell = GTK_CELL_RENDERER (gtk_builder_get_object (builder, "thumbnail_cell"));
GtkCellRenderer *filepath_cell = GTK_CELL_RENDERER (gtk_builder_get_object (builder, "filepath_cell"));
gtk_tree_view_column_clear (file_col);
gtk_tree_view_column_pack_start (file_col, thumbnail_cell, FALSE);
gtk_tree_view_column_pack_end (file_col, filepath_cell, TRUE);
gtk_tree_view_column_add_attribute (file_col, thumbnail_cell, "pixbuf", 0);
gtk_tree_view_column_add_attribute (file_col, filepath_cell, "text", 1);
GtkTreeViewColumn *progress_col = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder, "progress_col"));
GtkCellRenderer *progress_cell = GTK_CELL_RENDERER (gtk_builder_get_object (builder, "progress_cell"));
gtk_tree_view_column_clear (progress_col);
gtk_tree_view_column_pack_end (progress_col, progress_cell, TRUE);
gtk_tree_view_column_add_attribute (progress_col, progress_cell, "pulse", 3);
gtk_tree_view_column_add_attribute (progress_col, progress_cell, "text", 5);
g_object_unref (builder);
g_signal_connect (G_OBJECT (cancel_button), "clicked", G_CALLBACK (uploads_cancel_cb), plugin);
g_signal_connect (G_OBJECT (cancel_all_button), "clicked", G_CALLBACK (uploads_cancel_all_cb), plugin);
g_signal_connect (G_OBJECT (plugin->priv->uploads_window), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), plugin);
}
return plugin->priv->uploads_window;
}
static void
cc_ua_panel_init (CcUaPanel *self)
{
CcUaPanelPrivate *priv;
GtkWidget *widget;
GError *err = NULL;
gchar *objects[] = { "universal_access_box", "contrast_model",
"text_size_model", "slowkeys_delay_adjustment",
"bouncekeys_delay_adjustment", "click_delay_adjustment",
"dwell_time_adjustment", "dwell_threshold_adjustment",
"seeing_sizegroup", "typing_sizegroup",
"pointing_sizegroup", "pointing_sizegroup2",
"pointing_scale_sizegroup", "sizegroup1",
"hearing_sizegroup",
NULL };
priv = self->priv = UA_PANEL_PRIVATE (self);
priv->builder = gtk_builder_new ();
gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE);
gtk_builder_add_objects_from_file (priv->builder,
CINNAMONCC_UI_DIR "/uap.ui",
objects,
&err);
if (err)
{
g_warning ("Could not load interface file: %s", err->message);
g_error_free (err);
g_object_unref (priv->builder);
priv->builder = NULL;
return;
}
priv->interface_settings = g_settings_new ("org.gnome.desktop.interface");
priv->wm_settings = g_settings_new ("org.gnome.desktop.wm.preferences");
priv->kb_settings = g_settings_new ("org.gnome.desktop.a11y.keyboard");
priv->mouse_settings = g_settings_new ("org.gnome.desktop.a11y.mouse");
priv->application_settings = g_settings_new ("org.gnome.desktop.a11y.applications");
priv->mediakeys_settings = g_settings_new ("org.cinnamon.settings-daemon.plugins.media-keys");
cc_ua_panel_init_keyboard (self);
cc_ua_panel_init_mouse (self);
cc_ua_panel_init_hearing (self);
cc_ua_panel_init_seeing (self);
widget = (GtkWidget*) gtk_builder_get_object (priv->builder,
"universal_access_box");
gtk_container_add (GTK_CONTAINER (self), widget);
}
Splash *
oregano_splash_new ()
{
GtkBuilder *gui;
GError *perror = NULL;
Splash *sp;
GtkEventBox *event;
gchar *msg;
if ((gui = gtk_builder_new ()) == NULL) {
oregano_error (_("Could not create splash message."));
return NULL;
}
else gtk_builder_set_translation_domain (gui, NULL);
if (!g_file_test (OREGANO_UIDIR "/splash.ui", G_FILE_TEST_EXISTS) ||
!g_file_test (OREGANO_UIDIR "/splash.xpm", G_FILE_TEST_EXISTS)) {
msg = g_strdup_printf (
_("The files %s or %s could not be found. You might need to reinstall Oregano to fix this."),
OREGANO_UIDIR "/splash.ui", OREGANO_UIDIR "/splash.xpm");
oregano_error_with_title (_("Could not create splash message."), msg);
g_free (msg);
return NULL;
}
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/splash.ui",
&perror) <= 0) {
msg = perror->message;
oregano_error_with_title (_("Could not create splash message."), msg);
g_error_free (perror);
return NULL;
}
sp = g_new0 (Splash, 1);
sp->can_destroy = FALSE;
sp->win = GTK_WINDOW (gtk_builder_get_object (gui, "splash"));
sp->lbl = GTK_LABEL (gtk_builder_get_object (gui, "label"));
sp->progress = GTK_WIDGET (gtk_builder_get_object (gui, "pbar"));
event = GTK_EVENT_BOX (gtk_builder_get_object (gui, "event"));
sp->event = GTK_WIDGET (event);
gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (sp->progress), 0.07);
gtk_widget_show_all (GTK_WIDGET (sp->win));
while (gtk_events_pending ())
gtk_main_iteration ();
return sp;
}
void create_ui(SearchTools* self) {
gchar* filepath;
GError* err = 0;
GtkBuilder* builder;
builder = gtk_builder_new();
if( !builder )
return;
gtk_builder_set_translation_domain(builder, TEXT_DOMAIN);
filepath = g_build_filename(self->app->get_plugins_path(), "search_tools.ui", NULL);
if( !filepath ) {
g_printerr("ERROR(search_tools) : build preview page ui filepath failed!\n");
g_object_unref(G_OBJECT(builder));
return;
}
gtk_builder_add_from_file(builder, filepath, &err);
g_free(filepath);
if( err ) {
g_printerr("ERROR(search_tools): %s\n", err->message);
g_error_free(err);
g_object_unref(G_OBJECT(builder));
return;
}
self->panel = GTK_WIDGET(gtk_builder_get_object(builder, "search_tools_panel"));
self->search_entry = GTK_ENTRY(gtk_builder_get_object(builder, "search_entry"));
self->result_store = GTK_LIST_STORE(gtk_builder_get_object(builder, "search_result_store"));
self->result_view = GTK_TREE_VIEW(gtk_builder_get_object(builder, "search_result_view"));
self->search_option_in_current_file = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "search_option_in_current_file"));
self->search_option_in_opened_files = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "search_option_in_opened_files"));
self->search_option_in_current_file_dir = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "search_option_in_current_file_dir"));
assert( self->panel
&& self->search_entry
&& self->result_store
&& self->result_view
&& self->search_option_in_current_file
&& self->search_option_in_opened_files
&& self->search_option_in_current_file_dir );
gtk_widget_show_all(self->panel);
self->app->panel_append(self->panel, gtk_label_new(_("Search")), "puss_plugin_search_tools_panel", PUSS_PANEL_POS_BOTTOM);
g_signal_connect(self->panel, "focus-in-event",G_CALLBACK(&search_tools_active_search_entry), self);
gtk_builder_connect_signals(builder, self);
g_object_unref(G_OBJECT(builder));
}
static NMVpnPluginUiWidgetInterface *
nm_vpn_plugin_ui_widget_interface_new (NMConnection *connection, GError **error)
{
NMVpnPluginUiWidgetInterface *object;
StrongswanPluginUiWidgetPrivate *priv;
char *ui_file;
if (error)
g_return_val_if_fail (*error == NULL, NULL);
object = NM_VPN_PLUGIN_UI_WIDGET_INTERFACE (g_object_new (STRONGSWAN_TYPE_PLUGIN_UI_WIDGET, NULL));
if (!object) {
g_set_error (error, STRONGSWAN_PLUGIN_UI_ERROR, 0, "could not create strongswan object");
return NULL;
}
priv = STRONGSWAN_PLUGIN_UI_WIDGET_GET_PRIVATE (object);
ui_file = g_strdup_printf ("%s/%s", UIDIR, "nm-strongswan-dialog.ui");
priv->builder = gtk_builder_new ();
gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE);
if (!gtk_builder_add_from_file (priv->builder, ui_file, error)) {
g_warning ("Couldn't load builder file: %s",
error && *error ? (*error)->message : "(unknown)");
g_clear_error (error);
g_set_error (error, STRONGSWAN_PLUGIN_UI_ERROR, 0,
"could not load required resources at %s", ui_file);
g_free (ui_file);
g_object_unref (object);
return NULL;
}
g_free (ui_file);
priv->widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "strongswan-vbox") );
if (!priv->widget) {
g_set_error (error, STRONGSWAN_PLUGIN_UI_ERROR, 0, "could not load UI widget");
g_object_unref (object);
return NULL;
}
g_object_ref_sink (priv->widget);
if (!init_plugin_ui (STRONGSWAN_PLUGIN_UI_WIDGET (object), connection, error)) {
g_object_unref (object);
return NULL;
}
return object;
}
void
panel_properties_dialog_present (PanelToplevel *toplevel)
{
PanelPropertiesDialog *dialog;
GtkBuilder *gui;
GError *error;
if (!panel_properties_dialog_quark)
panel_properties_dialog_quark =
g_quark_from_static_string ("panel-properties-dialog");
dialog = g_object_get_qdata (G_OBJECT (toplevel), panel_properties_dialog_quark);
if (dialog) {
gtk_window_set_screen (GTK_WINDOW (dialog->properties_dialog),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
gtk_window_present (GTK_WINDOW (dialog->properties_dialog));
return;
}
gui = gtk_builder_new ();
gtk_builder_set_translation_domain (gui, GETTEXT_PACKAGE);
error = NULL;
gtk_builder_add_from_file (gui,
BUILDERDIR "/panel-properties-dialog.ui",
&error);
if (error) {
char *secondary;
secondary = g_strdup_printf (_("Unable to load file '%s': %s."),
BUILDERDIR"/panel-properties-dialog.ui",
error->message);
panel_error_dialog (GTK_WINDOW (toplevel),
gtk_window_get_screen (GTK_WINDOW (toplevel)),
"cannot_display_properties_dialog", TRUE,
_("Could not display properties dialog"),
secondary);
g_free (secondary);
g_error_free (error);
g_object_unref (gui);
return;
}
dialog = panel_properties_dialog_new (toplevel, gui);
g_object_unref (gui);
}
static GtkWidget *
gedit_word_completion_create_configure_widget (PeasGtkConfigurable *configurable)
{
GtkBuilder *builder;
GtkWidget *content;
GtkWidget *interactive_completion;
GtkWidget *min_word_size;
GSettings *settings;
GError *error = NULL;
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
gtk_builder_add_from_resource (builder,
"/org/gnome/gedit/plugins/wordcompletion/ui/gedit-word-completion-configure.ui",
&error);
if (error != NULL)
{
g_warning ("Word Completion configuration widget: %s", error->message);
g_error_free (error);
error = NULL;
}
content = GTK_WIDGET (gtk_builder_get_object (builder, "content"));
g_object_ref (content);
interactive_completion = GTK_WIDGET (gtk_builder_get_object (builder, "check_button_interactive_completion"));
min_word_size = GTK_WIDGET (gtk_builder_get_object (builder, "spin_button_min_word_size"));
g_object_unref (builder);
settings = g_settings_new (WORD_COMPLETION_SETTINGS_BASE);
g_settings_bind (settings, SETTINGS_KEY_INTERACTIVE_COMPLETION,
interactive_completion, "active",
G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_GET_NO_CHANGES);
g_settings_bind (settings, SETTINGS_KEY_MINIMUM_WORD_SIZE,
min_word_size, "value",
G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_GET_NO_CHANGES);
g_object_unref (settings);
return content;
}
GtkDialog*
encoding_dialog_new(GtkWindow* parent)
{
GtkBuilder* builder;
GObject* object;
GtkDialog* dialog;
GtkWidget* combobox;
GtkTreeModel* model;
dialog = NULL;
builder = gtk_builder_new();
gtk_builder_add_from_file(builder, ENCODINGS_DIALOG_UI, NULL);
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
object = gtk_builder_get_object(builder, "encoding_dialog");
if (object == NULL)
goto done;
dialog = GTK_DIALOG(object);
gtk_window_set_transient_for(GTK_WINDOW(dialog), parent);
model = GTK_TREE_MODEL(get_encoding_list_model());
combobox = combobox_entry_new(model);
g_object_set_data(G_OBJECT(dialog), "encoding_entry", combobox);
object = gtk_builder_get_object(builder, "hbox1");
if (object == NULL)
goto done;
gtk_box_pack_start(GTK_BOX(object), combobox, FALSE, TRUE, 0);
gtk_widget_show(combobox);
object = gtk_builder_get_object(builder, "accellabel1");
if (object == NULL)
goto done;
gtk_accel_label_set_accel_widget(GTK_ACCEL_LABEL(object), combobox);
done:
g_object_unref(builder);
return dialog;
}
static void edit_textbox (SheetItem *sheet_item)
{
TextboxItem *item;
Textbox *textbox;
const char *value;
GtkBuilder *builder;
GError *e = NULL;
Sheet *sheet = sheet_item_get_sheet (sheet_item);
g_return_if_fail (sheet_item != NULL);
g_return_if_fail (IS_TEXTBOX_ITEM (sheet_item));
if ((builder = gtk_builder_new ()) == NULL) {
oregano_error (_ ("Could not create textbox properties dialog"));
return;
}
gtk_builder_set_translation_domain (builder, NULL);
item = TEXTBOX_ITEM (sheet_item);
textbox = TEXTBOX (sheet_item_get_data (sheet_item));
if (!gtk_builder_add_from_file (builder, OREGANO_UIDIR "/textbox-properties-dialog.ui", &e)) {
oregano_error_with_title (_ ("Could not create textbox properties dialog."), e->message);
g_clear_error (&e);
return;
}
prop_dialog = g_new0 (TextboxPropDialog, 1);
prop_dialog->dialog =
GTK_DIALOG (gtk_builder_get_object (builder, "textbox-properties-dialog"));
prop_dialog->entry = GTK_ENTRY (gtk_builder_get_object (builder, "entry"));
value = textbox_get_text (textbox);
gtk_entry_set_text (GTK_ENTRY (prop_dialog->entry), value);
gtk_dialog_run (GTK_DIALOG (prop_dialog->dialog));
edit_dialog_ok (item);
gtk_widget_destroy (GTK_WIDGET (prop_dialog->dialog));
g_free (prop_dialog);
g_object_unref (builder);
}
void
nemo_file_management_properties_dialog_show (GtkWindow *window)
{
GtkBuilder *builder;
if (preferences_dialog != NULL) {
gtk_window_present (GTK_WINDOW (preferences_dialog));
return;
}
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
gtk_builder_add_from_resource (builder,
"/org/nemo/nemo-file-management-properties.glade",
NULL);
nemo_file_management_properties_dialog_setup (builder, window);
g_object_unref (builder);
}
/* Create popup dialog */
void
xkb_options_popup_dialog (GtkBuilder * dialog)
{
GtkWidget *chooser;
chooser_dialog = gtk_builder_new ();
gtk_builder_set_translation_domain (chooser_dialog, GETTEXT_PACKAGE);
gtk_builder_add_from_file (chooser_dialog, CINNAMONCC_UI_DIR
"/cinnamon-region-panel-options-dialog.ui",
NULL);
chooser = CWID ("xkb_options_dialog");
gtk_window_set_transient_for (GTK_WINDOW (chooser),
GTK_WINDOW (gtk_widget_get_toplevel (WID ("region_notebook"))));
gtk_window_set_modal (GTK_WINDOW (chooser), TRUE);
xkb_options_load_options (chooser_dialog);
g_signal_connect (chooser, "response",
G_CALLBACK (chooser_response_cb), dialog);
gtk_widget_show (chooser);
}
