/* Main program. */ int main(int argc, char * argv[]) { #ifdef ENABLE_NLS setlocale(LC_ALL, ""); bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #endif /* Initialize GTK (via g_option_context_parse) and parse command line arguments. */ GOptionContext * context = g_option_context_new(""); g_option_context_add_main_entries(context, opt_entries, GETTEXT_PACKAGE); g_option_context_add_group(context, gtk_get_option_group(TRUE)); GError * err = NULL; if ( ! g_option_context_parse(context, &argc, &argv, &err)) { g_print(_("Error: %s\n"), err->message); g_error_free(err); return 1; } g_option_context_free(context); HandlerContext handler_context; memset(&handler_context, 0, sizeof(handler_context)); /* Get the lxsession PID. */ const char * p = g_getenv("_LXSESSION_PID"); if (p != NULL) handler_context.lxsession_pid = atoi(p); /* Initialize capabilities of the systemd mechanism. */ if (dbus_systemd_CanPowerOff()) { handler_context.shutdown_available = TRUE; handler_context.shutdown_systemd = TRUE; } if (dbus_systemd_CanReboot()) { handler_context.reboot_available = TRUE; handler_context.reboot_systemd = TRUE; } if (dbus_systemd_CanSuspend()) { handler_context.suspend_available = TRUE; handler_context.suspend_systemd = TRUE; } if (dbus_systemd_CanHibernate()) { handler_context.hibernate_available = TRUE; handler_context.hibernate_systemd = TRUE; } /* Initialize capabilities of the ConsoleKit mechanism. */ if (!handler_context.shutdown_available && dbus_ConsoleKit_CanStop()) { handler_context.shutdown_available = TRUE; handler_context.shutdown_ConsoleKit = TRUE; } if (!handler_context.reboot_available && dbus_ConsoleKit_CanRestart()) { handler_context.reboot_available = TRUE; handler_context.reboot_ConsoleKit = TRUE; } /* Initialize capabilities of the UPower mechanism. */ if (!handler_context.suspend_available && dbus_UPower_CanSuspend()) { handler_context.suspend_available = TRUE; handler_context.suspend_UPower = TRUE; } if (!handler_context.hibernate_available && dbus_UPower_CanHibernate()) { handler_context.hibernate_available = TRUE; handler_context.hibernate_UPower = TRUE; } /* If we are under GDM, its "Switch User" is available. */ if (verify_running("gdm", "gdmflexiserver")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_GDM = TRUE; } /* If we are under GDM3, its "Switch User" is available. */ if (verify_running("gdm3", "gdmflexiserver")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_GDM = TRUE; } /* lightdm also use gdmflexiserver */ if (verify_running("lightdm", "gdmflexiserver")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_GDM = TRUE; } /* lightdm also use gdmflexiserver */ if (verify_running("lightdm", "gdmflexiserver")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_GDM = TRUE; } /* lightdm can also be find by the env */ if (g_getenv("XDG_SEAT_PATH")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_LIGHTDM = TRUE; } /* If we are under KDM, its "Switch User" is available. */ if (verify_running("kdm", "kdmctl")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_KDM = TRUE; } if (verify_running("lxdm", "lxdm-binary")) { handler_context.switch_user_available = TRUE; handler_context.switch_user_LXDM = TRUE; } /* LTSP support */ if (g_getenv("LTSP_CLIENT")) { handler_context.ltsp = TRUE; handler_context.shutdown_available = TRUE; handler_context.reboot_available = TRUE; } /* Lock screen */ const gchar* very_lock_screen = determine_lock_screen(); if (very_lock_screen) { handler_context.lock_screen = TRUE; } /* Make the button images accessible. */ gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), PACKAGE_DATA_DIR "/lxsession/images"); /* Get the background pixbuf. */ GdkPixbuf * pixbuf = get_background_pixbuf(); /* Create the toplevel window. */ GtkWidget * window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_decorated(GTK_WINDOW(window), FALSE); gtk_window_fullscreen(GTK_WINDOW(window)); GdkScreen* screen = gtk_widget_get_screen(window); gtk_window_set_default_size(GTK_WINDOW(window), gdk_screen_get_width(screen), gdk_screen_get_height(screen)); gtk_widget_set_app_paintable(window, TRUE); g_signal_connect(G_OBJECT(window), "expose_event", G_CALLBACK(expose_event), pixbuf); /* Toplevel container */ GtkWidget* alignment = gtk_alignment_new(0.5, 0.5, 0.0, 0.0); gtk_container_add(GTK_CONTAINER(window), alignment); GtkWidget* center_area = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(alignment), center_area); GtkWidget* center_vbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(center_vbox), 12); gtk_container_add(GTK_CONTAINER(center_area), center_vbox); GtkWidget* controls = gtk_vbox_new(FALSE, 6); /* If specified, apply a user-specified banner image. */ if (banner_path != NULL) { GtkWidget * banner_image = gtk_image_new_from_file(banner_path); GtkPositionType banner_position = get_banner_position(); switch (banner_position) { case GTK_POS_LEFT: case GTK_POS_RIGHT: { /* Create a horizontal box to contain the image and the controls. */ GtkWidget * box = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(center_vbox), box, FALSE, FALSE, 0); /* Pack the image and a separator. */ gtk_misc_set_alignment(GTK_MISC(banner_image), 0.5, 0.0); if (banner_position == GTK_POS_LEFT) { gtk_box_pack_start(GTK_BOX(box), banner_image, FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(box), gtk_vseparator_new(), FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(box), controls, FALSE, FALSE, 2); } else { gtk_box_pack_start(GTK_BOX(box), controls, FALSE, FALSE, 2); gtk_box_pack_end(GTK_BOX(box), gtk_vseparator_new(), FALSE, FALSE, 2); gtk_box_pack_end(GTK_BOX(box), banner_image, FALSE, FALSE, 2); } } break; case GTK_POS_TOP: gtk_box_pack_start(GTK_BOX(controls), banner_image, FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(controls), gtk_hseparator_new(), FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(center_vbox), controls, FALSE, FALSE, 0); break; case GTK_POS_BOTTOM: gtk_box_pack_end(GTK_BOX(controls), banner_image, FALSE, FALSE, 2); gtk_box_pack_end(GTK_BOX(controls), gtk_hseparator_new(), FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(center_vbox), controls, FALSE, FALSE, 0); break; } } else gtk_box_pack_start(GTK_BOX(center_vbox), controls, FALSE, FALSE, 0); /* Create the label. */ GtkWidget * label = gtk_label_new(""); if (prompt == NULL) { const char * session_name = g_getenv("DESKTOP_SESSION"); if (session_name == NULL) session_name = "LXDE"; const gchar *command_line = "lsb_release -r -s"; gchar *output = NULL; GError *error; if (!g_spawn_command_line_sync( command_line, &output, NULL, NULL, &error)) { fprintf (stderr, "Error: %s\n", error->message); g_error_free (error); } if (output == NULL) { output = ""; } else { output[strlen ( output ) - 1] = '\0'; } prompt = g_strdup_printf(_("<b><big>Logout %s %s session ?</big></b>"), session_name, output); } gtk_label_set_markup(GTK_LABEL(label), prompt); gtk_box_pack_start(GTK_BOX(controls), label, FALSE, FALSE, 4); /* Create the Shutdown button. */ if (handler_context.shutdown_available) { GtkWidget * shutdown_button = gtk_button_new_with_mnemonic(_("Sh_utdown")); GtkWidget * image = gtk_image_new_from_icon_name("system-shutdown", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(shutdown_button), image); gtk_button_set_alignment(GTK_BUTTON(shutdown_button), 0.0, 0.5); g_signal_connect(G_OBJECT(shutdown_button), "clicked", G_CALLBACK(shutdown_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), shutdown_button, FALSE, FALSE, 4); } /* Create the Reboot button. */ if (handler_context.reboot_available) { GtkWidget * reboot_button = gtk_button_new_with_mnemonic(_("_Reboot")); GtkWidget * image = gtk_image_new_from_icon_name("gnome-session-reboot", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(reboot_button), image); gtk_button_set_alignment(GTK_BUTTON(reboot_button), 0.0, 0.5); g_signal_connect(G_OBJECT(reboot_button), "clicked", G_CALLBACK(reboot_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), reboot_button, FALSE, FALSE, 4); } /* Create the Suspend button. */ if (handler_context.suspend_available && !handler_context.ltsp) { GtkWidget * suspend_button = gtk_button_new_with_mnemonic(_("_Suspend")); GtkWidget * image = gtk_image_new_from_icon_name("gnome-session-suspend", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(suspend_button), image); gtk_button_set_alignment(GTK_BUTTON(suspend_button), 0.0, 0.5); g_signal_connect(G_OBJECT(suspend_button), "clicked", G_CALLBACK(suspend_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), suspend_button, FALSE, FALSE, 4); } /* Create the Hibernate button. */ if (handler_context.hibernate_available && !handler_context.ltsp) { GtkWidget * hibernate_button = gtk_button_new_with_mnemonic(_("_Hibernate")); GtkWidget * image = gtk_image_new_from_icon_name("gnome-session-hibernate", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(hibernate_button), image); gtk_button_set_alignment(GTK_BUTTON(hibernate_button), 0.0, 0.5); g_signal_connect(G_OBJECT(hibernate_button), "clicked", G_CALLBACK(hibernate_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), hibernate_button, FALSE, FALSE, 4); } /* Create the Switch User button. */ if (handler_context.switch_user_available && !handler_context.ltsp) { GtkWidget * switch_user_button = gtk_button_new_with_mnemonic(_("S_witch User")); GtkWidget * image = gtk_image_new_from_icon_name("gnome-session-switch", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(switch_user_button), image); gtk_button_set_alignment(GTK_BUTTON(switch_user_button), 0.0, 0.5); g_signal_connect(G_OBJECT(switch_user_button), "clicked", G_CALLBACK(switch_user_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), switch_user_button, FALSE, FALSE, 4); } /* Create the Lock Screen button. */ if (handler_context.lock_screen && !handler_context.ltsp) { GtkWidget * lock_screen_button = gtk_button_new_with_mnemonic(_("L_ock Screen")); GtkWidget * image = gtk_image_new_from_icon_name("system-lock-screen", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(lock_screen_button), image); gtk_button_set_alignment(GTK_BUTTON(lock_screen_button), 0.0, 0.5); g_signal_connect(G_OBJECT(lock_screen_button), "clicked", G_CALLBACK(lock_screen_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), lock_screen_button, FALSE, FALSE, 4); } /* Create the Logout button. */ GtkWidget * logout_button = gtk_button_new_with_mnemonic(_("_Logout")); GtkWidget * image = gtk_image_new_from_icon_name("system-log-out", GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(logout_button), image); gtk_button_set_alignment(GTK_BUTTON(logout_button), 0.0, 0.5); g_signal_connect(G_OBJECT(logout_button), "clicked", G_CALLBACK(logout_clicked), &handler_context); gtk_box_pack_start(GTK_BOX(controls), logout_button, FALSE, FALSE, 4); /* Create the Cancel button. */ GtkWidget * cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_button_set_alignment(GTK_BUTTON(cancel_button), 0.0, 0.5); g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(cancel_clicked), NULL); gtk_box_pack_start(GTK_BOX(controls), cancel_button, FALSE, FALSE, 4); /* Create the error text. */ handler_context.error_label = gtk_label_new(""); gtk_label_set_justify(GTK_LABEL(handler_context.error_label), GTK_JUSTIFY_CENTER); gtk_box_pack_start(GTK_BOX(controls), handler_context.error_label, FALSE, FALSE, 4); /* Show everything. */ gtk_widget_show_all(window); /* Run the main event loop. */ gtk_main(); /* Return. */ return 0; }
void hybrid_confirm_window_create(HybridAccount *account, guchar *pic_data, gint pic_len, HybridConfirmOkFunc ok_func, HybridConfirmCancelFunc cancel_func, gpointer user_data) { HybridConfirmWindow *con; GtkWidget *vbox; GtkWidget *table; GtkWidget *action_area; GtkWidget *button; GtkWidget *label; GdkPixbuf *pixbuf; con = g_new0(HybridConfirmWindow, 1); con->account = account; con->ok_func = ok_func; con->cancel_func = cancel_func; con->user_data = user_data; con->window = hybrid_create_window(_("Confirm Code"), NULL, GTK_WIN_POS_CENTER, FALSE); gtk_widget_set_size_request(con->window, 300, 200); gtk_container_set_border_width(GTK_CONTAINER(con->window), 8); g_signal_connect(con->window, "destroy", G_CALLBACK(destroy_cb), con); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(con->window), vbox); table = gtk_table_new(3, 3, FALSE); gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 5); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<i>Please input the following code in the picture:</i>")); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 2, 0, 1); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<i>Code:</i>")); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); /* show code picture. */ pixbuf = hybrid_create_pixbuf(pic_data, pic_len); con->image = gtk_image_new_from_pixbuf(pixbuf); g_object_unref(pixbuf); gtk_table_attach_defaults(GTK_TABLE(table), con->image, 1, 2, 1, 2); con->entry = gtk_entry_new(); g_signal_connect(con->entry, "activate", G_CALLBACK(ok_cb), con); gtk_table_attach_defaults(GTK_TABLE(table), con->entry, 0, 2, 2, 3); action_area = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), action_area, FALSE, FALSE, 5); button = gtk_button_new_with_label(_("OK")); gtk_widget_set_size_request(button, 100, 30); gtk_box_pack_end(GTK_BOX(action_area), button, FALSE, FALSE, 5); g_signal_connect(button, "clicked", G_CALLBACK(ok_cb), con); button = gtk_button_new_with_label(_("Cancel")); gtk_widget_set_size_request(button, 100, 30); gtk_box_pack_end(GTK_BOX(action_area), button, FALSE, FALSE, 5); g_signal_connect(button, "clicked", G_CALLBACK(cancel_cb), con); gtk_widget_show_all(con->window); }
static void is_sensor_dialog_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { IsSensorDialog *self = IS_SENSOR_DIALOG(object); IsSensorDialogPrivate *priv = self->priv; gchar *markup; switch (property_id) { case PROP_SENSOR: priv->sensor = g_object_ref(g_value_get_object(value)); markup = g_strdup_printf("<span weight='bold'>%s: %s</span>", _("Sensor"), is_sensor_get_path(priv->sensor)); gtk_label_set_markup(GTK_LABEL(priv->path_label), markup); g_free(markup); gtk_widget_set_sensitive(priv->label_entry, TRUE); gtk_entry_set_text(GTK_ENTRY(priv->label_entry), is_sensor_get_label(priv->sensor)); g_signal_connect(priv->label_entry, "changed", G_CALLBACK(label_changed), self); g_signal_connect(priv->sensor, "notify::label", G_CALLBACK(sensor_notify_label), self); gtk_widget_set_sensitive(priv->alarm_mode_combo_box, TRUE); gtk_combo_box_set_active(GTK_COMBO_BOX(priv->alarm_mode_combo_box), is_sensor_get_alarm_mode(priv->sensor)); g_signal_connect(priv->alarm_mode_combo_box, "changed", G_CALLBACK(alarm_mode_changed), self); g_signal_connect(priv->sensor, "notify::alarm-mode", G_CALLBACK(sensor_notify_alarm_mode), self); /* set sensitive so we can update */ gtk_widget_set_sensitive(priv->alarm_value_spin_button, TRUE); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(priv->alarm_value_spin_button), is_sensor_get_digits(priv->sensor)); gtk_spin_button_set_value(GTK_SPIN_BUTTON(priv->alarm_value_spin_button), is_sensor_get_alarm_value(priv->sensor)); g_signal_connect(priv->alarm_value_spin_button, "value-changed", G_CALLBACK(alarm_value_changed), self); g_signal_connect(priv->sensor, "notify::alarm-value", G_CALLBACK(sensor_notify_alarm_value), self); gtk_widget_set_sensitive(priv->alarm_value_spin_button, (is_sensor_get_alarm_mode(priv->sensor) != IS_SENSOR_ALARM_MODE_DISABLED)); gtk_widget_set_sensitive(priv->units_label, TRUE); gtk_label_set_text(GTK_LABEL(priv->units_label), is_sensor_get_units(priv->sensor)); g_signal_connect(priv->sensor, "notify::units", G_CALLBACK(sensor_notify_units), self); gtk_widget_set_sensitive(priv->low_value, TRUE); gtk_spin_button_set_value(GTK_SPIN_BUTTON(priv->low_value), is_sensor_get_low_value(priv->sensor)); g_signal_connect(priv->low_value, "value-changed", G_CALLBACK(low_value_changed), self); g_signal_connect(priv->sensor, "notify::low-value", G_CALLBACK(sensor_notify_low_value), self); gtk_label_set_text(GTK_LABEL(priv->low_units_label), is_sensor_get_units(priv->sensor)); gtk_widget_set_sensitive(priv->high_value, TRUE); gtk_spin_button_set_value(GTK_SPIN_BUTTON(priv->high_value), is_sensor_get_high_value(priv->sensor)); g_signal_connect(priv->high_value, "value-changed", G_CALLBACK(high_value_changed), self); g_signal_connect(priv->sensor, "notify::high-value", G_CALLBACK(sensor_notify_high_value), self); gtk_label_set_text(GTK_LABEL(priv->high_units_label), is_sensor_get_units(priv->sensor)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } }
/* * Dispaly the up-to-date status of the software. If a new release is available * display information about it. */ static gboolean version_info_show(gpointer data) { Dialogs *_dialogs = (data) ? (Dialogs *)data : &dialogs; GtkBuilder *builder = _dialogs->builder; GtkWidget *r_name, *r_link, *r_dld_link; GtkWidget *internal_vbox; gchar *buf; /* don't bother showing the dialog if version check failed (applies only at startup) */ if (!release && !data) return false; gdk_threads_enter(); internal_vbox = GTK_WIDGET(gtk_builder_get_object(builder, "msg_dialog_vbox")); if (!release) { g_object_set(G_OBJECT(_dialogs->latest_version), "text", "Failed to get the latest version." "Make sure you have an internet connection.", NULL); gtk_widget_hide(internal_vbox); } else if (strncmp(GIT_VERSION, release->commit, 7)) { if (date_compare_against_build_date(release->build_date) > 0) { g_object_set(G_OBJECT(_dialogs->latest_version), "text", "A new version is available", NULL); } else { /* No data means that a silent version checking has been requested. The progress bar has already been hidden and so should the message dialog be. */ if (!data) goto end; g_object_set(G_OBJECT(_dialogs->latest_version), "text", "This software is newer than the latest release", NULL); } r_name = GTK_WIDGET(gtk_builder_get_object(builder, "latest_version_name")); r_link = GTK_WIDGET(gtk_builder_get_object(builder, "latest_version_link")); r_dld_link = GTK_WIDGET(gtk_builder_get_object(builder, "latest_version_donwnload_link")); buf = g_strdup_printf("<b>%s</b>", release->name); gtk_label_set_markup(GTK_LABEL(r_name), buf); g_free(buf); gtk_link_button_set_uri(GTK_LINK_BUTTON(r_link), release->url); gtk_link_button_set_uri(GTK_LINK_BUTTON(r_dld_link), release->windows_dld_url); #ifndef __MINGW32__ gtk_widget_hide(r_dld_link); #endif gtk_widget_show(internal_vbox); } else { /* No data means that a silent version checking has been requested. The progress bar has already been hidden and so should the message dialog be. */ if (!data) goto end; g_object_set(G_OBJECT(_dialogs->latest_version), "text", "This software is up to date", NULL); gtk_widget_hide(internal_vbox); } release_dispose(release); release = NULL; gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder, "version_check_dont_show_again")), !data); gtk_dialog_run(GTK_DIALOG(_dialogs->latest_version)); gtk_widget_hide(_dialogs->latest_version); end: gdk_threads_leave(); return false; }
static void pgd_text_get_text (GtkWidget *button, PgdTextDemo *demo) { PopplerPage *page; PopplerRectangle *recs = NULL; guint n_recs; gchar *text; GTimer *timer; gint i; page = poppler_document_get_page (demo->doc, demo->page); if (!page) return; gtk_list_store_clear (demo->model); if (demo->text_attrs) poppler_page_free_text_attributes (demo->text_attrs); demo->text_attrs = NULL; timer = g_timer_new (); text = poppler_page_get_text_for_area (page, &demo->area); g_timer_stop (timer); if (text) { gchar *str; gdouble text_elapsed, layout_elapsed; text_elapsed = g_timer_elapsed (timer, NULL); g_timer_start (timer); poppler_page_get_text_layout_for_area (page, &demo->area, &recs, &n_recs); g_timer_stop (timer); layout_elapsed = g_timer_elapsed (timer, NULL); g_timer_start (timer); demo->text_attrs = poppler_page_get_text_attributes_for_area (page, &demo->area); g_timer_stop (timer); str = g_strdup_printf ("<i>got %ld chars in %.4f seconds, %u layout units in %.4f seconds, text attrs in %.4f seconds</i>", g_utf8_strlen(text, -1), text_elapsed, n_recs, layout_elapsed, g_timer_elapsed (timer, NULL)); gtk_label_set_markup (GTK_LABEL (demo->timer_label), str); g_free (str); } else { gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No text found</i>"); n_recs = 0; } g_timer_destroy (timer); g_object_unref (page); if (text) { gtk_text_buffer_set_text (demo->buffer, text, strlen (text)); g_free (text); } for (i = 0; i < n_recs; i++) { GtkTreeIter iter; gchar *x1, *y1, *x2, *y2; gchar *offset; x1 = g_strdup_printf ("%.2f", recs[i].x1); y1 = g_strdup_printf ("%.2f", recs[i].y1); x2 = g_strdup_printf ("%.2f", recs[i].x2); y2 = g_strdup_printf ("%.2f", recs[i].y2); offset = g_strdup_printf ("%d", i); gtk_list_store_append (demo->model, &iter); gtk_list_store_set (demo->model, &iter, TEXT_X1_COLUMN, x1, TEXT_Y1_COLUMN, y1, TEXT_X2_COLUMN, x2, TEXT_Y2_COLUMN, y2, TEXT_OFFSET_COLUMN, offset, TEXT_OFFPTR_COLUMN, GINT_TO_POINTER (i), -1); g_free (x1); g_free (y1); g_free (x2); g_free (y2); g_free (offset); } g_free (recs); }
//używane przy aktualizacji pozycji na liscie w userlist.c void on_ContactsTreeView_cursor_changed (GtkTreeView * treeview, gpointer user_data) { GtkTreeSelection *selection; GtkTreeModel *model; GtkTreeIter iter; gchar *uuid = NULL; gchar *path = NULL; gchar *tmp = NULL; gchar *uin = NULL; gchar *first_name = NULL; gchar *last_name = NULL; GtkLabel *label_uin = NULL; GtkLabel *label_details = NULL; GList *selected_list = NULL; GList *selected_list_start = NULL; selection = gtk_tree_view_get_selection (treeview); model = gtk_tree_view_get_model (treeview); if (!selection) { g_print ("no selection, no error, juz warning\n"); return; } selected_list = gtk_tree_selection_get_selected_rows (selection, &model); selected_list_start = selected_list; while (selected_list) { GtkTreePath *treepath = selected_list->data; gboolean is_group; gtk_tree_model_get_iter (model, &iter, treepath); gtk_tree_model_get (model, &iter, UI_CONTACTS_COLUMN_UUID, &uuid, -1); gtk_tree_model_get (model, &iter, UI_CONTACTS_COLUMN_IS_GROUP, &is_group, -1); if (is_group) //PARENT goto next_selected; g_assert (uuid); path = gnomegadu_conf_contact_path_find_uuid (uuid); tmp = g_strconcat (path, "/uin", NULL); uin = gconf_client_get_string (gconf, tmp, NULL); g_free (tmp); tmp = g_strconcat (path, "/first_name", NULL); first_name = gconf_client_get_string (gconf, tmp, NULL); g_free (tmp); tmp = g_strconcat (path, "/last_name", NULL); last_name = gconf_client_get_string (gconf, tmp, NULL); g_free (tmp); label_uin = GTK_LABEL (glade_xml_get_widget (gladexml, "ContactDetailsTitleLabel")); gtk_label_set_text (label_uin, uin); label_details = GTK_LABEL (glade_xml_get_widget (gladexml, "ContactDetailsLabel")); tmp = g_strconcat ("<b>Imię:</b> ", first_name, "\n<b>Nazwisko:</b>", last_name, NULL); gtk_label_set_markup (label_details, (const gchar *) tmp); g_free (tmp); g_free (first_name); g_free (last_name); g_free (uin); next_selected: selected_list = g_list_next (selected_list); } g_list_foreach (selected_list_start, (GFunc) gtk_tree_path_free, NULL); g_list_free (selected_list_start); g_free (path); }
/* Shows the preferences dialog on the given tab */ void show_preferences(gint tab) { if(gtk_grab_get_current()) { /* A window is already open, so we present it to the user */ GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current()); gtk_window_present((GtkWindow*)toplevel); return; } /* Declare some variables */ GtkWidget *frame, *label, *alignment, *hbox, *vbox; GtkObject *adjustment, *adjustment_small, *adjustment_statics; GtkTreeViewColumn *tree_column; /* Create the dialog */ GtkWidget* dialog = gtk_dialog_new_with_buttons(_("Preferences"), NULL, (GTK_DIALOG_MODAL + GTK_DIALOG_NO_SEPARATOR), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_icon((GtkWindow*)dialog, gtk_widget_render_icon(dialog, GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU, NULL)); gtk_window_set_resizable((GtkWindow*)dialog, FALSE); /* Create notebook */ GtkWidget* notebook = gtk_notebook_new(); #if GTK_CHECK_VERSION (2,14,0) gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area (GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 2); #else gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 2); #endif /* Build the settings page */ GtkWidget* page_settings = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_settings, 12, 6, 12, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_settings, gtk_label_new(_("Settings"))); GtkWidget* vbox_settings = gtk_vbox_new(FALSE, 12); gtk_container_add((GtkContainer*)page_settings, vbox_settings); /* Build the clipboards frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Clipboards</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); copy_check = gtk_check_button_new_with_mnemonic(_("Use _Copy (Ctrl-C)")); g_signal_connect((GObject*)copy_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, copy_check, FALSE, FALSE, 0); primary_check = gtk_check_button_new_with_mnemonic(_("Use _Primary (Selection)")); g_signal_connect((GObject*)primary_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, primary_check, FALSE, FALSE, 0); synchronize_check = gtk_check_button_new_with_mnemonic(_("S_ynchronize clipboards")); gtk_box_pack_start((GtkBox*)vbox, synchronize_check, FALSE, FALSE, 0); paste_check = gtk_check_button_new_with_mnemonic(_("_Automatically paste selected item")); g_signal_connect((GObject*)paste_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, paste_check, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0); /* Build the miscellaneous frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Miscellaneous</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); show_indexes_check = gtk_check_button_new_with_mnemonic(_("Show _indexes in history menu")); gtk_box_pack_start((GtkBox*)vbox, show_indexes_check, FALSE, FALSE, 0); save_uris_check = gtk_check_button_new_with_mnemonic(_("S_ave URIs")); gtk_box_pack_start((GtkBox*)vbox, save_uris_check, FALSE, FALSE, 0); hyperlinks_check = gtk_check_button_new_with_mnemonic(_("Capture _hyperlinks only")); gtk_box_pack_start((GtkBox*)vbox, hyperlinks_check, FALSE, FALSE, 0); confirm_check = gtk_check_button_new_with_mnemonic(_("C_onfirm before clearing history")); gtk_box_pack_start((GtkBox*)vbox, confirm_check, FALSE, FALSE, 0); use_rmb_menu_check = gtk_check_button_new_with_mnemonic(_("_Use right-click menu")); gtk_box_pack_start((GtkBox*)vbox, use_rmb_menu_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0); /* Build the history page */ GtkWidget* page_history = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_history, 12, 6, 12, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_history, gtk_label_new(_("History"))); GtkWidget* vbox_history = gtk_vbox_new(FALSE, 12); gtk_container_add((GtkContainer*)page_history, vbox_history); /* Build the history frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>History</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); save_check = gtk_check_button_new_with_mnemonic(_("Save _history")); gtk_widget_set_tooltip_text(save_check, _("Save and restore history between sessions")); gtk_box_pack_start((GtkBox*)vbox, save_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Items in history:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment = gtk_adjustment_new(25, 5, 1000, 1, 10, 0); history_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)history_spin, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, history_spin, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Items in menu:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment_small = gtk_adjustment_new(25, 5, 100, 1, 10, 0); items_menu = gtk_spin_button_new((GtkAdjustment*)adjustment_small, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)items_menu, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, items_menu, FALSE, FALSE, 0); statics_show_check = gtk_check_button_new_with_mnemonic(_("Show _static items in menu")); g_signal_connect((GObject*)statics_show_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, statics_show_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Static items in menu:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment_statics = gtk_adjustment_new(10, 1, 100, 1, 10, 0); statics_items_spin = gtk_spin_button_new((GtkAdjustment*)adjustment_statics, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)statics_items_spin, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, statics_items_spin, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); /* Build the items frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Items</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); linemode_check = gtk_check_button_new_with_mnemonic(_("Show in a single _line")); gtk_box_pack_start((GtkBox*)vbox, linemode_check, FALSE, FALSE, 0); reverse_check = gtk_check_button_new_with_mnemonic(_("Show in _reverse order")); gtk_box_pack_start((GtkBox*)vbox, reverse_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Character length of items:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment = gtk_adjustment_new(50, 25, 75, 1, 5, 0); charlength_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)charlength_spin, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, charlength_spin, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Omit items in the:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); ellipsize_combo = gtk_combo_box_new_text(); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning")); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle")); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End")); gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); /* Build the omitting frame frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Omitting</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Omit items in the:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); ellipsize_combo = gtk_combo_box_new_text(); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning")); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle")); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End")); gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); */ /* Build the actions page */ GtkWidget* page_actions = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_actions, 6, 6, 6, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_actions, gtk_label_new(_("Actions"))); GtkWidget* vbox_actions = gtk_vbox_new(FALSE, 6); gtk_container_add((GtkContainer*)page_actions, vbox_actions); /* Build the actions label */ label = gtk_label_new(_("Control-click ClipIt\'s tray icon to use actions")); gtk_label_set_line_wrap((GtkLabel*)label, TRUE); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)vbox_actions, label, FALSE, FALSE, 0); /* Build the actions treeview */ GtkWidget* scrolled_window = gtk_scrolled_window_new( (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0), (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0)); gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window, GTK_SHADOW_ETCHED_OUT); GtkWidget* treeview = gtk_tree_view_new(); gtk_tree_view_set_reorderable((GtkTreeView*)treeview, TRUE); gtk_tree_view_set_rules_hint((GtkTreeView*)treeview, TRUE); actions_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1); gtk_tree_view_set_model((GtkTreeView*)treeview, (GtkTreeModel*)actions_list); GtkCellRenderer* name_renderer = gtk_cell_renderer_text_new(); g_object_set(name_renderer, "editable", TRUE, NULL); g_signal_connect((GObject*)name_renderer, "edited", (GCallback)edit_action, (gpointer)0); tree_column = gtk_tree_view_column_new_with_attributes(_("Action"), name_renderer, "text", 0, NULL); gtk_tree_view_column_set_resizable(tree_column, TRUE); gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column); GtkCellRenderer* command_renderer = gtk_cell_renderer_text_new(); g_object_set(command_renderer, "editable", TRUE, NULL); g_object_set(command_renderer, "ellipsize-set", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_signal_connect((GObject*)command_renderer, "edited", (GCallback)edit_action, (gpointer)1); tree_column = gtk_tree_view_column_new_with_attributes(_("Command"), command_renderer, "text", 1, NULL); gtk_tree_view_column_set_expand(tree_column, TRUE); gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column); gtk_container_add((GtkContainer*)scrolled_window, treeview); gtk_box_pack_start((GtkBox*)vbox_actions, scrolled_window, TRUE, TRUE, 0); /* Edit selection and connect treeview related signals */ actions_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview); gtk_tree_selection_set_mode(actions_selection, GTK_SELECTION_BROWSE); g_signal_connect((GObject*)treeview, "key-press-event", (GCallback)delete_key_pressed, NULL); /* Build the buttons */ GtkWidget* hbbox = gtk_hbutton_box_new(); gtk_box_set_spacing((GtkBox*)hbbox, 6); gtk_button_box_set_layout((GtkButtonBox*)hbbox, GTK_BUTTONBOX_START); GtkWidget* add_button = gtk_button_new_with_label(_("Add...")); gtk_button_set_image((GtkButton*)add_button, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)add_button, "clicked", (GCallback)add_action, NULL); gtk_box_pack_start((GtkBox*)hbbox, add_button, FALSE, TRUE, 0); GtkWidget* remove_button = gtk_button_new_with_label(_("Remove")); gtk_button_set_image((GtkButton*)remove_button, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)remove_button, "clicked", (GCallback)remove_action, NULL); gtk_box_pack_start((GtkBox*)hbbox, remove_button, FALSE, TRUE, 0); GtkWidget* up_button = gtk_button_new(); gtk_button_set_image((GtkButton*)up_button, gtk_image_new_from_stock(GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)up_button, "clicked", (GCallback)move_action_up, NULL); gtk_box_pack_start((GtkBox*)hbbox, up_button, FALSE, TRUE, 0); GtkWidget* down_button = gtk_button_new(); gtk_button_set_image((GtkButton*)down_button, gtk_image_new_from_stock(GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)down_button, "clicked", (GCallback)move_action_down, NULL); gtk_box_pack_start((GtkBox*)hbbox, down_button, FALSE, TRUE, 0); gtk_box_pack_start((GtkBox*)vbox_actions, hbbox, FALSE, FALSE, 0); /* Build the exclude page */ GtkWidget* page_exclude = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_exclude, 6, 6, 6, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_exclude, gtk_label_new(_("Exclude"))); GtkWidget* vbox_exclude = gtk_vbox_new(FALSE, 6); gtk_container_add((GtkContainer*)page_exclude, vbox_exclude); /* Build the exclude label */ label = gtk_label_new(_("Regex list of items that should not be inserted into the history (passwords/sites that you don't need in history, etc).")); gtk_label_set_line_wrap((GtkLabel*)label, TRUE); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)vbox_exclude, label, FALSE, FALSE, 0); /* Build the exclude treeview */ GtkWidget* scrolled_window_exclude = gtk_scrolled_window_new( (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0), (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0)); gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window_exclude, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window_exclude, GTK_SHADOW_ETCHED_OUT); GtkWidget* treeview_exclude = gtk_tree_view_new(); gtk_tree_view_set_reorderable((GtkTreeView*)treeview_exclude, TRUE); gtk_tree_view_set_rules_hint((GtkTreeView*)treeview_exclude, TRUE); exclude_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1); gtk_tree_view_set_model((GtkTreeView*)treeview_exclude, (GtkTreeModel*)exclude_list); GtkCellRenderer* name_renderer_exclude = gtk_cell_renderer_text_new(); g_object_set(name_renderer_exclude, "editable", TRUE, NULL); g_signal_connect((GObject*)name_renderer_exclude, "edited", (GCallback)edit_exclude, (gpointer)0); tree_column = gtk_tree_view_column_new_with_attributes(_("Regex"), name_renderer_exclude, "text", 0, NULL); gtk_tree_view_column_set_resizable(tree_column, TRUE); gtk_tree_view_append_column((GtkTreeView*)treeview_exclude, tree_column); gtk_container_add((GtkContainer*)scrolled_window_exclude, treeview_exclude); gtk_box_pack_start((GtkBox*)vbox_exclude, scrolled_window_exclude, TRUE, TRUE, 0); /* Edit selection and connect treeview related signals */ exclude_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview_exclude); gtk_tree_selection_set_mode(exclude_selection, GTK_SELECTION_BROWSE); g_signal_connect((GObject*)treeview_exclude, "key-press-event", (GCallback)delete_key_pressed, NULL); /* Build the buttons */ GtkWidget* hbbox_exclude = gtk_hbutton_box_new(); gtk_box_set_spacing((GtkBox*)hbbox_exclude, 6); gtk_button_box_set_layout((GtkButtonBox*)hbbox_exclude, GTK_BUTTONBOX_START); GtkWidget* add_button_exclude = gtk_button_new_with_label(_("Add...")); gtk_button_set_image((GtkButton*)add_button_exclude, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)add_button_exclude, "clicked", (GCallback)add_exclude, NULL); gtk_box_pack_start((GtkBox*)hbbox_exclude, add_button_exclude, FALSE, TRUE, 0); GtkWidget* remove_button_exclude = gtk_button_new_with_label(_("Remove")); gtk_button_set_image((GtkButton*)remove_button_exclude, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)remove_button_exclude, "clicked", (GCallback)remove_exclude, NULL); gtk_box_pack_start((GtkBox*)hbbox_exclude, remove_button_exclude, FALSE, TRUE, 0); gtk_box_pack_start((GtkBox*)vbox_exclude, hbbox_exclude, FALSE, FALSE, 0); /* Build the hotkeys page */ GtkWidget* page_extras = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_extras, 12, 6, 12, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_extras, gtk_label_new(_("Hotkeys"))); GtkWidget* vbox_extras = gtk_vbox_new(FALSE, 12); gtk_container_add((GtkContainer*)page_extras, vbox_extras); /* Build the hotkeys frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Hotkeys</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); /* History key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("History hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); history_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)history_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, history_key_entry, TRUE, TRUE, 0); /* Actions key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Actions hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); actions_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)actions_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, actions_key_entry, TRUE, TRUE, 0); /* Menu key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Menu hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); menu_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)menu_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, menu_key_entry, TRUE, TRUE, 0); /* Search key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Manage hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); search_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)search_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, search_key_entry, TRUE, TRUE, 0); /* Offline mode key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Offline mode hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); offline_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)offline_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, offline_key_entry, TRUE, TRUE, 0); gtk_box_pack_start((GtkBox*)vbox_extras, frame, FALSE, FALSE, 0); /* Make widgets reflect current preferences */ gtk_toggle_button_set_active((GtkToggleButton*)copy_check, prefs.use_copy); gtk_toggle_button_set_active((GtkToggleButton*)primary_check, prefs.use_primary); gtk_toggle_button_set_active((GtkToggleButton*)synchronize_check, prefs.synchronize); gtk_toggle_button_set_active((GtkToggleButton*)paste_check, prefs.automatic_paste); gtk_toggle_button_set_active((GtkToggleButton*)show_indexes_check, prefs.show_indexes); gtk_toggle_button_set_active((GtkToggleButton*)save_uris_check, prefs.save_uris); gtk_toggle_button_set_active((GtkToggleButton*)use_rmb_menu_check, prefs.use_rmb_menu); gtk_toggle_button_set_active((GtkToggleButton*)save_check, prefs.save_history); gtk_spin_button_set_value((GtkSpinButton*)history_spin, (gdouble)prefs.history_limit); gtk_spin_button_set_value((GtkSpinButton*)items_menu, (gdouble)prefs.items_menu); gtk_toggle_button_set_active((GtkToggleButton*)statics_show_check, prefs.statics_show); gtk_spin_button_set_value((GtkSpinButton*)statics_items_spin, (gdouble)prefs.statics_items); gtk_toggle_button_set_active((GtkToggleButton*)hyperlinks_check, prefs.hyperlinks_only); gtk_toggle_button_set_active((GtkToggleButton*)confirm_check, prefs.confirm_clear); gtk_toggle_button_set_active((GtkToggleButton*)linemode_check, prefs.single_line); gtk_toggle_button_set_active((GtkToggleButton*)reverse_check, prefs.reverse_history); gtk_spin_button_set_value((GtkSpinButton*)charlength_spin, (gdouble)prefs.item_length); gtk_combo_box_set_active((GtkComboBox*)ellipsize_combo, prefs.ellipsize - 1); gtk_entry_set_text((GtkEntry*)history_key_entry, prefs.history_key); gtk_entry_set_text((GtkEntry*)actions_key_entry, prefs.actions_key); gtk_entry_set_text((GtkEntry*)menu_key_entry, prefs.menu_key); gtk_entry_set_text((GtkEntry*)search_key_entry, prefs.search_key); gtk_entry_set_text((GtkEntry*)offline_key_entry, prefs.offline_key); /* Read actions */ read_actions(); read_excludes(); /* Run the dialog */ gtk_widget_show_all(dialog); #ifdef HAVE_APPINDICATOR gtk_widget_hide(use_rmb_menu_check); #endif gtk_notebook_set_current_page((GtkNotebook*)notebook, tab); if (gtk_dialog_run((GtkDialog*)dialog) == GTK_RESPONSE_ACCEPT) { /* If the user disabled history saving, we ask him if he wants to delete the history file */ if(prefs.save_history && !gtk_toggle_button_get_active((GtkToggleButton*)save_check)) check_saved_hist_file(); /* Apply and save preferences */ apply_preferences(); save_preferences(); save_actions(); save_excludes(); } gtk_widget_destroy(dialog); }
GtkWidget * plugin_google_contacts (EPlugin *epl, EConfigHookItemFactoryData *data) { EABConfigTargetSource *t = (EABConfigTargetSource *) data->target; ESource *source; ESourceGroup *group; const gchar *base_uri; const gchar *username; const gchar *refresh_interval_str; guint refresh_interval; const gchar *use_ssl_str; gchar *buff; gboolean use_ssl; GtkWidget *parent; GtkWidget *vbox; GtkWidget *section; GtkWidget *vbox2; GtkWidget *hbox; GtkWidget *spacer; GtkWidget *label; GtkWidget *username_entry; GtkWidget *interval_sb; GtkWidget *interval_combo; IntervalType type; gint time; GtkWidget *ssl_cb; struct ui_data *ui; source = t->source; group = e_source_peek_group (source); base_uri = e_source_group_peek_base_uri (group); g_object_set_data (G_OBJECT (epl), "gwidget", NULL); if (g_ascii_strncasecmp (GOOGLE_BASE_URI, base_uri, 9) != 0) return NULL; /* Build up the UI */ parent = data->parent; vbox = gtk_widget_get_ancestor ( gtk_widget_get_parent (parent), GTK_TYPE_VBOX); vbox2 = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); section = gtk_label_new (NULL); buff = g_strconcat ("<b>", _("Server"), "</b>", NULL); gtk_label_set_markup (GTK_LABEL (section), buff); g_free (buff); gtk_misc_set_alignment (GTK_MISC (section), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox2), section, FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, TRUE, 0); spacer = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("User_name:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); username_entry = gtk_entry_new (); username = e_source_get_property (source, "username"); if (username) gtk_entry_set_text (GTK_ENTRY (username_entry), username); gtk_box_pack_start (GTK_BOX (hbox), username_entry, TRUE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, TRUE, 0); spacer = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0); use_ssl_str = e_source_get_property (source, "use-ssl"); if (use_ssl_str && ('1' == use_ssl_str[0] || 0 == g_ascii_strcasecmp (use_ssl_str, "true"))) { use_ssl = 1; } else { use_ssl = 0; } ssl_cb = gtk_check_button_new_with_mnemonic (_("Use _secure connection")); gtk_box_pack_start (GTK_BOX (hbox), ssl_cb, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ssl_cb), use_ssl); hbox = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, TRUE, 0); spacer = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0); refresh_interval_str = e_source_get_property (source, "refresh-interval"); if (refresh_interval_str && (1 == sscanf (refresh_interval_str, "%u", &refresh_interval))) { } else { refresh_interval = -1; } seconds_to_interval (refresh_interval, &type, &time); label = gtk_label_new_with_mnemonic (_("Re_fresh:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); interval_sb = gtk_spin_button_new_with_range (1, 100, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (interval_sb), time); gtk_box_pack_start (GTK_BOX (hbox), interval_sb, FALSE, FALSE, 0); interval_combo = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (interval_combo), _("minutes")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (interval_combo), _("hours")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (interval_combo), _("days")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (interval_combo), _("weeks")); gtk_combo_box_set_active (GTK_COMBO_BOX (interval_combo), type); gtk_box_pack_start (GTK_BOX (hbox), interval_combo, FALSE, FALSE, 0); gtk_widget_show_all (vbox2); g_object_set_data (G_OBJECT (interval_sb), "interval-combo", interval_combo); g_object_set_data (G_OBJECT (interval_combo), "interval-sb", interval_sb); ui = g_malloc0 (sizeof (struct ui_data)); ui->widget = vbox2; g_object_set_data_full(G_OBJECT(epl), "gwidget", ui, destroy_ui_data); g_signal_connect ( ui->widget, "destroy", G_CALLBACK (gtk_widget_destroyed), &ui->widget); g_signal_connect ( username_entry, "changed", G_CALLBACK (on_username_entry_changed), source); g_signal_connect ( interval_combo, "changed", G_CALLBACK (on_interval_combo_changed), source); g_signal_connect ( ssl_cb, "toggled", G_CALLBACK (on_ssl_cb_toggled), source); g_signal_connect ( interval_sb, "value-changed", G_CALLBACK (on_interval_sb_value_changed), source); return NULL; }
/* Called when status icon is control-clicked */ static gboolean show_actions_menu(gpointer data) { /* Declare some variables */ GtkWidget *menu, *menu_item, *menu_image, *item_label; /* Create menu */ menu = gtk_menu_new(); g_signal_connect((GObject*)menu, "selection-done", (GCallback)gtk_widget_destroy, NULL); /* Actions using: */ menu_item = gtk_image_menu_item_new_with_label(_("Actions using:")); menu_image = gtk_image_new_from_stock(GTK_STOCK_EXECUTE, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image((GtkImageMenuItem*)menu_item, menu_image); g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); /* Clipboard contents */ gchar* text = gtk_clipboard_wait_for_text(clipboard); if (text != NULL) { menu_item = gtk_menu_item_new_with_label(_("None")); /* Modify menu item label properties */ item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_single_line_mode((GtkLabel*)item_label, TRUE); gtk_label_set_ellipsize((GtkLabel*)item_label, prefs.ellipsize); gtk_label_set_width_chars((GtkLabel*)item_label, 30); /* Making bold... */ gchar* bold_text = g_markup_printf_escaped("<b>%s</b>", text); gtk_label_set_markup((GtkLabel*)item_label, bold_text); g_free(bold_text); /* Append menu item */ g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); } else { /* Create menu item for empty clipboard contents */ menu_item = gtk_menu_item_new_with_label(_("None")); /* Modify menu item label properties */ item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_markup((GtkLabel*)item_label, _("<b>None</b>")); /* Append menu item */ g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); } /* -------------------- */ gtk_menu_shell_append((GtkMenuShell*)menu, gtk_separator_menu_item_new()); /* Actions */ gchar* path = g_build_filename(g_get_user_data_dir(), ACTIONS_FILE, NULL); FILE* actions_file = fopen(path, "rb"); g_free(path); /* Check that it opened and begin read */ if (actions_file) { gint size; size_t fread_return; fread_return = fread(&size, 4, 1, actions_file); /* Check if actions file is empty */ if (!size) { /* File contained no actions so adding empty */ menu_item = gtk_menu_item_new_with_label(_("Empty")); gtk_widget_set_sensitive(menu_item, FALSE); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); } /* Continue reading items until size is 0 */ while (size) { /* Read name */ gchar* name = (gchar*)g_malloc(size + 1); fread_return = fread(name, size, 1, actions_file); name[size] = '\0'; menu_item = gtk_menu_item_new_with_label(name); g_free(name); fread_return = fread(&size, 4, 1, actions_file); /* Read command */ gchar* command = (gchar*)g_malloc(size + 1); fread_return = fread(command, size, 1, actions_file); command[size] = '\0'; fread_return = fread(&size, 4, 1, actions_file); /* Append the action */ gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); g_signal_connect((GObject*)menu_item, "activate", (GCallback)action_selected, (gpointer)command); } fclose(actions_file); } else { /* File did not open so adding empty */ menu_item = gtk_menu_item_new_with_label(_("Empty")); gtk_widget_set_sensitive(menu_item, FALSE); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); } /* -------------------- */ gtk_menu_shell_append((GtkMenuShell*)menu, gtk_separator_menu_item_new()); /* Edit actions */ menu_item = gtk_image_menu_item_new_with_mnemonic(_("_Edit actions")); menu_image = gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image((GtkImageMenuItem*)menu_item, menu_image); g_signal_connect((GObject*)menu_item, "activate", (GCallback)edit_actions_selected, NULL); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); /* Popup the menu... */ gtk_widget_show_all(menu); gtk_menu_popup((GtkMenu*)menu, NULL, NULL, NULL, NULL, 1, gtk_get_current_event_time()); /* Return false so the g_timeout_add() function is called only once */ return FALSE; }
/* Build the multiple file dialog */ static SeahorseWidget* prepare_dialog (FilesCtx *ctx, guint nfolders, guint nfiles, GFileInfo *info, gchar* ext) { SeahorseWidget *swidget; const gchar* pkg; GtkWidget *tog; GtkWidget *w; GtkWidget *combo; gchar *msg, *display; gboolean sep; gint i; GtkCellRenderer *cell; GtkTreeModel *store; FRFileType *save_type_list; g_assert (info); swidget = seahorse_widget_new ("multi-encrypt", NULL); g_return_val_if_fail (swidget != NULL, NULL); /* The main 'selected' message */ msg = make_message (nfolders, nfiles); w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "message")); gtk_label_set_markup (GTK_LABEL(w), msg); g_free (msg); /* Setup the remote or local messages */ w = GTK_WIDGET (seahorse_widget_get_widget (swidget, ctx->remote ? "remote-options" : "local-options")); gtk_widget_show (w); tog = GTK_WIDGET (seahorse_widget_get_widget (swidget, "do-separate")); if (ctx->remote) { /* Always use the seperate option */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tog), TRUE); /* The local stuff */ } else { sep = g_settings_get_boolean (seahorse_tool_settings, "separate-files"); /* Setup the package */ w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "package-name")); display = g_strdup (g_file_info_get_display_name (info)); pkg = seahorse_util_uri_split_last (display); gtk_entry_set_text (GTK_ENTRY (w), pkg); g_free (display); /* Setup the URI combo box */ combo = GTK_WIDGET (seahorse_widget_get_widget (swidget, "package-extension")); store = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), store); g_object_unref (store); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell, "text", 0, NULL); compute_supported_archive_types (); save_type_list = save_type; for (i = 0; save_type_list[i] != FR_FILE_TYPE_NULL; i++) { gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), file_type_desc[save_type_list[i]].ext); if (strcmp(ext, file_type_desc[save_type_list[i]].ext) == 0) gtk_combo_box_set_active (GTK_COMBO_BOX (combo), i); } if(sep == FALSE) { gtk_widget_grab_focus (w); gtk_editable_select_region (GTK_EDITABLE (w), 0, strlen (pkg)); } /* Setup the main radio buttons */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tog), sep); g_signal_connect (tog, "toggled", G_CALLBACK (seperate_toggled), w); seperate_toggled (tog, w); } return swidget; }
static void nmn_applet_init (NmnApplet *applet) { NmnAppletPrivate *priv = GET_PRIVATE (applet); GtkWidget *w; GtkWidget *vbox; GtkWidget *frame; GtkWidget *table; const char *markup_str; char *label; gtk_notebook_set_show_tabs (GTK_NOTEBOOK (applet), FALSE); priv->pane = gtk_hbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (priv->pane), 6); gtk_notebook_append_page (GTK_NOTEBOOK (applet), priv->pane, NULL); /* left side (Networks list, add new connection button) */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (priv->pane), vbox, TRUE, TRUE, 0); frame = mx_gtk_frame_new (); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); priv->add_new_connection = gtk_button_new_with_label (_("Add new connection")); gtk_box_pack_start (GTK_BOX (vbox), priv->add_new_connection, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); label = g_strdup_printf ("<span font_desc=\"Sans Bold 18\" foreground=\"#3e3e3e\">%s</span>", _("Networks")); w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), label); g_free (label); gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); w = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); priv->list = nmn_list_new (); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (w), priv->list); gtk_widget_show (priv->list); gtk_box_pack_start (GTK_BOX (vbox), w, TRUE, TRUE, 0); /* Right side, switches */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (priv->pane), vbox, FALSE, FALSE, 0); frame = mx_gtk_frame_new (); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); w = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), w); table = gtk_table_new (5, 2, FALSE); priv->switches_table = table; gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_set_border_width (GTK_CONTAINER (table), 6); gtk_box_pack_start (GTK_BOX (w), table, FALSE, FALSE, 0); markup_str = "<span font_desc=\"Sans Bold 12\" foreground=\"#3e3e3e\">%s</span>"; w = gtk_label_new (NULL); label = g_strdup_printf (markup_str, _("WiFi")); gtk_label_set_markup (GTK_LABEL (w), label); g_free (label); priv->enable_wifi_label = w; gtk_misc_set_alignment (GTK_MISC (w), 0.2, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), w, 0, 1, SWITCHES_ROW_WIFI, SWITCHES_ROW_WIFI + 1); priv->enable_wifi = mx_gtk_light_switch_new (); gtk_table_attach_defaults (GTK_TABLE (table), priv->enable_wifi, 1, 2, SWITCHES_ROW_WIFI, SWITCHES_ROW_WIFI + 1); w = gtk_label_new (NULL); label = g_strdup_printf (markup_str, _("Wired")); gtk_label_set_markup (GTK_LABEL (w), label); g_free (label); priv->enable_ethernet_label = w; gtk_misc_set_alignment (GTK_MISC (w), 0.2, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), w, 0, 1, SWITCHES_ROW_ETHERNET, SWITCHES_ROW_ETHERNET + 1); priv->enable_ethernet = mx_gtk_light_switch_new (); gtk_table_attach_defaults (GTK_TABLE (table), priv->enable_ethernet, 1, 2, SWITCHES_ROW_ETHERNET, SWITCHES_ROW_ETHERNET + 1); w = gtk_label_new (NULL); label = g_strdup_printf (markup_str, _("3G")); gtk_label_set_markup (GTK_LABEL (w), label); g_free (label); priv->enable_3g_label = w; gtk_misc_set_alignment (GTK_MISC (w), 0.2, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), w, 0, 1, SWITCHES_ROW_3G, SWITCHES_ROW_3G + 1); priv->enable_3g = mx_gtk_light_switch_new (); gtk_table_attach_defaults (GTK_TABLE (table), priv->enable_3g, 1, 2, SWITCHES_ROW_3G, SWITCHES_ROW_3G + 1); w = gtk_label_new (NULL); label = g_strdup_printf (markup_str, _("WiMAX")); gtk_label_set_markup (GTK_LABEL (w), label); g_free (label); priv->enable_wimax_label = w; gtk_misc_set_alignment (GTK_MISC (w), 0.2, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), w, 0, 1, SWITCHES_ROW_WIMAX, SWITCHES_ROW_WIMAX + 1); priv->enable_wimax = mx_gtk_light_switch_new (); gtk_table_attach_defaults (GTK_TABLE (table), priv->enable_wimax, 1, 2, SWITCHES_ROW_WIMAX, SWITCHES_ROW_WIMAX + 1); w = gtk_label_new (NULL); label = g_strdup_printf (markup_str, _("Bluetooth")); gtk_label_set_markup (GTK_LABEL (w), label); g_free (label); priv->enable_bt_label = w; gtk_misc_set_alignment (GTK_MISC (w), 0.2, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), w, 0, 1, SWITCHES_ROW_BT, SWITCHES_ROW_BT + 1); priv->enable_bt = mx_gtk_light_switch_new (); gtk_table_attach_defaults (GTK_TABLE (table), priv->enable_bt, 1, 2, SWITCHES_ROW_BT, SWITCHES_ROW_BT + 1); frame = mx_gtk_frame_new (); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); table = gtk_table_new (2, 2, TRUE); gtk_container_add (GTK_CONTAINER (frame), table); w = gtk_label_new (NULL); label = g_strdup_printf (markup_str, _("Offline mode")); gtk_label_set_markup (GTK_LABEL (w), label); g_free (label); gtk_misc_set_alignment (GTK_MISC (w), 0.2, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), w, 0, 1, 0, 1); priv->enable_network = mx_gtk_light_switch_new (); gtk_table_attach_defaults (GTK_TABLE (table), priv->enable_network, 1, 2, 0, 1); w = gtk_label_new (_("This will disable all your connections")); gtk_table_attach_defaults (GTK_TABLE (table), w, 0, 2, 1, 2); gtk_widget_show_all (priv->pane); }
GtkWidget * pgd_text_create_widget (PopplerDocument *document) { PgdTextDemo *demo; GtkWidget *label; GtkWidget *vbox; GtkWidget *hbox, *page_selector; GtkWidget *button; GtkWidget *swindow, *textview; gchar *str; gint n_pages; demo = g_new0 (PgdTextDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_vbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_text_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); button = gtk_button_new_with_label ("Get Text"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_text_get_text), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No text found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->buffer = gtk_text_buffer_new (NULL); textview = gtk_text_view_new_with_buffer (demo->buffer); gtk_container_add (GTK_CONTAINER (swindow), textview); gtk_widget_show (textview); gtk_box_pack_start (GTK_BOX (vbox), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_text_free, demo); return vbox; }
static void file_list_ready_cb (GList *files, gpointer user_data) { NautilusFileConflictDialog *fcd = user_data; NautilusFile *src, *dest, *dest_dir; time_t src_mtime, dest_mtime; gboolean source_is_dir, dest_is_dir, should_show_type; NautilusFileConflictDialogDetails *details; char *primary_text, *message, *secondary_text; const gchar *message_extra; char *dest_name, *dest_dir_name, *edit_name; char *label_text; char *size, *date, *type = NULL; GdkPixbuf *pixbuf; GtkWidget *label; GString *str; PangoAttrList *attr_list; details = fcd->details; details->handle = NULL; dest_dir = g_list_nth_data (files, 0); dest = g_list_nth_data (files, 1); src = g_list_nth_data (files, 2); src_mtime = nautilus_file_get_mtime (src); dest_mtime = nautilus_file_get_mtime (dest); dest_name = nautilus_file_get_display_name (dest); dest_dir_name = nautilus_file_get_display_name (dest_dir); source_is_dir = nautilus_file_is_directory (src); dest_is_dir = nautilus_file_is_directory (dest); type = nautilus_file_get_mime_type (dest); should_show_type = !nautilus_file_is_mime_type (src, type); g_free (type); type = NULL; /* Set up the right labels */ if (dest_is_dir) { if (source_is_dir) { primary_text = g_strdup_printf (_("Merge folder “%s”?"), dest_name); message_extra = _("Merging will ask for confirmation before replacing any files in " "the folder that conflict with the files being copied."); if (src_mtime > dest_mtime) { message = g_strdup_printf ( _("An older folder with the same name already exists in “%s”."), dest_dir_name); } else if (src_mtime < dest_mtime) { message = g_strdup_printf ( _("A newer folder with the same name already exists in “%s”."), dest_dir_name); } else { message = g_strdup_printf ( _("Another folder with the same name already exists in “%s”."), dest_dir_name); } } else { message_extra = _("Replacing it will remove all files in the folder."); primary_text = g_strdup_printf (_("Replace folder “%s”?"), dest_name); message = g_strdup_printf (_("A folder with the same name already exists in “%s”."), dest_dir_name); } } else { primary_text = g_strdup_printf (_("Replace file “%s”?"), dest_name); message_extra = _("Replacing it will overwrite its content."); if (src_mtime > dest_mtime) { message = g_strdup_printf ( _("An older file with the same name already exists in “%s”."), dest_dir_name); } else if (src_mtime < dest_mtime) { message = g_strdup_printf ( _("A newer file with the same name already exists in “%s”."), dest_dir_name); } else { message = g_strdup_printf ( _("Another file with the same name already exists in “%s”."), dest_dir_name); } } secondary_text = g_strdup_printf ("%s\n%s", message, message_extra); g_free (message); label = gtk_label_new (primary_text); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (details->titles_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); attr_list = pango_attr_list_new (); pango_attr_list_insert (attr_list, pango_attr_weight_new (PANGO_WEIGHT_BOLD)); pango_attr_list_insert (attr_list, pango_attr_scale_new (PANGO_SCALE_LARGE)); g_object_set (label, "attributes", attr_list, NULL); pango_attr_list_unref (attr_list); label = gtk_label_new (secondary_text); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (details->titles_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (primary_text); g_free (secondary_text); /* Set up file icons */ pixbuf = nautilus_file_get_icon_pixbuf (dest, NAUTILUS_ICON_SIZE_LARGE, TRUE, gtk_widget_get_scale_factor (fcd->details->titles_vbox), NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS); details->dest_image = gtk_image_new_from_pixbuf (pixbuf); gtk_box_pack_start (GTK_BOX (details->first_hbox), details->dest_image, FALSE, FALSE, 0); gtk_widget_show (details->dest_image); g_object_unref (pixbuf); pixbuf = nautilus_file_get_icon_pixbuf (src, NAUTILUS_ICON_SIZE_LARGE, TRUE, gtk_widget_get_scale_factor (fcd->details->titles_vbox), NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS); details->src_image = gtk_image_new_from_pixbuf (pixbuf); gtk_box_pack_start (GTK_BOX (details->second_hbox), details->src_image, FALSE, FALSE, 0); gtk_widget_show (details->src_image); g_object_unref (pixbuf); /* Set up labels */ label = gtk_label_new (NULL); date = nautilus_file_get_string_attribute (dest, "date_modified"); size = nautilus_file_get_string_attribute (dest, "size"); if (should_show_type) { type = nautilus_file_get_string_attribute (dest, "type"); } str = g_string_new (NULL); g_string_append_printf (str, "<b>%s</b>\n", _("Original file")); g_string_append_printf (str, "%s %s\n", _("Size:"), size); if (should_show_type) { g_string_append_printf (str, "%s %s\n", _("Type:"), type); } g_string_append_printf (str, "%s %s", _("Last modified:"), date); label_text = str->str; gtk_label_set_markup (GTK_LABEL (label), label_text); gtk_box_pack_start (GTK_BOX (details->first_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (size); g_free (type); g_free (date); g_string_erase (str, 0, -1); /* Second label */ label = gtk_label_new (NULL); date = nautilus_file_get_string_attribute (src, "date_modified"); size = nautilus_file_get_string_attribute (src, "size"); if (should_show_type) { type = nautilus_file_get_string_attribute (src, "type"); } g_string_append_printf (str, "<b>%s</b>\n", _("Replace with")); g_string_append_printf (str, "%s %s\n", _("Size:"), size); if (should_show_type) { g_string_append_printf (str, "%s %s\n", _("Type:"), type); } g_string_append_printf (str, "%s %s", _("Last modified:"), date); label_text = g_string_free (str, FALSE); gtk_label_set_markup (GTK_LABEL (label), label_text); gtk_box_pack_start (GTK_BOX (details->second_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (size); g_free (date); g_free (type); g_free (label_text); /* Populate the entry */ edit_name = nautilus_file_get_edit_name (dest); details->conflict_name = edit_name; gtk_entry_set_text (GTK_ENTRY (details->entry), edit_name); if (source_is_dir && dest_is_dir) { gtk_button_set_label (GTK_BUTTON (details->replace_button), _("Merge")); } nautilus_file_monitor_add (src, fcd, NAUTILUS_FILE_ATTRIBUTES_FOR_ICON); nautilus_file_monitor_add (dest, fcd, NAUTILUS_FILE_ATTRIBUTES_FOR_ICON); details->src_handler_id = g_signal_connect (src, "changed", G_CALLBACK (file_icons_changed), fcd); details->dest_handler_id = g_signal_connect (dest, "changed", G_CALLBACK (file_icons_changed), fcd); }
/* * The setter. */ static void qq_chatwindow_setter(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { if(object == NULL || value == NULL || property_id < 0){ return; } QQChatWindowPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE( object, qq_chatwindow_get_type() , QQChatWindowPriv); gchar buf[500]; GdkPixbuf *pb = NULL; switch (property_id) { case QQ_CHATWINDOW_PROPERTY_UIN: g_stpcpy(priv -> uin, g_value_get_string(value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } QQBuddy *bdy = qq_info_lookup_buddy_by_uin(info, priv -> uin); gchar *name = priv -> uin; if(bdy == NULL){ return; } // set lnick g_snprintf(buf, 500, "<b>%s</b>", bdy -> lnick -> str); gtk_label_set_markup(GTK_LABEL(priv -> lnick_label), buf); // set face image g_snprintf(buf, 500, "%s/%s", QQ_FACEDIR, bdy -> qqnumber -> str); pb= gdk_pixbuf_new_from_file_at_size(buf, 35, 35, NULL); if(pb == NULL){ pb= gdk_pixbuf_new_from_file_at_size(IMGDIR"/avatar.gif" , 35, 35, NULL); } gtk_image_set_from_pixbuf(GTK_IMAGE(priv -> faceimage), pb); // window icon gtk_window_set_icon(GTK_WINDOW(object), pb); g_object_unref(pb); if(bdy -> markname == NULL || bdy -> markname -> len <= 0){ name = bdy -> nick -> str; }else{ name = bdy -> markname -> str; } // set status and name if(g_strcmp0("online", bdy -> status -> str) == 0 || g_strcmp0("away", bdy -> status -> str) == 0 || g_strcmp0("busy", bdy -> status -> str) == 0 || g_strcmp0("silent", bdy -> status -> str) == 0 || g_strcmp0("callme", bdy -> status -> str) == 0){ gtk_widget_set_sensitive(priv -> faceimage, TRUE); g_snprintf(buf, 500, "<b>%s</b><span color='blue'>[%s]</span>" , name , bdy -> status -> str); }else{ gtk_widget_set_sensitive(priv -> faceimage, FALSE); g_snprintf(buf, 500, "<b>%s</b>", name); } gtk_label_set_markup(GTK_LABEL(priv -> name_label), buf); // window title g_snprintf(buf, 500, "Talking with %s", name); gtk_window_set_title(GTK_WINDOW(object), buf); }
void calendar_create_fullyear_window (GUI *appGUI) { GtkWidget *vbox1, *vbox2; GtkWidget *hseparator; GtkWidget *hbuttonbox; GtkWidget *close_button; GtkWidget *hbox1; GtkWidget *prev_button; GtkWidget *info_button; GtkObject *fy_spinbutton_adj; GtkWidget *next_button; GtkWidget *fycal_scrolledwindow; GtkWidget *fycal_viewport; GtkWidget *fycal_alternative_view_checkbutton; GtkWidget *vseparator; GtkWidget *label; GtkWidget *fycal_label, *fycal_vbox; #ifdef HAVE_LIBICAL GtkWidget *button; #endif /* HAVE_LIBICAL */ gchar tmpbuf[BUFFER_SIZE], buffer[BUFFER_SIZE]; gint i, j, x, y, idx; GDate *cdate; guint month, year; cdate = g_date_new (); g_return_if_fail (cdate != NULL); g_date_set_time_t (cdate, time (NULL)); appGUI->cal->fullyear_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (appGUI->cal->fullyear_window), _("Full-year calendar")); gtk_window_set_position (GTK_WINDOW (appGUI->cal->fullyear_window), GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_default_size (GTK_WINDOW (appGUI->cal->fullyear_window), config.fy_window_size_x, config.fy_window_size_y); gtk_window_set_modal (GTK_WINDOW (appGUI->cal->fullyear_window), TRUE); g_signal_connect (G_OBJECT (appGUI->cal->fullyear_window), "delete_event", G_CALLBACK (fullyear_window_close_cb), appGUI); gtk_window_set_transient_for (GTK_WINDOW (appGUI->cal->fullyear_window), GTK_WINDOW (appGUI->main_window)); gtk_container_set_border_width (GTK_CONTAINER (appGUI->cal->fullyear_window), 8); g_signal_connect (G_OBJECT (appGUI->cal->fullyear_window), "key_press_event", G_CALLBACK (fullyear_key_press_cb), appGUI); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (appGUI->cal->fullyear_window), vbox1); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 4); g_snprintf (tmpbuf, BUFFER_SIZE, "<b>%s:</b>", _("Year")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox1), label, FALSE, TRUE, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); fy_spinbutton_adj = gtk_adjustment_new (get_gdate_current_year (), JULIAN_GREGORIAN_YEAR, 9999, 1, 10, 10); appGUI->cal->fy_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (fy_spinbutton_adj), 1, 0); gtk_widget_show (appGUI->cal->fy_spinbutton); g_signal_connect(appGUI->cal->fy_spinbutton, "value-changed", G_CALLBACK(change_year_spin_button_cb), appGUI); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->fy_spinbutton, FALSE, FALSE, 8); gtk_widget_set_size_request (appGUI->cal->fy_spinbutton, 80, -1); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (appGUI->cal->fy_spinbutton), TRUE); gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (appGUI->cal->fy_spinbutton), GTK_UPDATE_IF_VALID); if (config.default_stock_icons) { info_button = gui_stock_button (GTK_STOCK_INFO, FALSE); } else { info_button = gui_stock_button (OSMO_STOCK_BUTTON_INFO, FALSE); } GTK_WIDGET_UNSET_FLAGS(info_button, GTK_CAN_FOCUS); gtk_widget_show (info_button); g_signal_connect (info_button, "clicked", G_CALLBACK (year_info_cb), appGUI); gtk_tooltips_set_tip (appGUI->osmo_tooltips, info_button, _("Year info"), NULL); gtk_button_set_relief (GTK_BUTTON (info_button), GTK_RELIEF_NONE); gtk_box_pack_start (GTK_BOX (hbox1), info_button, FALSE, FALSE, 2); vseparator = gtk_vseparator_new (); gtk_widget_show (vseparator); gtk_box_pack_start (GTK_BOX (hbox1), vseparator, FALSE, FALSE, 8); if (config.default_stock_icons) { prev_button = gui_stock_button (GTK_STOCK_GO_BACK, FALSE); } else { prev_button = gui_stock_button (OSMO_STOCK_BUTTON_PREV_YEAR, FALSE); } GTK_WIDGET_UNSET_FLAGS (prev_button, GTK_CAN_FOCUS); gtk_widget_show (prev_button); g_signal_connect (prev_button, "clicked", G_CALLBACK (change_to_previous_year_cb), appGUI); gtk_tooltips_set_tip (appGUI->osmo_tooltips, prev_button, _("Previous year"), NULL); gtk_button_set_relief (GTK_BUTTON (prev_button), GTK_RELIEF_NONE); gtk_box_pack_start (GTK_BOX (hbox1), prev_button, FALSE, FALSE, 2); if (config.default_stock_icons) { appGUI->cal->cyear_button = gui_stock_button (GTK_STOCK_HOME, FALSE); } else { appGUI->cal->cyear_button = gui_stock_button (OSMO_STOCK_BUTTON_TODAY, FALSE); } GTK_WIDGET_UNSET_FLAGS (appGUI->cal->cyear_button, GTK_CAN_FOCUS); gtk_widget_show (appGUI->cal->cyear_button); g_signal_connect (appGUI->cal->cyear_button, "clicked", G_CALLBACK (change_to_current_year_cb), appGUI); gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->cal->cyear_button, _("Current year"), NULL); gtk_button_set_relief (GTK_BUTTON (appGUI->cal->cyear_button), GTK_RELIEF_NONE); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->cyear_button, FALSE, FALSE, 2); if (config.default_stock_icons) { next_button = gui_stock_button (GTK_STOCK_GO_FORWARD, FALSE); } else { next_button = gui_stock_button (OSMO_STOCK_BUTTON_NEXT_YEAR, FALSE); } GTK_WIDGET_UNSET_FLAGS(next_button, GTK_CAN_FOCUS); gtk_widget_show (next_button); g_signal_connect (next_button, "clicked", G_CALLBACK (change_to_next_year_cb), appGUI); gtk_tooltips_set_tip (appGUI->osmo_tooltips, next_button, _("Next year"), NULL); gtk_button_set_relief (GTK_BUTTON (next_button), GTK_RELIEF_NONE); gtk_box_pack_start (GTK_BOX (hbox1), next_button, FALSE, FALSE, 2); vseparator = gtk_vseparator_new (); gtk_widget_show (vseparator); gtk_box_pack_start (GTK_BOX (hbox1), vseparator, FALSE, FALSE, 8); fycal_alternative_view_checkbutton = gtk_check_button_new_with_mnemonic (_("Alternative view")); GTK_WIDGET_UNSET_FLAGS (fycal_alternative_view_checkbutton, GTK_CAN_FOCUS); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fycal_alternative_view_checkbutton), config.fy_alternative_view); g_signal_connect (G_OBJECT (fycal_alternative_view_checkbutton), "toggled", G_CALLBACK (alternative_view_cb), appGUI); gtk_box_pack_start (GTK_BOX (hbox1), fycal_alternative_view_checkbutton, FALSE, FALSE, 2); gtk_widget_show (fycal_alternative_view_checkbutton); #ifdef HAVE_LIBICAL if (appGUI->calendar_only == FALSE) { button = gtk_button_new_with_label (_("Browse iCal events")); GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS); gtk_widget_show (button); gtk_box_pack_end (GTK_BOX (hbox1), button, FALSE, FALSE, 2); g_signal_connect (button, "clicked", G_CALLBACK (browse_ical_events_cb), appGUI); } #endif /* HAVE_LIBICAL */ fycal_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (fycal_scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox1), fycal_scrolledwindow, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (fycal_scrolledwindow), 4); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (fycal_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); fycal_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (fycal_viewport); gtk_container_add (GTK_CONTAINER (fycal_scrolledwindow), fycal_viewport); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_add (GTK_CONTAINER (fycal_viewport), vbox2); /*-------------------------------------------------------------------------------------*/ /* First view */ if (config.fy_simple_view == TRUE) { appGUI->cal->fycal_table_1 = gtk_table_new (MAX_MONTHS + 2, FULL_YEAR_COLS + 1, FALSE); } else { appGUI->cal->fycal_table_1 = gtk_table_new (MAX_MONTHS + 4, FULL_YEAR_COLS + 3, FALSE); } if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fycal_alternative_view_checkbutton)) == FALSE) { gtk_widget_show (appGUI->cal->fycal_table_1); } gtk_box_pack_start (GTK_BOX (vbox2), appGUI->cal->fycal_table_1, TRUE, TRUE, 0); vseparator = gtk_vseparator_new (); gtk_widget_show (vseparator); if (config.fy_simple_view == TRUE) { gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), vseparator, 1, 2, 0, 14, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); } else { gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), vseparator, 1, 2, 0, 16, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); } hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, 2, 39, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); if (config.fy_simple_view == FALSE) { vseparator = gtk_vseparator_new (); gtk_widget_show (vseparator); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), vseparator, FULL_YEAR_COLS + 2, FULL_YEAR_COLS + 3, 0, 16, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, 2, 39, MAX_MONTHS + 2, MAX_MONTHS + 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, 0, 1, MAX_MONTHS + 2, MAX_MONTHS + 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, FULL_YEAR_COLS + 3, FULL_YEAR_COLS + 4, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, FULL_YEAR_COLS + 3, FULL_YEAR_COLS + 4, MAX_MONTHS + 2, MAX_MONTHS + 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); } g_date_set_day (cdate, 1); for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) { g_date_set_month (cdate, month); g_date_strftime (buffer, BUFFER_SIZE, config.fy_simple_view ? "%b" : "%B", cdate); g_snprintf (tmpbuf, BUFFER_SIZE, (month % 2) ? "%s" : "<span foreground='medium blue'>%s</span>", buffer); label = gtk_label_new (NULL); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), label, 0, 1, month + 1, month + 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_padding (GTK_MISC (label), 8, 0); gtk_label_set_markup (GTK_LABEL (label), tmpbuf); if (config.fy_simple_view == FALSE) { label = gtk_label_new (NULL); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), label, FULL_YEAR_COLS + 3, FULL_YEAR_COLS + 4, month + 1, month + 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_padding (GTK_MISC (label), 8, 0); gtk_label_set_markup (GTK_LABEL (label), tmpbuf); } } /* start with monday */ g_date_set_dmy (cdate, 1, 1, 2007); for (i = 0; i < FULL_YEAR_COLS; i++) { g_date_set_day (cdate, (i % DAYS_PER_WEEK) + 1); g_date_strftime (buffer, BUFFER_SIZE, "%a", cdate); if (i % 7 + 1 == G_DATE_SATURDAY || i % 7 + 1 == G_DATE_SUNDAY) { g_snprintf (tmpbuf, BUFFER_SIZE, "<span foreground='firebrick'>%s</span>", buffer); } else { g_snprintf (tmpbuf, BUFFER_SIZE, "%s", buffer); } label = gtk_label_new (NULL); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), label, i + 2, i + 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_padding (GTK_MISC (label), 4, 0); gtk_label_set_angle (GTK_LABEL (label), 90); gtk_label_set_markup (GTK_LABEL (label), tmpbuf); if (config.fy_simple_view == FALSE) { label = gtk_label_new (NULL); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), label, i + 2, i + 3, MAX_MONTHS + 3, MAX_MONTHS + 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_padding (GTK_MISC (label), 4, 0); gtk_label_set_angle (GTK_LABEL (label), 90); gtk_label_set_markup (GTK_LABEL (label), tmpbuf); } } for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) { for (j = 0; j < FULL_YEAR_COLS; j++) { i = month - 1; idx = i * FULL_YEAR_COLS + j; appGUI->cal->calendar_buttons[idx] = gtk_button_new (); GTK_WIDGET_UNSET_FLAGS (appGUI->cal->calendar_buttons[idx], GTK_CAN_FOCUS); gtk_button_set_relief (GTK_BUTTON (appGUI->cal->calendar_buttons[idx]), GTK_RELIEF_NONE); gtk_widget_show (appGUI->cal->calendar_buttons[idx]); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), appGUI->cal->calendar_buttons[idx], j+2, j+3, i+2, i+3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); } } display_calendar (get_current_year (), appGUI); gtk_widget_set_sensitive (appGUI->cal->cyear_button, FALSE); /*-------------------------------------------------------------------------------------*/ /* Second view */ appGUI->cal->fycal_table_2 = gtk_table_new (3, 4, FALSE); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fycal_alternative_view_checkbutton)) == TRUE) { gtk_widget_show (appGUI->cal->fycal_table_2); } gtk_box_pack_start (GTK_BOX (vbox2), appGUI->cal->fycal_table_2, TRUE, TRUE, 0); for (i = y = 0; y < 3; y++) { for (x = 0; x < 4; x++, i++) { fycal_vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (fycal_vbox); gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_2), fycal_vbox, x, x + 1, y, y + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); fycal_label = gtk_label_new (NULL); gtk_widget_show (fycal_label); gtk_box_pack_start (GTK_BOX (fycal_vbox), fycal_label, FALSE, FALSE, 0); appGUI->cal->fy_calendars[i] = gui_calendar_new (); gtk_widget_show (appGUI->cal->fy_calendars[i]); GTK_WIDGET_UNSET_FLAGS (appGUI->cal->fy_calendars[i], GTK_CAN_FOCUS); gui_calendar_set_display_options (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), (config.display_options & (GUI_CALENDAR_SHOW_DAY_NAMES | GUI_CALENDAR_WEEK_START_MONDAY)) | GUI_CALENDAR_NO_MONTH_CHANGE); gui_calendar_enable_cursor (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), FALSE); gui_calendar_set_event_marker_type (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.event_marker_type); gui_calendar_set_event_marker_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.mark_color); gui_calendar_set_selector_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.selection_color); gui_calendar_set_header_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.header_color); gui_calendar_set_weekend_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.weekend_color); gui_calendar_set_day_note_marker_type (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.day_note_marker); gui_calendar_set_today_marker_type (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.today_marker_type); gui_calendar_set_today_marker_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.mark_current_day_color); gui_calendar_set_today_marker_alpha (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.mark_current_day_alpha); year = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (appGUI->cal->fy_spinbutton)); month = i + 1; gui_calendar_select_month (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), month - 1, year); mark_events (appGUI->cal->fy_calendars[i], month - 1, year, appGUI); g_date_set_dmy (cdate, 1, month, year); g_date_strftime (buffer, BUFFER_SIZE, "%B", cdate); gtk_label_set_text (GTK_LABEL (fycal_label), buffer); gtk_box_pack_start (GTK_BOX (fycal_vbox), appGUI->cal->fy_calendars[i], FALSE, FALSE, 0); } } /*-------------------------------------------------------------------------------------*/ hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4); hbuttonbox = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonbox), 4); if (config.default_stock_icons) { close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); } else { close_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CLOSE); } gtk_widget_show (close_button); g_signal_connect (close_button, "clicked", G_CALLBACK (button_fullyear_window_close_cb), appGUI); gtk_container_add (GTK_CONTAINER (hbuttonbox), close_button); gtk_widget_show (appGUI->cal->fullyear_window); }
static GtkWidget *create_history_menu(GtkWidget *history_menu) { GtkWidget *menu_item, *item_label; history_menu = gtk_menu_new(); g_signal_connect((GObject*)history_menu, "key-press-event", (GCallback)menu_key_pressed, NULL); /* Items */ if ((history != NULL) && (history->data != NULL)) { /* Declare some variables */ GList* element; gint element_number = 0; gint element_number_small = 0; gchar* primary_temp = gtk_clipboard_wait_for_text(primary); gchar* clipboard_temp = gtk_clipboard_wait_for_text(clipboard); /* Reverse history if enabled */ if (prefs.reverse_history) { history = g_list_reverse(history); element_number = g_list_length(history) - 1; } /* Go through each element and adding each */ for (element = history; (element != NULL) && (element_number_small < prefs.items_menu); element = element->next) { history_item *elem_data = element->data; GString* string = g_string_new((gchar*)elem_data->content); /* Ellipsize text */ string = ellipsize_string(string); /* Remove control characters */ string = remove_newlines_string(string); /* Make new item with ellipsized text */ gchar* list_item; if (prefs.show_indexes) { list_item = g_strdup_printf("%d. %s", (element_number_small+1), string->str); } else { list_item = g_strdup(string->str); } menu_item = gtk_menu_item_new_with_label(list_item); g_signal_connect((GObject*)menu_item, "activate", (GCallback)item_selected, GINT_TO_POINTER(element_number)); /* Modify menu item label properties */ item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_single_line_mode((GtkLabel*)item_label, prefs.single_line); /* Check if item is also clipboard text and make bold */ if ((clipboard_temp) && (g_strcmp0((gchar*)elem_data->content, clipboard_temp) == 0)) { gchar* bold_text = g_markup_printf_escaped("<b>%s</b>", list_item); gtk_label_set_markup((GtkLabel*)item_label, bold_text); g_free(bold_text); } else if ((primary_temp) && (g_strcmp0((gchar*)elem_data->content, primary_temp) == 0)) { gchar* italic_text = g_markup_printf_escaped("<i>%s</i>", list_item); gtk_label_set_markup((GtkLabel*)item_label, italic_text); g_free(italic_text); } g_free(list_item); /* Append item */ gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item); /* Prepare for next item */ g_string_free(string, TRUE); if (prefs.reverse_history) element_number--; else element_number++; element_number_small++; } /* Cleanup */ g_free(primary_temp); g_free(clipboard_temp); /* Return history to normal if reversed */ if (prefs.reverse_history) history = g_list_reverse(history); } else { /* Nothing in history so adding empty */ menu_item = gtk_menu_item_new_with_label(_("Empty")); gtk_widget_set_sensitive(menu_item, FALSE); gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item); } if (prefs.statics_show) { /* -------------------- */ gtk_menu_shell_append((GtkMenuShell*)history_menu, gtk_separator_menu_item_new()); /* Items */ GList *elem = history; int elem_num = 0; int elem_num_static = 1; while (elem && (elem_num_static <= prefs.statics_items)) { history_item *hitem = elem->data; if (hitem->is_static) { GString* string = g_string_new((gchar*)hitem->content); /* Ellipsize text */ string = ellipsize_string(string); /* Remove control characters */ string = remove_newlines_string(string); gchar* list_item; if (prefs.show_indexes) { list_item = g_strdup_printf("%d. %s", (elem_num_static), string->str); } else { list_item = g_strdup(string->str); } menu_item = gtk_menu_item_new_with_label(list_item); g_signal_connect((GObject*)menu_item, "activate", (GCallback)item_selected, GINT_TO_POINTER(elem_num)); /* Modify menu item label properties */ item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_single_line_mode((GtkLabel*)item_label, prefs.single_line); g_free(list_item); g_string_free(string, TRUE); gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item); elem_num_static++; } elem_num++; elem = elem->next; } } /* Show a notice in offline mode */ if (prefs.offline_mode) { gtk_menu_shell_append((GtkMenuShell*)history_menu, gtk_separator_menu_item_new()); menu_item = gtk_menu_item_new_with_label(""); item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_markup((GtkLabel*)item_label, "<b>Offline mode is ON</b>"); gtk_label_set_single_line_mode((GtkLabel*)item_label, TRUE); gtk_widget_set_sensitive(item_label, FALSE); gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item); } return history_menu; }
void display_calendar (guint year, GUI *appGUI) { static MESSAGE selected_date[MAX_MONTHS * FULL_YEAR_COLS]; GDate *cdate; gint calendar_table[MAX_MONTHS * FULL_YEAR_COLS]; guint current_day, current_month, current_year; guint month; gint i, idx, day, first_day, days; gchar tmpbuf[BUFFER_SIZE], tmpbuf2[BUFFER_SIZE]; for (i = 0; i < MAX_MONTHS * FULL_YEAR_COLS; i++) { calendar_table[i] = -1; } cdate = g_date_new (); g_return_if_fail (cdate != NULL); for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) { g_date_set_dmy (cdate, 1, month, year); first_day = g_date_get_weekday (cdate); days = g_date_get_days_in_month (month, year); for (i = 1; i <= days; i++) { calendar_table[(month - 1) * FULL_YEAR_COLS + first_day + i - 2] = i; } } g_date_set_time_t (cdate, time (NULL)); current_day = g_date_get_day (cdate); current_month = g_date_get_month (cdate); current_year = g_date_get_year (cdate); for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) { for (i = 0; i < FULL_YEAR_COLS; i++) { idx = (month - 1) * FULL_YEAR_COLS + i; g_signal_handlers_disconnect_by_func (G_OBJECT (appGUI->cal->calendar_buttons[idx]), G_CALLBACK (select_date_day_cb), &selected_date[idx]); day = calendar_table[idx]; if (day > 0) { if (day == current_day && month == current_month && year == current_year) { g_snprintf (tmpbuf2, BUFFER_SIZE, "<b><u>%2d</u></b>", day); } else { g_snprintf (tmpbuf2, BUFFER_SIZE, "%2d", day); } if (i % 7 + 1 == G_DATE_SATURDAY || i % 7 + 1 == G_DATE_SUNDAY) { g_snprintf (tmpbuf, BUFFER_SIZE, "<span foreground='firebrick'>%s</span>", tmpbuf2); } else if (month % 2 == 0) { g_snprintf (tmpbuf, BUFFER_SIZE, "<span foreground='medium blue'>%s</span>", tmpbuf2); } else { g_strlcpy (tmpbuf, tmpbuf2, BUFFER_SIZE); } g_date_set_dmy (cdate, (GDateDay) day, month, (GDateYear) gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (appGUI->cal->fy_spinbutton))); selected_date[idx].data = (gpointer) g_date_get_julian (cdate); selected_date[idx].appGUI = appGUI; g_signal_connect (G_OBJECT (appGUI->cal->calendar_buttons[idx]), "clicked", G_CALLBACK (select_date_day_cb), &selected_date[idx]); gtk_button_set_label (GTK_BUTTON (appGUI->cal->calendar_buttons[idx]), ""); gtk_label_set_markup (GTK_LABEL (GTK_BIN (appGUI->cal->calendar_buttons[idx])->child), tmpbuf); gtk_widget_show (appGUI->cal->calendar_buttons[idx]); } else { gtk_button_set_label (GTK_BUTTON (appGUI->cal->calendar_buttons[idx]), ""); gtk_widget_hide (GTK_WIDGET (appGUI->cal->calendar_buttons[idx])); } } } g_date_free (cdate); }
static void pref_construct(GtkWidget *con) { GtkWidget *frame,*vbox; GtkWidget *a_a_ck, *a_b_ck, *a_s_ck, *c_a_ck, *a_i_ck, *s_s_ck, *s_g_ck; /** * Enable/Disable checkbox */ frame = gtk_frame_new(""); gtk_label_set_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))), "<b>Fetch</b>"); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE); vbox = gtk_vbox_new(FALSE,6); gtk_container_set_border_width(GTK_CONTAINER(vbox), 12); gtk_container_add(GTK_CONTAINER(frame), vbox); /* Fetch artist art */ a_a_ck = gtk_check_button_new_with_label(_("Artist images")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_a_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-artist", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), a_a_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(a_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_ART)); /* Fetch artist text*/ a_b_ck = gtk_check_button_new_with_label(_("Artist biography")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_b_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-biography-artist", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), a_b_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(a_b_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_TXT)); /* Fetch similar artists */ a_s_ck = gtk_check_button_new_with_label(_("Similar artists")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_s_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-artist", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), a_s_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(a_s_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_SIMILAR)); /* Fetch album art */ c_a_ck = gtk_check_button_new_with_label(_("Album cover")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c_a_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-album", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), c_a_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(c_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ALBUM_ART)); /* Fetch album info */ a_i_ck = gtk_check_button_new_with_label(_("Album information")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_i_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-album-info", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), a_i_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(c_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ALBUM_TXT)); /* Fetch similar songs */ s_s_ck = gtk_check_button_new_with_label(_("Similar songs")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_s_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-song", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), s_s_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(s_s_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_SONG_SIMILAR)); /* Fetch similar genre */ s_g_ck = gtk_check_button_new_with_label(_("Similar genres")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_g_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-genre", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), s_g_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(s_g_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_GENRE_SIMILAR)); if(!lastfm_get_enabled()) { gtk_widget_set_sensitive(GTK_WIDGET(vbox), FALSE); } gtk_widget_show_all(frame); gtk_container_add(GTK_CONTAINER(con), frame); }
static struct _send_data * build_dialog (EAccountList *accounts, CamelFolder *outbox, const char *destination) { GtkDialog *gd; GtkWidget *table; int row, num_sources; GList *list = NULL; struct _send_data *data; GtkWidget *send_icon; GtkWidget *recv_icon; GtkWidget *scrolled_window; GtkWidget *label; GtkWidget *status_label; GtkWidget *progress_bar; GtkWidget *cancel_button; struct _send_info *info; char *pretty_url; EAccount *account; EIterator *iter; GList *icon_list; EMEventTargetSendReceive *target; gd = (GtkDialog *)(send_recv_dialog = gtk_dialog_new_with_buttons(_("Send & Receive Mail"), NULL, GTK_DIALOG_NO_SEPARATOR, NULL)); gtk_window_set_modal ((GtkWindow *) gd, FALSE); gconf_bridge_bind_window_size ( gconf_bridge_get (), GCONF_KEY_PREFIX, GTK_WINDOW (send_recv_dialog)); gtk_widget_ensure_style ((GtkWidget *)gd); gtk_container_set_border_width ((GtkContainer *)gd->vbox, 0); gtk_container_set_border_width ((GtkContainer *)gd->action_area, 6); cancel_button = gtk_button_new_with_mnemonic (_("Cancel _All")); gtk_button_set_image ( GTK_BUTTON (cancel_button), gtk_image_new_from_stock ( GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON)); gtk_widget_show (cancel_button); gtk_dialog_add_action_widget (gd, cancel_button, GTK_RESPONSE_CANCEL); icon_list = e_icon_factory_get_icon_list ("mail-send-receive"); if (icon_list) { gtk_window_set_icon_list (GTK_WINDOW (gd), icon_list); g_list_foreach (icon_list, (GFunc) g_object_unref, NULL); g_list_free (icon_list); } num_sources = 0; iter = e_list_get_iterator ((EList *) accounts); while (e_iterator_is_valid (iter)) { account = (EAccount *) e_iterator_get (iter); if (account->source->url) num_sources++; e_iterator_next (iter); } g_object_unref (iter); table = gtk_table_new (num_sources, 4, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width ( GTK_CONTAINER (scrolled_window), 6); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport ( GTK_SCROLLED_WINDOW (scrolled_window), table); gtk_box_pack_start ( GTK_BOX (gd->vbox), scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); /* must bet setup after send_recv_dialog as it may re-trigger send-recv button */ data = setup_send_data (); row = 0; iter = e_list_get_iterator ((EList *) accounts); while (e_iterator_is_valid (iter)) { EAccountService *source; account = (EAccount *) e_iterator_get (iter); source = account->source; if (!account->enabled || !source->url) { e_iterator_next (iter); continue; } /* see if we have an outstanding download active */ info = g_hash_table_lookup (data->active, source->url); if (info == NULL) { send_info_t type; type = get_receive_type (source->url); if (type == SEND_INVALID || type == SEND_SEND) { e_iterator_next (iter); continue; } info = g_malloc0 (sizeof (*info)); info->type = type; d(printf("adding source %s\n", source->url)); info->uri = g_strdup (source->url); info->keep = source->keep_on_server; info->cancel = camel_operation_new (operation_status, info); info->state = SEND_ACTIVE; info->timeout_id = g_timeout_add (STATUS_TIMEOUT, operation_status_timeout, info); g_hash_table_insert (data->active, info->uri, info); list = g_list_prepend (list, info); } else if (info->progress_bar != NULL) { /* incase we get the same source pop up again */ e_iterator_next (iter); continue; } else if (info->timeout_id == 0) info->timeout_id = g_timeout_add (STATUS_TIMEOUT, operation_status_timeout, info); recv_icon = e_icon_factory_get_image ( "mail-inbox", E_ICON_SIZE_LARGE_TOOLBAR); pretty_url = format_url (source->url, account->name); label = gtk_label_new (NULL); gtk_label_set_ellipsize ( GTK_LABEL (label), PANGO_ELLIPSIZE_END); gtk_label_set_markup (GTK_LABEL (label), pretty_url); g_free (pretty_url); progress_bar = gtk_progress_bar_new (); cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); status_label = gtk_label_new ( (info->type == SEND_UPDATE) ? _("Updating...") : _("Waiting...")); gtk_label_set_ellipsize ( GTK_LABEL (status_label), PANGO_ELLIPSIZE_END); /* g_object_set(data->label, "bold", TRUE, NULL); */ gtk_misc_set_alignment (GTK_MISC (label), 0, .5); gtk_misc_set_alignment (GTK_MISC (status_label), 0, .5); gtk_table_attach ( GTK_TABLE (table), recv_icon, 0, 1, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), label, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), progress_bar, 2, 3, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), cancel_button, 3, 4, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), status_label, 1, 2, row+1, row+2, GTK_EXPAND | GTK_FILL, 0, 0, 0); info->progress_bar = progress_bar; info->status_label = status_label; info->cancel_button = cancel_button; info->data = data; g_signal_connect ( cancel_button, "clicked", G_CALLBACK (receive_cancel), info); e_iterator_next (iter); row = row + 2; } g_object_unref (iter); /* Hook: If some one wants to hook on to the sendreceive dialog, this is the way to go. */ target = em_event_target_new_send_receive (em_event_peek(), table, data, row, EM_EVENT_SEND_RECEIVE); e_event_emit ((EEvent *)em_event_peek (), "mail.sendreceive", (EEventTarget *) target); if (outbox && destination) { info = g_hash_table_lookup (data->active, SEND_URI_KEY); if (info == NULL) { info = g_malloc0 (sizeof (*info)); info->type = SEND_SEND; d(printf("adding dest %s\n", destination)); info->uri = g_strdup (destination); info->keep = FALSE; info->cancel = camel_operation_new (operation_status, info); info->state = SEND_ACTIVE; info->timeout_id = g_timeout_add (STATUS_TIMEOUT, operation_status_timeout, info); g_hash_table_insert (data->active, SEND_URI_KEY, info); list = g_list_prepend (list, info); } else if (info->timeout_id == 0) info->timeout_id = g_timeout_add (STATUS_TIMEOUT, operation_status_timeout, info); send_icon = e_icon_factory_get_image ( "mail-outbox", E_ICON_SIZE_LARGE_TOOLBAR); pretty_url = format_url (destination, NULL); label = gtk_label_new (NULL); gtk_label_set_ellipsize ( GTK_LABEL (label), PANGO_ELLIPSIZE_END); gtk_label_set_markup (GTK_LABEL (label), pretty_url); g_free (pretty_url); progress_bar = gtk_progress_bar_new (); cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); status_label = gtk_label_new (_("Waiting...")); gtk_label_set_ellipsize ( GTK_LABEL (status_label), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment (GTK_MISC (label), 0, .5); gtk_misc_set_alignment (GTK_MISC (status_label), 0, .5); gtk_table_attach ( GTK_TABLE (table), send_icon, 0, 1, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), label, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), progress_bar, 2, 3, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), cancel_button, 3, 4, row, row+2, 0, 0, 0, 0); gtk_table_attach ( GTK_TABLE (table), status_label, 1, 2, row+1, row+2, GTK_EXPAND | GTK_FILL, 0, 0, 0); info->progress_bar = progress_bar; info->cancel_button = cancel_button; info->data = data; info->status_label = status_label; g_signal_connect ( cancel_button, "clicked", G_CALLBACK (receive_cancel), info); gtk_widget_show_all (table); } gtk_widget_show (GTK_WIDGET (gd)); g_signal_connect (gd, "response", G_CALLBACK (dialog_response), data); g_object_weak_ref ((GObject *) gd, (GWeakNotify) dialog_destroy_cb, data); data->infos = list; data->gd = gd; return data; }
//! mengambil combo box pilihan id static GtkWidget *modifGetPilihanId(GtkWidget *bagian){ gboolean status = FALSE; GtkWidget *dialog , *content_area; GtkWidget *label1; GtkWidget *table; dialog = gtk_dialog_new(); table = gtk_table_new(1, 1, FALSE); // content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); char *str = "<b>Id</b>"; label1 = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label1), str); gtk_table_attach(GTK_TABLE(table), label1, 0, 1, 0, 1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5); //! isinya combobox GtkListStore *store; GtkTreeIter iter; GtkCellRenderer *cell; store = gtk_list_store_new ( 1, G_TYPE_STRING ); GValueArray* has = databaseGetDatasFromDb("select id from isi ", NULL , &status); gint i; for(i=0;i<has->n_values;i++){ GValue *ii = g_value_array_get_nth (has ,i ); gchar *tmp = g_strdup_printf ("%i", g_value_get_int(ii) ); gtk_list_store_append( store, &iter); gtk_list_store_set( store, &iter, 0, tmp, -1 ); //! free g_free(tmp); } // GtkWidget* bagian = gtk_combo_box_new_with_model( GTK_TREE_MODEL( store ) ); // bagian = gtk_combo_box_new_with_model( GTK_TREE_MODEL( store ) ); gtk_combo_box_set_model ( (GtkComboBox *) bagian,(GtkTreeModel *)store); gtk_combo_box_set_active( (GtkComboBox *) bagian,0); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( bagian ), cell, TRUE ); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( bagian ), cell, "text", 0, NULL ); gtk_combo_box_set_row_span_column(bagian,0); gtk_table_attach(GTK_TABLE(table), bagian , 1, 2 , 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_SHRINK, 5, 5); gtk_window_set_default_size(GTK_WINDOW(dialog), 250, 100); gtk_container_add (GTK_CONTAINER (content_area), table ); modifAddButton(dialog,GTK_RESPONSE_CANCEL); gchar *tmp = g_strdup_printf ("Pilih Id - %s", globalGetAppName()); gtk_window_set_title(GTK_WINDOW(dialog), tmp); gtk_dialog_set_has_separator(dialog,TRUE); // data = bagian; gtk_dialog_set_has_separator(dialog,TRUE); gtk_window_set_modal( GTK_WINDOW( dialog ), TRUE ); gtk_window_set_transient_for( GTK_WINDOW( dialog ),GTK_WINDOW( globalGetParent() ) ); //! free g_value_array_free (has); g_object_unref( G_OBJECT( store ) ); return dialog; }
static GtkWidget *create_dialog(void) { GtkWidget *dialog; GtkWidget *header_image; GtkWidget *header_label; GtkWidget *label_info; GtkWidget *codename_label; GtkWidget *builddate_label; GtkWidget *url_button; GtkWidget *cop_label; GtkWidget *label; GtkWidget *license_textview; GtkWidget *notebook; GtkWidget *box; GtkWidget *credits_scrollwin; GtkWidget *table; GtkWidget *license_scrollwin; GtkWidget *info_box; GtkWidget *header_hbox; GtkWidget *header_eventbox; GdkPixbuf *icon; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; dialog = gtk_dialog_new(); /* configure dialog */ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany")); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL); /* create header */ header_eventbox = gtk_event_box_new(); gtk_widget_show(header_eventbox); header_hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4); gtk_widget_show(header_hbox); gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox); header_image = gtk_image_new(); gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0); header_label = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE); /* print the subversion revision generated by ./configure if it is available */ g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string()); gtk_label_set_markup(GTK_LABEL(header_label), buffer); gtk_widget_show(header_label); gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0); header_eventbox_style_set(header_eventbox); header_label_style_set(header_label); g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL); g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0); /* set image */ icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO); gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon); gtk_window_set_icon(GTK_WINDOW(dialog), icon); g_object_unref(icon); /* free our reference */ /* create notebook */ notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_container_set_border_width(GTK_CONTAINER(notebook), 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0); /* create "Info" tab */ info_box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(info_box), 6); gtk_widget_show(info_box); label_info = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(label_info), TRUE); gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE); g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE")); gtk_label_set_markup(GTK_LABEL(label_info), buffer); gtk_misc_set_padding(GTK_MISC(label_info), 2, 11); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0); /* Codename label */ codename_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE); gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME); gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8); gtk_widget_show(codename_label); gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0); /* build date label */ builddate_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__); g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2); gtk_label_set_markup(GTK_LABEL(builddate_label), buffer); gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2); gtk_widget_show(builddate_label); gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0); box = gtk_hbutton_box_new(); url_button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE); g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE); label = gtk_label_new(NULL); gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE); gtk_widget_show(label); gtk_container_add(GTK_CONTAINER(url_button), label); gtk_widget_show(url_button); gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10); /* copyright label */ cop_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE); gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE); gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT); gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10); gtk_widget_show(cop_label); gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0); /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */ label = gtk_label_new(_("Info")); gtk_widget_show(label); gtk_widget_show_all(info_box); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label); /* create "Credits" tab */ credits_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 10); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 10); row = 0; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < translators_len; i++) { ROW(translators[i][0], row, 0, 1, 4, 0); ROW(translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < prev_translators_len; i++) { ROW(prev_translators[i][0], row, 0, 1, 4, 0); ROW(prev_translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; g_snprintf(buffer, sizeof(buffer), _("Some of the many contributors (for a more detailed list, see the file %s):"), #ifdef G_OS_WIN32 "Thanks.txt" #else "THANKS" #endif ); label = geany_wrap_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; label = geany_wrap_label_new(contributors); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE); gtk_widget_show_all(table); label = gtk_label_new(_("Credits")); gtk_widget_show(label); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label); /* create "License" tab */ license_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); license_textview = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE); gtk_widget_show(license_textview); gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview); label = gtk_label_new(_("License")); gtk_widget_show(label); g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir); g_file_get_contents(buffer, &license_text, NULL, NULL); if (license_text == NULL) { license_text = g_strdup( _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online.")); } tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview)); gtk_text_buffer_set_text(tb, license_text, -1); g_free(license_text); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label); gtk_widget_show_all(dialog); return dialog; }
static void pgd_page_set_page (PgdPageDemo *demo, PopplerPage *page) { #ifdef POPPLER_WITH_GDK GdkPixbuf *thumbnail; #else cairo_surface_t *thumbnail; #endif gchar *str; str = page ? g_strdup_printf ("%d", poppler_page_get_index (page)) : NULL; gtk_label_set_text (GTK_LABEL (demo->index), str); g_free (str); if (page) { str = poppler_page_get_label (page); gtk_label_set_text (GTK_LABEL (demo->label), str); g_free (str); } else { gtk_label_set_text (GTK_LABEL (demo->label), NULL); } if (page) { gdouble width, height; poppler_page_get_size (page, &width, &height); str = g_strdup_printf ("%.2f x %.2f", width, height); gtk_label_set_text (GTK_LABEL (demo->size), str); g_free (str); } else { gtk_label_set_text (GTK_LABEL (demo->size), NULL); } str = page ? g_strdup_printf ("%.2f seconds", poppler_page_get_duration (page)) : NULL; gtk_label_set_text (GTK_LABEL (demo->duration), str); g_free (str); #ifdef POPPLER_WITH_GDK thumbnail = page ? poppler_page_get_thumbnail_pixbuf (page) : NULL; #else thumbnail = page ? poppler_page_get_thumbnail (page) : NULL; #endif if (thumbnail) { gint width, height; poppler_page_get_thumbnail_size (page, &width, &height); str = g_strdup_printf ("%d x %d", width, height); gtk_label_set_text (GTK_LABEL (demo->thumbnail_size), str); g_free (str); #ifdef POPPLER_WITH_GDK gtk_image_set_from_pixbuf (GTK_IMAGE (demo->thumbnail), thumbnail); g_object_unref (thumbnail); #else image_set_from_surface (GTK_IMAGE (demo->thumbnail), thumbnail); cairo_surface_destroy (thumbnail); #endif } else { str = g_strdup ("<i>No thumbnail found</i>"); gtk_label_set_markup (GTK_LABEL (demo->thumbnail_size), str); g_free (str); gtk_image_set_from_icon_name (GTK_IMAGE (demo->thumbnail), "image-missing", GTK_ICON_SIZE_DIALOG); } }
GtkWidget * pgd_text_create_widget (PopplerDocument *document) { PgdTextDemo *demo; GtkWidget *label; GtkWidget *vbox, *vbox2; GtkWidget *hbox, *page_selector, *area_hbox; GtkWidget *button; GtkWidget *swindow, *textview, *treeview; GtkTreeSelection *selection; GtkWidget *frame, *alignment, *table; GtkWidget *hpaned; GtkCellRenderer *renderer; gchar *str; gint n_pages; gint row = 0; demo = g_new0 (PgdTextDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_text_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("X1:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_x1 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_x1, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x1, TRUE, TRUE, 0); gtk_widget_show (demo->area_x1); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Y1:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_y1 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_y1, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y1, TRUE, TRUE, 0); gtk_widget_show (demo->area_y1); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("X2:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_x2 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_x2, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x2, TRUE, TRUE, 0); gtk_widget_show (demo->area_x2); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Y2:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_y2 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_y2, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y2, TRUE, TRUE, 0); gtk_widget_show (demo->area_y2); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); pgd_text_area_selector_setup (demo); button = gtk_button_new_with_label ("Get Text"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_text_get_text), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No text found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_paned_set_position (GTK_PANED (hpaned), 300); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); demo->treeview = treeview; renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_X1_COLUMN, "X1", renderer, "text", TEXT_X1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_Y1_COLUMN, "Y1", renderer, "text", TEXT_Y1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_X2_COLUMN, "X2", renderer, "text", TEXT_X2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_Y2_COLUMN, "Y2", renderer, "text", TEXT_Y2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_OFFSET_COLUMN, "Offset", renderer, "text", TEXT_OFFSET_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (selection, "changed", G_CALLBACK (pgd_text_selection_changed), (gpointer) demo); gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); /* Text attributes */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Text Attributes</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (table), 6); gtk_grid_set_row_spacing (GTK_GRID (table), 6); demo->font_name = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Name:</b>", demo->font_name, &row); demo->font_size = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Size:</b>", demo->font_size, &row); demo->is_underlined = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Underlined:</b>", demo->is_underlined, &row); demo->text_color = gtk_image_new (); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Color:</b>", demo->text_color, &row); gtk_container_add (GTK_CONTAINER (alignment), table); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 12); gtk_widget_show (frame); gtk_paned_add1 (GTK_PANED (hpaned), vbox2); gtk_widget_show (vbox2); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->buffer = gtk_text_buffer_new (NULL); textview = gtk_text_view_new_with_buffer (demo->buffer); g_signal_connect (textview, "query-tooltip", G_CALLBACK (pgd_text_view_query_tooltip), demo); g_signal_connect (demo->buffer, "notify::has-selection", G_CALLBACK (pgd_text_buffer_selection_changed), textview); gtk_container_add (GTK_CONTAINER (swindow), textview); gtk_widget_show (textview); gtk_paned_add2 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_text_free, demo); return vbox; }
GtkWidget * pgd_page_create_widget (PopplerDocument *document) { PgdPageDemo *demo; GtkWidget *vbox; GtkWidget *hbox, *page_selector; GtkWidget *button; GtkWidget *frame, *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *thumnail_box; gchar *str; gint n_pages; gint row = 0; demo = g_new0 (PgdPageDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_page_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); button = gtk_button_new_with_label ("Get Info"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_page_get_info), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Page Properties</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (table), 6); gtk_grid_set_row_spacing (GTK_GRID (table), 6); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Index:</b>", &(demo->index), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Label:</b>", &(demo->label), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Size:</b>", &(demo->size), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Duration:</b>", &(demo->duration), NULL, &row); gtk_container_add (GTK_CONTAINER (alignment), table); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Page Thumbnail</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); thumnail_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); demo->thumbnail = gtk_image_new (); gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail, TRUE, TRUE, 0); gtk_widget_show (demo->thumbnail); demo->thumbnail_size = gtk_label_new (NULL); g_object_set (G_OBJECT (demo->thumbnail_size), "xalign", 0.5, NULL); gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail_size, TRUE, TRUE, 0); gtk_widget_show (demo->thumbnail_size); gtk_container_add (GTK_CONTAINER (alignment), thumnail_box); gtk_widget_show (thumnail_box); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_page_free, (gpointer)demo); return vbox; }
static void set_up (EmpathyIndividualLinker *self) { EmpathyIndividualLinkerPriv *priv; EmpathyIndividualManager *individual_manager; GtkWidget *top_vbox; GtkPaned *paned; GtkWidget *label, *scrolled_window; GtkBox *vbox; EmpathyPersonaView *persona_view; gchar *tmp; GtkWidget *alignment; priv = GET_PRIV (self); top_vbox = gtk_vbox_new (FALSE, 6); /* Layout panes */ paned = GTK_PANED (gtk_hpaned_new ()); /* Left column heading */ alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 0, 6); gtk_widget_show (alignment); vbox = GTK_BOX (gtk_vbox_new (FALSE, 6)); label = gtk_label_new (NULL); tmp = g_strdup_printf ("<b>%s</b>", _("Select contacts to link")); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_box_pack_start (vbox, label, FALSE, TRUE, 0); gtk_widget_show (label); /* Individual selector */ individual_manager = empathy_individual_manager_dup_singleton (); priv->individual_store = empathy_individual_store_new (individual_manager); g_object_unref (individual_manager); empathy_individual_store_set_show_protocols (priv->individual_store, FALSE); priv->individual_view = empathy_individual_view_new (priv->individual_store, EMPATHY_INDIVIDUAL_VIEW_FEATURE_INDIVIDUAL_DRAG | EMPATHY_INDIVIDUAL_VIEW_FEATURE_INDIVIDUAL_DROP | EMPATHY_INDIVIDUAL_VIEW_FEATURE_PERSONA_DROP, EMPATHY_INDIVIDUAL_FEATURE_NONE); empathy_individual_view_set_show_offline (priv->individual_view, TRUE); empathy_individual_view_set_show_untrusted (priv->individual_view, FALSE); g_signal_connect (priv->individual_view, "row-activated", (GCallback) row_activated_cb, self); g_signal_connect (priv->individual_view, "drag-motion", (GCallback) individual_view_drag_motion_cb, self); g_signal_connect (priv->individual_view, "drag-persona-received", (GCallback) individual_view_drag_persona_received_cb, self); /* Add a checkbox column to the selector */ priv->toggle_renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (priv->toggle_renderer, "toggled", (GCallback) row_toggled_cb, self); priv->toggle_column = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (priv->toggle_column, priv->toggle_renderer, FALSE); gtk_tree_view_column_set_cell_data_func (priv->toggle_column, priv->toggle_renderer, (GtkTreeCellDataFunc) contact_toggle_cell_data_func, self, NULL); gtk_tree_view_insert_column (GTK_TREE_VIEW (priv->individual_view), priv->toggle_column, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (priv->individual_view)); gtk_widget_show (GTK_WIDGET (priv->individual_view)); gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); /* Live search */ priv->search_widget = empathy_live_search_new ( GTK_WIDGET (priv->individual_view)); empathy_individual_view_set_live_search (priv->individual_view, EMPATHY_LIVE_SEARCH (priv->search_widget)); gtk_box_pack_end (vbox, priv->search_widget, FALSE, TRUE, 0); gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox)); gtk_paned_pack1 (paned, alignment, TRUE, FALSE); gtk_widget_show (GTK_WIDGET (vbox)); /* Right column heading */ alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 6, 0); gtk_widget_show (alignment); vbox = GTK_BOX (gtk_vbox_new (FALSE, 6)); label = gtk_label_new (NULL); tmp = g_strdup_printf ("<b>%s</b>", _("New contact preview")); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_box_pack_start (vbox, label, FALSE, TRUE, 0); gtk_widget_show (label); /* New individual preview */ priv->preview_widget = empathy_individual_widget_new (priv->new_individual, EMPATHY_INDIVIDUAL_WIDGET_SHOW_DETAILS); gtk_box_pack_start (vbox, priv->preview_widget, FALSE, TRUE, 0); gtk_widget_show (priv->preview_widget); /* Persona list */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); priv->persona_store = empathy_persona_store_new (priv->new_individual); empathy_persona_store_set_show_protocols (priv->persona_store, TRUE); persona_view = empathy_persona_view_new (priv->persona_store, EMPATHY_PERSONA_VIEW_FEATURE_ALL); empathy_persona_view_set_show_offline (persona_view, TRUE); g_signal_connect (persona_view, "drag-individual-received", (GCallback) persona_view_drag_individual_received_cb, self); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (persona_view)); gtk_widget_show (GTK_WIDGET (persona_view)); gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox)); gtk_paned_pack2 (paned, alignment, TRUE, FALSE); gtk_widget_show (GTK_WIDGET (vbox)); gtk_widget_show (GTK_WIDGET (paned)); /* Footer label */ label = gtk_label_new (NULL); tmp = g_strdup_printf ("<i>%s</i>", _("Contacts selected in the list on the left will be linked together.")); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (top_vbox), GTK_WIDGET (paned), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (top_vbox), label, FALSE, TRUE, 0); /* Add the main vbox to the bin */ gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (top_vbox)); gtk_widget_show (GTK_WIDGET (top_vbox)); }
void gui_show_dialog(gpointer signal, gboolean change) { GGaduSignal *sig = (GGaduSignal *) signal; GtkWidget *dialog_widget = NULL; GtkWidget *image = NULL; GtkWidget *table = NULL; GtkWidget *label = NULL; GtkWidget *hbox = NULL; GdkPixbuf *windowicon = NULL; GGaduDialog *dialog = (sig) ? sig->data : NULL; gchar *markup = NULL; if (!sig) return; if ((ggadu_dialog_get_flags(dialog) & GGADU_DIALOG_FLAG_ONLY_OK) == GGADU_DIALOG_FLAG_ONLY_OK) dialog_widget = gtk_dialog_new_with_buttons(dialog->title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); else dialog_widget = gtk_dialog_new_with_buttons(dialog->title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(dialog_widget), GTK_RESPONSE_OK); gtk_window_set_resizable(GTK_WINDOW(dialog_widget), FALSE); if ((windowicon = create_pixbuf(GGADU_DEFAULT_ICON_FILENAME)) != NULL) { gtk_window_set_icon(GTK_WINDOW(dialog_widget), windowicon); gdk_pixbuf_unref(windowicon); } hbox = gtk_hbox_new(FALSE, 0); if (ggadu_dialog_get_type(dialog)) { gint type = ggadu_dialog_get_type(dialog); print_debug("d->type = %d\n", type); switch (type) { case GGADU_DIALOG_CONFIG: image = gtk_image_new(); gtk_image_set_from_stock(GTK_IMAGE(image), "gtk-preferences", GTK_ICON_SIZE_DND); break; case GGADU_DIALOG_YES_NO: image = gtk_image_new(); gtk_image_set_from_stock(GTK_IMAGE(image), "gtk-dialog-question", GTK_ICON_SIZE_DND); break; default: break; } gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 5); } label = gtk_label_new(NULL); markup = g_strdup_printf("<span weight=\"bold\">%s</span>", ggadu_dialog_get_title(dialog)); gtk_label_set_markup(GTK_LABEL(label), markup); g_free(markup); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_widget)->vbox), hbox, TRUE, TRUE, 10); if (dialog->flags & GGADU_DIALOG_FLAG_PROGRESS) table = gui_build_dialog_gtk_table(ggadu_dialog_get_entries(dialog), 1, TRUE); else table = gui_build_dialog_gtk_table(ggadu_dialog_get_entries(dialog), 1, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 7); gtk_table_set_col_spacings(GTK_TABLE(table), 5); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_widget)->vbox), table, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(dialog_widget), "response", G_CALLBACK(gui_dialog_response), signal_cpy(signal)); /* if (ggadu_dialog_get_type(dialog) == GGADU_DIALOG_PROGRESS) { g_timeout_add(1000,dialog->watch_func,NULL); } */ gtk_widget_show_all(dialog_widget); }
/* returns TRUE if a folder window should be opened */ static gboolean do_autorun_for_content_type (GMount *mount, const char *x_content_type, CajaAutorunOpenWindow open_window_func, gpointer user_data) { AutorunDialogData *data; GtkWidget *dialog; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *label; GtkWidget *combo_box; GtkWidget *always_check_button; GtkWidget *eject_button; GtkWidget *image; char *markup; char *content_description; char *mount_name; GIcon *icon; GdkPixbuf *pixbuf; CajaIconInfo *icon_info; int icon_size; gboolean user_forced_dialog; gboolean pref_ask; gboolean pref_start_app; gboolean pref_ignore; gboolean pref_open_folder; char *media_greeting; gboolean ret; ret = FALSE; mount_name = NULL; if (g_content_type_is_a (x_content_type, "x-content/win32-software")) { /* don't pop up the dialog anyway if the content type says * windows software. */ goto out; } user_forced_dialog = is_shift_pressed (); caja_autorun_get_preferences (x_content_type, &pref_start_app, &pref_ignore, &pref_open_folder); pref_ask = !pref_start_app && !pref_ignore && !pref_open_folder; if (user_forced_dialog) { goto show_dialog; } if (!pref_ask && !pref_ignore && !pref_open_folder) { GAppInfo *app_info; app_info = g_app_info_get_default_for_type (x_content_type, FALSE); if (app_info != NULL) { caja_autorun_launch_for_mount (mount, app_info); } goto out; } if (pref_open_folder) { ret = TRUE; goto out; } if (pref_ignore) { goto out; } show_dialog: mount_name = g_mount_get_name (mount); dialog = gtk_dialog_new (); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); icon = g_mount_get_icon (mount); icon_size = caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_DIALOG); icon_info = caja_icon_info_lookup (icon, icon_size); pixbuf = caja_icon_info_get_pixbuf_at_size (icon_info, icon_size); g_object_unref (icon_info); g_object_unref (icon); image = gtk_image_new_from_pixbuf (pixbuf); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, TRUE, TRUE, 0); /* also use the icon on the dialog */ gtk_window_set_title (GTK_WINDOW (dialog), mount_name); gtk_window_set_icon (GTK_WINDOW (dialog), pixbuf); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); g_object_unref (pixbuf); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); label = gtk_label_new (NULL); /* Customize greeting for well-known x-content types */ if (strcmp (x_content_type, "x-content/audio-cdda") == 0) { media_greeting = _("You have just inserted an Audio CD."); } else if (strcmp (x_content_type, "x-content/audio-dvd") == 0) { media_greeting = _("You have just inserted an Audio DVD."); } else if (strcmp (x_content_type, "x-content/video-dvd") == 0) { media_greeting = _("You have just inserted a Video DVD."); } else if (strcmp (x_content_type, "x-content/video-vcd") == 0) { media_greeting = _("You have just inserted a Video CD."); } else if (strcmp (x_content_type, "x-content/video-svcd") == 0) { media_greeting = _("You have just inserted a Super Video CD."); } else if (strcmp (x_content_type, "x-content/blank-cd") == 0) { media_greeting = _("You have just inserted a blank CD."); } else if (strcmp (x_content_type, "x-content/blank-dvd") == 0) { media_greeting = _("You have just inserted a blank DVD."); } else if (strcmp (x_content_type, "x-content/blank-cd") == 0) { media_greeting = _("You have just inserted a blank Blu-Ray disc."); } else if (strcmp (x_content_type, "x-content/blank-cd") == 0) { media_greeting = _("You have just inserted a blank HD DVD."); } else if (strcmp (x_content_type, "x-content/image-photocd") == 0) { media_greeting = _("You have just inserted a Photo CD."); } else if (strcmp (x_content_type, "x-content/image-picturecd") == 0) { media_greeting = _("You have just inserted a Picture CD."); } else if (strcmp (x_content_type, "x-content/image-dcf") == 0) { media_greeting = _("You have just inserted a medium with digital photos."); } else if (strcmp (x_content_type, "x-content/audio-player") == 0) { media_greeting = _("You have just inserted a digital audio player."); } else if (g_content_type_is_a (x_content_type, "x-content/software")) { media_greeting = _("You have just inserted a medium with software intended to be automatically started."); } else { /* fallback to generic greeting */ media_greeting = _("You have just inserted a medium."); } markup = g_strdup_printf ("<big><b>%s %s</b></big>", media_greeting, _("Choose what application to launch.")); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0); label = gtk_label_new (NULL); content_description = g_content_type_get_description (x_content_type); markup = g_strdup_printf (_("Select how to open \"%s\" and whether to perform this action in the future for other media of type \"%s\"."), mount_name, content_description); g_free (content_description); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0); data = g_new0 (AutorunDialogData, 1); data->dialog = dialog; data->mount = g_object_ref (mount); data->remember = !pref_ask; data->selected_ignore = pref_ignore; data->x_content_type = g_strdup (x_content_type); data->selected_app = g_app_info_get_default_for_type (x_content_type, FALSE); data->open_window_func = open_window_func; data->user_data = user_data; combo_box = gtk_combo_box_new (); caja_autorun_prepare_combo_box (combo_box, x_content_type, FALSE, TRUE, FALSE, autorun_combo_changed, data); g_signal_connect (G_OBJECT (combo_box), "key-press-event", G_CALLBACK (combo_box_enter_ok), dialog); gtk_box_pack_start (GTK_BOX (vbox), combo_box, TRUE, TRUE, 0); always_check_button = gtk_check_button_new_with_mnemonic (_("_Always perform this action")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (always_check_button), data->remember); g_signal_connect (G_OBJECT (always_check_button), "toggled", G_CALLBACK (autorun_always_toggled), data); gtk_box_pack_start (GTK_BOX (vbox), always_check_button, TRUE, TRUE, 0); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); if (g_mount_can_eject (mount)) { GtkWidget *eject_image; eject_button = gtk_button_new_with_mnemonic (_("_Eject")); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "media-eject", caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_BUTTON), 0, NULL); eject_image = gtk_image_new_from_pixbuf (pixbuf); g_object_unref (pixbuf); gtk_button_set_image (GTK_BUTTON (eject_button), eject_image); data->should_eject = TRUE; } else { eject_button = gtk_button_new_with_mnemonic (_("_Unmount")); data->should_eject = FALSE; } gtk_dialog_add_action_widget (GTK_DIALOG (dialog), eject_button, AUTORUN_DIALOG_RESPONSE_EJECT); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))), eject_button, TRUE); /* show the dialog */ gtk_widget_show_all (dialog); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (autorun_dialog_response), data); g_signal_connect (G_OBJECT (data->mount), "unmounted", G_CALLBACK (autorun_dialog_mount_unmounted), data); out: g_free (mount_name); return ret; }
/** * called when the user click on the button 'create the new reconciliation' * check the entries and create the corresponding reconciliation * * \param button * \param label a message label, hidden at the beginning, that will say ok the reconciliation is created * or if there is a problem... * * \return FALSE * */ static gboolean gsb_assistant_reconcile_config_page_add_new_reconcile ( GtkWidget *button, GtkWidget *label ) { gint reconcile_number; gchar *string; /* first, we check the date are valid */ if ( !gsb_date_check_entry ( reconcile_init_date_entry ) ) { string = make_red ( _("The initial date is not valid, please check it.") ); gtk_label_set_markup ( GTK_LABEL ( label) , string ); gtk_widget_grab_focus (reconcile_init_date_entry); g_free ( string ); return FALSE; } if ( !gsb_date_check_entry ( reconcile_final_date_entry ) ) { string = make_red ( _("The final date is not valid, please check it.") ); gtk_label_set_markup ( GTK_LABEL ( label) , string ); gtk_widget_grab_focus ( reconcile_final_date_entry ); g_free ( string ); return FALSE; } /* check there is a name */ if ( !strlen (gtk_entry_get_text ( GTK_ENTRY ( reconcile_name_entry ) ) ) ) { string = make_red ( _("Please give a name to the new reconciliation.") ); gtk_label_set_markup ( GTK_LABEL ( label) , string ); gtk_widget_grab_focus ( reconcile_name_entry ); g_free ( string ); return FALSE; } /* check if already exist the name */ if ( gsb_data_reconcile_get_number_by_name ( gtk_entry_get_text (GTK_ENTRY (reconcile_name_entry) ) ) ) { string = make_red ( _("That name already exists, please find another one.") ); gtk_label_set_markup ( GTK_LABEL ( label) , string ); gtk_widget_grab_focus ( reconcile_name_entry ); g_free ( string ); return FALSE; } /* ok, now we can create the reconcile */ reconcile_number = gsb_data_reconcile_new ( gtk_entry_get_text ( GTK_ENTRY ( reconcile_name_entry ) ) ); if ( !reconcile_number ) if (gsb_data_reconcile_get_number_by_name ( gtk_entry_get_text ( GTK_ENTRY ( reconcile_name_entry ) ) ) ) { string = make_red ( _("Cannot allocate memory : Bad things will happen soon.") ); gtk_label_set_markup ( GTK_LABEL ( label) , string ); gtk_widget_grab_focus ( reconcile_name_entry ); g_free ( string ); return FALSE; } gsb_data_reconcile_set_init_date ( reconcile_number, gsb_calendar_entry_get_date ( reconcile_init_date_entry ) ); gsb_data_reconcile_set_final_date ( reconcile_number, gsb_calendar_entry_get_date ( reconcile_final_date_entry ) ); gsb_data_reconcile_set_init_balance ( reconcile_number, utils_real_get_from_string ( gtk_entry_get_text ( GTK_ENTRY (reconcile_init_balance_entry ) ) ) ); gsb_data_reconcile_set_final_balance ( reconcile_number, utils_real_get_from_string ( gtk_entry_get_text ( GTK_ENTRY ( reconcile_final_balance_entry ) ) ) ); gsb_data_reconcile_set_account ( reconcile_number, gsb_account_get_combo_account_number ( reconcile_account_button ) ); /* erase the entries but not the account wich can be used again */ gtk_entry_set_text ( GTK_ENTRY (reconcile_name_entry), "" ); gtk_entry_set_text ( GTK_ENTRY (reconcile_init_date_entry), "" ); gtk_entry_set_text ( GTK_ENTRY (reconcile_final_date_entry), "" ); gtk_entry_set_text ( GTK_ENTRY (reconcile_init_balance_entry), "" ); gtk_entry_set_text ( GTK_ENTRY (reconcile_final_balance_entry), "" ); string = make_blue ( g_strdup_printf ( _("Reconciliation %s successfully appended!"), gsb_data_reconcile_get_name ( reconcile_number ) ) ); gtk_label_set_markup ( GTK_LABEL ( label ), string ); g_free ( string ); /* update the list of reconcile in the configuration list */ gsb_reconcile_config_fill ( ); gtk_widget_grab_focus ( reconcile_name_entry ); return FALSE; }
int main (int argc, char *argv[]) { GtkWidget *window, *label, *vbox, *button; GdkScreen *screen; gint i; gtk_init (&argc, &argv); screen = gdk_screen_get_default (); num_monitors = gdk_screen_get_n_monitors (screen); if (num_monitors == 1) g_warning ("The default screen of the current display only has one monitor."); primary_monitor = gdk_screen_get_primary_monitor (screen); for (i = 0; i < num_monitors; i++) { GdkRectangle monitor; gchar *str; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gdk_screen_get_monitor_geometry (screen, i, &monitor); gtk_window_set_default_size (GTK_WINDOW (window), 200, 200); gtk_window_move (GTK_WINDOW (window), (monitor.width - 200) / 2 + monitor.x, (monitor.height - 200) / 2 + monitor.y); label = gtk_label_new (NULL); str = g_strdup_printf ("<big><span foreground='white' background='black'>" "Monitor %d of %d</span></big>\n" "<i>Width - Height </i>: (%d,%d)\n" "<i>Top left coordinate </i>: (%d,%d)\n" "<i>Primary monitor: %d</i>", i + 1, num_monitors, monitor.width, monitor.height, monitor.x, monitor.y, primary_monitor); gtk_label_set_markup (GTK_LABEL (label), str); g_free (str); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); button = gtk_button_new_with_label ("Query current monitor"); g_signal_connect (button, "clicked", G_CALLBACK (request), label); gtk_container_add (GTK_CONTAINER (vbox), button); button = gtk_button_new_with_label ("Close"); g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); gtk_container_add (GTK_CONTAINER (vbox), button); gtk_widget_show_all (window); g_signal_connect (screen, "monitors-changed", G_CALLBACK (monitors_changed_cb), label); } gtk_main (); return 0; }
/*! \brief Creates a group of 2D Table Editors packed into a GtkNotebook \param button is a pointer to the widget the user click on, which has bound to is a list of the TE Table ID's which we need to create on-screen representations for \returns TRUE on success, FALSE otherwise */ G_MODULE_EXPORT gboolean create_2d_table_editor_group(GtkWidget *button) { GladeXML *main_xml = NULL; GladeXML *xml = NULL; GtkWidget *widget = NULL; GtkWidget *window = NULL; GtkWidget *notebook = NULL; GtkWidget *curve = NULL; GtkWidget *x_parent = NULL; GtkWidget *y_parent = NULL; GtkWidget *x_table = NULL; GtkWidget *y_table = NULL; GtkWidget *label = NULL; GtkWidget *entry = NULL; GtkWidget *dummy = NULL; GtkWidget *gauge = NULL; GtkWidget *parent = NULL; GtkWidget *curve_parent = NULL; CurveData *cdata = NULL; GArray *x_entries = NULL; GArray *y_entries = NULL; GList *widget_list = NULL; GList *curve_list = NULL; GList *gauge_list = NULL; gchar * tmpbuf = NULL; gchar * filename = NULL; gchar **vector = NULL; GList ***ecu_widgets = NULL; gint num_tabs = 0; gint x_mult = 0; gint y_mult = 0; gint page = 0; gint offset = 0; gint i = 0; gint j = 0; gfloat tmpf = 0.0; guint32 id = 0; gint rows = 0; gint table_num = 0; Firmware_Details *firmware = NULL; firmware = DATA_GET(global_data,"firmware"); ecu_widgets = DATA_GET(global_data,"ecu_widgets"); main_xml = (GladeXML *)DATA_GET(global_data,"main_xml"); if (!main_xml) return FALSE; xml = glade_xml_new(main_xml->filename,"table_editor_window",NULL); window = glade_xml_get_widget(xml,"table_editor_window"); glade_xml_signal_autoconnect(xml); g_signal_connect(G_OBJECT(window),"destroy_event", G_CALLBACK(close_2d_editor),NULL); g_signal_connect(G_OBJECT(window),"delete_event", G_CALLBACK(close_2d_editor),NULL); gtk_window_set_title(GTK_WINDOW(window),_("2D Table Group Editor")); gtk_window_resize(GTK_WINDOW(window),800,530); widget = glade_xml_get_widget(xml,"2d_close_button"); g_signal_connect_swapped(G_OBJECT(widget),"clicked", G_CALLBACK(close_2d_editor),window); widget = glade_xml_get_widget(xml,"get_data_button"); OBJ_SET(widget,"handler",GINT_TO_POINTER(READ_VE_CONST)); OBJ_SET_FULL(widget,"bind_to_list",g_strdup("get_data_buttons"),g_free); bind_to_lists_f(widget,"get_data_buttons"); widget_list = g_list_prepend(widget_list,(gpointer)widget); widget = glade_xml_get_widget(xml,"burn_data_button"); OBJ_SET(widget,"handler",GINT_TO_POINTER(BURN_FLASH)); OBJ_SET_FULL(widget,"bind_to_list",g_strdup("burners"),g_free); bind_to_lists_f(widget,"burners"); widget_list = g_list_prepend(widget_list,(gpointer)widget); /* widget = glade_xml_get_widget(xml,"curve_editor_menuitem"); gtk_widget_set_sensitive(GTK_WIDGET(widget), FALSE); */ widget = glade_xml_get_widget(xml,"close_menuitem"); OBJ_SET(widget,"window",(gpointer)window); widget = glade_xml_get_widget(xml,"te_layout_hbox1"); gtk_widget_destroy(widget); widget = glade_xml_get_widget(xml,"te_layout_vbox"); tmpbuf = OBJ_GET(button,"te_tables"); vector = parse_keys_f(tmpbuf,&num_tabs,","); notebook = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook),GTK_POS_LEFT); gtk_box_pack_start(GTK_BOX(widget),notebook,TRUE,TRUE,0); for (j = 0;j < num_tabs;j++) { table_num = (gint)strtod(vector[j],NULL); if (table_num >= firmware->total_te_tables) { warn_user_f("Requested to create 2D table editor window for an undefined (out of range) table ID"); return FALSE; } if (!firmware->te_params) { warn_user_f("No 2D table Editor tables (te_tables) defined in interrogation profile, yet told to create a graph for a table... BUG detected!"); continue; } if (!firmware->te_params[table_num]) { warn_user_f("Requested to create a 2D table editor window for an undefined table!"); continue; } xml = glade_xml_new(main_xml->filename,"te_layout_hbox1",NULL); widget = glade_xml_get_widget(xml,"te_layout_hbox1"); label = gtk_label_new(firmware->te_params[table_num]->title); gtk_misc_set_alignment(GTK_MISC(label),0,0.5); if (firmware->te_params[table_num]->bind_to_list) { OBJ_SET_FULL(widget,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free); OBJ_SET(widget,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type)); bind_to_lists_f(widget,firmware->te_params[table_num]->bind_to_list); widget_list = g_list_prepend(widget_list,(gpointer)widget); OBJ_SET_FULL(label,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free); OBJ_SET(label,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type)); bind_to_lists_f(label,firmware->te_params[table_num]->bind_to_list); widget_list = g_list_prepend(widget_list,(gpointer)label); } if (firmware->te_params[table_num]->gauge || firmware->te_params[table_num]->c_gauge || firmware->te_params[table_num]->f_gauge) { parent = glade_xml_get_widget(xml,"te_gaugeframe"); gauge = mtx_gauge_face_new(); gauge_list = g_list_prepend(gauge_list,(gpointer)gauge); OBJ_SET(window,"gauge",gauge); if (firmware->te_params[table_num]->gauge_temp_dep) { if ((GINT)DATA_GET(global_data,"mtx_temp_units") == CELSIUS) tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/'); else if ((GINT)DATA_GET(global_data,"mtx_temp_units") == KELVIN) tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/'); else tmpbuf = g_strdelimit(firmware->te_params[table_num]->f_gauge,"\\",'/'); } else tmpbuf = g_strdelimit(firmware->te_params[table_num]->gauge,"\\",'/'); filename = get_file(g_strconcat(GAUGES_DATA_DIR,PSEP,tmpbuf,NULL),NULL); mtx_gauge_face_import_xml(MTX_GAUGE_FACE(gauge),filename); lookup_current_value_f(firmware->te_params[table_num]->gauge_datasource, &tmpf); mtx_gauge_face_set_value(MTX_GAUGE_FACE(gauge),tmpf); g_free(filename); id = create_rtv_value_change_watch_f(firmware->te_params[table_num]->gauge_datasource,FALSE,"update_misc_gauge",(gpointer)gauge); OBJ_SET(gauge,"gauge_id",GINT_TO_POINTER(id)); gtk_container_add(GTK_CONTAINER(parent),gauge); } gtk_notebook_append_page(GTK_NOTEBOOK(notebook),widget,label); curve_parent = glade_xml_get_widget(xml,"te_right_frame"); curve = mtx_curve_new(); curve_list = g_list_prepend(curve_list,(gpointer)curve); mtx_curve_set_title(MTX_CURVE(curve),_(firmware->te_params[table_num]->title)); mtx_curve_set_x_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->x_axis_label)); mtx_curve_set_y_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->y_axis_label)); cdata = g_new0(CurveData, 1); cdata->curve = curve; cdata->axis = _X_; cdata->source = firmware->te_params[table_num]->x_source; id = create_rtv_value_change_watch_f(cdata->source,FALSE,"update_curve_marker",(gpointer)cdata); mtx_curve_set_show_x_marker(MTX_CURVE(curve),TRUE); OBJ_SET(curve,"cdata",(gpointer)cdata); OBJ_SET(curve,"marker_id",GINT_TO_POINTER(id)); mtx_curve_set_auto_hide_vertexes(MTX_CURVE(curve),TRUE); g_signal_connect(G_OBJECT(curve),"coords-changed", G_CALLBACK(coords_changed), NULL); g_signal_connect(G_OBJECT(curve),"vertex-proximity", G_CALLBACK(vertex_proximity), NULL); g_signal_connect(G_OBJECT(curve),"marker-proximity", G_CALLBACK(marker_proximity), NULL); label = glade_xml_get_widget(xml,"x_units"); gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_units); label = glade_xml_get_widget(xml,"y_units"); gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_units); label = glade_xml_get_widget(xml,"x_title"); gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_name); label = glade_xml_get_widget(xml,"y_title"); gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_name); rows = firmware->te_params[table_num]->bincount; mtx_curve_set_empty_array(MTX_CURVE(curve),rows); x_table = gtk_table_new(rows+1,1,FALSE); y_table = gtk_table_new(rows+1,1,FALSE); x_parent = glade_xml_get_widget(xml,"te_x_frame"); y_parent = glade_xml_get_widget(xml,"te_y_frame"); gtk_container_set_border_width(GTK_CONTAINER(x_table),5); gtk_container_set_border_width(GTK_CONTAINER(y_table),5); gtk_container_add(GTK_CONTAINER(x_parent),x_table); gtk_container_add(GTK_CONTAINER(y_parent),y_table); x_mult = get_multiplier_f(firmware->te_params[table_num]->x_size); y_mult = get_multiplier_f(firmware->te_params[table_num]->y_size); x_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *)); y_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *)); for (i=0;i<rows;i++) { /* X Column */ entry = gtk_entry_new(); OBJ_SET(entry,"last_value",GINT_TO_POINTER(-G_MAXINT)); gtk_entry_set_width_chars(GTK_ENTRY(entry),7); OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i)); g_array_insert_val(x_entries,i,entry); OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_X_)); OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE)); OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC)); OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_lower)),g_free); OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_upper)),g_free); OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->x_fromecu_mult); OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->x_fromecu_add); OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->x_precision)); OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->x_size)); OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->x_page)); OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->x_temp_dep)); OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->x_use_color)); if(firmware->te_params[table_num]->x_temp_dep) { OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units")); OBJ_SET_FULL(entry,"bind_to_list", g_strdup("temperature"),g_free); bind_to_lists_f(entry,"temperature"); } offset = (i*x_mult) + firmware->te_params[table_num]->x_base; OBJ_SET(entry,"offset",GINT_TO_POINTER(offset)); g_signal_connect(G_OBJECT(entry),"changed", G_CALLBACK(update_2d_curve),curve); g_signal_connect(G_OBJECT(entry),"changed", G_CALLBACK(entry_changed_handler_f),NULL); g_signal_connect(G_OBJECT(entry),"key_press_event", G_CALLBACK(key_event_f),NULL); g_signal_connect(G_OBJECT(entry),"key_release_event", G_CALLBACK(key_event_f),NULL); g_signal_connect(G_OBJECT(entry),"focus_out_event", G_CALLBACK(focus_out_handler_f),NULL); g_signal_connect(G_OBJECT(entry),"activate", G_CALLBACK(std_entry_handler_f),NULL); if (firmware->te_params[table_num]->reversed) gtk_table_attach(GTK_TABLE(x_table),entry, 0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0); else gtk_table_attach(GTK_TABLE(x_table),entry, 0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0); page = firmware->te_params[table_num]->x_page; ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry); widget_list = g_list_prepend(widget_list,(gpointer)entry); update_widget(G_OBJECT(entry),NULL); /* Y Column */ entry = gtk_entry_new(); OBJ_SET(entry,"last_value",GINT_TO_POINTER(-G_MAXINT)); gtk_entry_set_width_chars(GTK_ENTRY(entry),7); OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i)); g_array_insert_val(y_entries,i,entry); OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_Y_)); OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE)); OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC)); OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_lower)),g_free); OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_upper)),g_free); OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->y_fromecu_mult); OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->y_fromecu_add); OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->y_precision)); OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->y_size)); OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->y_page)); OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->y_temp_dep)); OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->y_use_color)); if(firmware->te_params[table_num]->y_temp_dep) { OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units")); OBJ_SET_FULL(entry,"bind_to_list", g_strdup("temperature"),g_free); bind_to_lists_f(entry,"temperature"); } offset = (i*y_mult) + firmware->te_params[table_num]->y_base; OBJ_SET(entry,"offset",GINT_TO_POINTER(offset)); g_signal_connect(G_OBJECT(entry),"changed", G_CALLBACK(update_2d_curve),curve); g_signal_connect(G_OBJECT(entry),"changed", G_CALLBACK(entry_changed_handler_f),NULL); g_signal_connect(G_OBJECT(entry),"key_press_event", G_CALLBACK(key_event_f),NULL); g_signal_connect(G_OBJECT(entry),"key_release_event", G_CALLBACK(key_event_f),NULL); g_signal_connect(G_OBJECT(entry),"focus_out_event", G_CALLBACK(focus_out_handler_f),NULL); g_signal_connect(G_OBJECT(entry),"activate", G_CALLBACK(std_entry_handler_f),NULL); if (firmware->te_params[table_num]->reversed) gtk_table_attach(GTK_TABLE(y_table),entry, 0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0); else gtk_table_attach(GTK_TABLE(y_table),entry, 0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0); page = firmware->te_params[table_num]->y_page; ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry); widget_list = g_list_prepend(widget_list,(gpointer)entry); update_widget(G_OBJECT(entry),NULL); } /* Create the "LOCK" buttons */ dummy = gtk_toggle_button_new_with_label("Unlocked"); OBJ_SET(dummy,"axis",GINT_TO_POINTER(_X_)); g_signal_connect(G_OBJECT(dummy),"toggled", G_CALLBACK(set_axis_locking),curve); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->x_lock); gtk_table_attach(GTK_TABLE(x_table),dummy, 0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0); dummy = gtk_toggle_button_new_with_label("Unlocked"); OBJ_SET(dummy,"axis",GINT_TO_POINTER(_Y_)); g_signal_connect(G_OBJECT(dummy),"toggled", G_CALLBACK(set_axis_locking),curve); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->y_lock); gtk_table_attach(GTK_TABLE(y_table),dummy, 0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0); mtx_curve_set_x_precision(MTX_CURVE(curve),firmware->te_params[table_num]->x_precision); mtx_curve_set_y_precision(MTX_CURVE(curve),firmware->te_params[table_num]->y_precision); mtx_curve_set_hard_limits(MTX_CURVE(curve), (gfloat)firmware->te_params[table_num]->x_raw_lower, (gfloat)firmware->te_params[table_num]->x_raw_upper, (gfloat)firmware->te_params[table_num]->y_raw_lower, (gfloat)firmware->te_params[table_num]->y_raw_upper); OBJ_SET(curve,"x_entries",x_entries); OBJ_SET(curve,"y_entries",y_entries); if (firmware->te_params[table_num]->bind_to_list) g_list_foreach(get_list_f(firmware->te_params[table_num]->bind_to_list),alter_widget_state_f,NULL); create_rtv_value_change_watch_f(cdata->source,TRUE,"update_curve_marker",(gpointer)cdata); gtk_container_add(GTK_CONTAINER(curve_parent),curve); } OBJ_SET(window,"widget_list",widget_list); OBJ_SET(window,"curve_list",curve_list); OBJ_SET(window,"gauge_list",gauge_list); gtk_widget_show_all(window); return TRUE; }