/* * display the interface selection dialog */ static void gtkui_unified_sniff(void) { GList *iface_list; const char *iface_desc = NULL; char err[100]; GtkWidget *iface_combo; pcap_if_t *dev; GtkWidget *dialog, *label, *hbox, *image; DEBUG_MSG("gtk_unified_sniff"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Input", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); label = gtk_label_new ("Network interface : "); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); /* make a list of network interfaces */ iface_list = NULL; for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { iface_list = g_list_append(iface_list, dev->description); } /* make a drop down box and assign the list to it */ iface_combo = gtk_combo_new(); gtk_combo_set_popdown_strings (GTK_COMBO (iface_combo), iface_list); gtk_box_pack_start (GTK_BOX (hbox), iface_combo, FALSE, FALSE, 0); /* hitting Enter in the drop down box clicks OK */ g_object_set_data(G_OBJECT (GTK_COMBO (iface_combo)->entry), "dialog", dialog); g_signal_connect(G_OBJECT (GTK_COMBO (iface_combo)->entry), "activate", G_CALLBACK (gtkui_dialog_enter), NULL); /* list is stored in the widget, can safely free this copy */ g_list_free(iface_list); /* render the contents of the dialog */ gtk_widget_show_all (hbox); /* show the dialog itself and become interactive */ if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { iface_desc = gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (iface_combo)->entry)); for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { if(!strncmp(dev->description, iface_desc, IFACE_LEN)) { SAFE_FREE(GBL_OPTIONS->iface); SAFE_CALLOC(GBL_OPTIONS->iface, IFACE_LEN, sizeof(char)); strncpy(GBL_OPTIONS->iface, dev->name, IFACE_LEN); break; } } /* if no match in list */ if(GBL_OPTIONS->iface == NULL) { snprintf(err, 100, "Invalid interface: %s", iface_desc); gtkui_error(err); gtk_widget_destroy(dialog); return; } /* exit setup iterface */ gtk_widget_destroy(dialog); gtk_main_quit(); return; } gtk_widget_destroy(dialog); }
static void preview_diffuse_only(gint32 image_ID) { gint32 noiselayer_ID = -1; gint32 drawable_ID = -1; gint32 drawableDiffuse_ID = -1; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.0); gtk_label_set_text(GTK_LABEL(progress_label), "Begin"); drawableBeginActiveLayer = gimp_image_get_active_layer(image_ID); drawable_ID = gimp_layer_copy (drawableBeginActiveLayer); gimp_image_add_layer(image_ID, drawable_ID, -1); gimp_image_set_active_layer(image_ID, drawable_ID); /** Here I should hide previous active layer, make not visible. */ gimp_drawable_set_visible(drawableBeginActiveLayer, FALSE); /** * For preview do nothing here. * if(local_vals.Resizie) * { * } */ if (local_vals.Noise) { /** Already have active layer in drawable_ID. */ noiselayer_ID = gimp_layer_copy (drawable_ID); gimp_image_add_layer(image_ID, noiselayer_ID, -1); gimp_image_set_active_layer(image_ID, noiselayer_ID); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.03); gtk_label_set_text(GTK_LABEL(progress_label), "Noise"); /** * Filter "RGB Noise" applied * Standard plug-in. Source code ships with GIMP. * * Add the "f" here to signify float in c language. */ if (plug_in_rgb_noise_connector(image_ID, noiselayer_ID, 1, 1, 0.20f, 0.20f, 0.20f, 0.0f) != 1) return; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.04); gimp_layer_set_mode(noiselayer_ID, GIMP_VALUE_MODE); gimp_image_merge_down(image_ID, noiselayer_ID, 0); gtk_label_set_text(GTK_LABEL(gwNormalLabel), "Noise affects every redraw!"); } else { gtk_label_set_text(GTK_LABEL(gwNormalLabel), ""); gtk_label_set_text(GTK_LABEL(progress_label), "Noise added"); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.04); } if(local_vals.RemoveLighting) { gtk_label_set_text(GTK_LABEL(progress_label), "Remove Shading"); removeShadingPreview(image_ID, local_vals.Noise); /** * See notes inside of removeShadingPreview * for explanation of next line. */ /** * If Noise is on, then noiselayer_ID was merged down into drawable_ID. * You cannot remove drawable_ID in this case, as it is the only * layer left! * * However, if Noise is Yes and RemoveLighting is Yes, * Then there is an extra layer floating around! * Delete noiselayer_ID? I thought it was merged! * No, I was right noiselayer_ID is already gone! */ gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.05); } else { gtk_label_set_text(GTK_LABEL(progress_label), "Stretch"); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.05); } drawableDiffuse_ID = gimp_image_get_active_layer(image_ID); gimp_levels_stretch(drawableDiffuse_ID); if(local_vals.Tile) { gtk_label_set_text(GTK_LABEL(progress_label), "Making Seamless"); /** * Filter "Tile Seamless" applied * Standard plug-in. Source code ships with GIMP. */ if (plug_in_make_seamless_connector(image_ID, drawableDiffuse_ID) != 1) return; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.07); } else { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.07); } /** Here I should un hide previously hidden layer, make visible. */ pDrawables.drawable_d = gimp_drawable_get(drawableDiffuse_ID); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.1); }
static void signal_handler(DBusGProxy *obj, const char *msg, GtkWidget *widget) { gtk_label_set_markup(GTK_LABEL(widget), msg); }
GtkWidget * do_images (GtkWidget *do_widget) { GtkWidget *frame; GtkWidget *vbox; GtkWidget *image; GtkWidget *label; GtkWidget *align; GtkWidget *button; GdkPixbuf *pixbuf; GError *error = NULL; char *filename; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Images"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); g_signal_connect (window, "destroy", G_CALLBACK (cleanup_callback), NULL); gtk_container_set_border_width (GTK_CONTAINER (window), 8); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Image loaded from a file</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); /* The alignment keeps the frame from growing when users resize * the window */ align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER (align), frame); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0); /* demo_find_file() looks in the the current directory first, * so you can run gtk-demo without installing GTK, then looks * in the location where the file is installed. */ pixbuf = NULL; filename = demo_find_file ("gtk-logo-rgb.gif", &error); if (filename) { pixbuf = gdk_pixbuf_new_from_file (filename, &error); g_free (filename); } if (error) { /* This code shows off error handling. You can just use * gtk_image_new_from_file() instead if you don't want to report * errors to the user. If the file doesn't load when using * gtk_image_new_from_file(), a "missing image" icon will * be displayed instead. */ GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Unable to open image file 'gtk-logo-rgb.gif': %s", error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (dialog); } image = gtk_image_new_from_pixbuf (pixbuf); gtk_container_add (GTK_CONTAINER (frame), image); /* Animation */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Animation loaded from a file</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); /* The alignment keeps the frame from growing when users resize * the window */ align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER (align), frame); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0); filename = demo_find_file ("floppybuddy.gif", NULL); image = gtk_image_new_from_file (filename); g_free (filename); gtk_container_add (GTK_CONTAINER (frame), image); /* Progressive */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Progressive image loading</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); /* The alignment keeps the frame from growing when users resize * the window */ align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER (align), frame); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0); /* Create an empty image for now; the progressive loader * will create the pixbuf and fill it in. */ image = gtk_image_new_from_pixbuf (NULL); gtk_container_add (GTK_CONTAINER (frame), image); start_progressive_loading (image); /* Sensitivity control */ button = gtk_toggle_button_new_with_mnemonic ("_Insensitive"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "toggled", G_CALLBACK (toggle_sensitivity_callback), vbox); } if (!GTK_WIDGET_VISIBLE (window)) { gtk_widget_show_all (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
static int passphrase_dialog(char *message) { const char *failed; char *passphrase, *local; char **messages; int result, i, grab_server, grab_pointer; GtkWidget *dialog, *entry, *label; GdkGrabStatus status; grab_server = (getenv("GNOME_SSH_ASKPASS_GRAB_SERVER") != NULL); grab_pointer = (getenv("GNOME_SSH_ASKPASS_GRAB_POINTER") != NULL); dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL, "%s", message); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), entry, FALSE, FALSE, 0); gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); gtk_widget_grab_focus(entry); gtk_widget_show(entry); gtk_window_set_title(GTK_WINDOW(dialog), "OpenSSH"); gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); gtk_label_set_line_wrap(GTK_LABEL((GTK_MESSAGE_DIALOG(dialog))->label), TRUE); /* Make <enter> close dialog */ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(ok_dialog), dialog); /* Grab focus */ gtk_widget_show_now(dialog); if (grab_server) { gdk_x11_grab_server(); } if (grab_pointer) { status = gdk_pointer_grab((GTK_WIDGET(dialog))->window, TRUE, 0, NULL, NULL, GDK_CURRENT_TIME); if (status != GDK_GRAB_SUCCESS) { failed = "mouse"; goto nograb; } } status = gdk_keyboard_grab((GTK_WIDGET(dialog))->window, FALSE, GDK_CURRENT_TIME); if (status != GDK_GRAB_SUCCESS) { failed = "keyboard"; goto nograbkb; } result = gtk_dialog_run(GTK_DIALOG(dialog)); /* Ungrab */ if (grab_server) XUngrabServer(GDK_DISPLAY()); if (grab_pointer) gdk_pointer_ungrab(GDK_CURRENT_TIME); gdk_keyboard_ungrab(GDK_CURRENT_TIME); gdk_flush(); /* Report passphrase if user selected OK */ passphrase = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry))); if (result == GTK_RESPONSE_OK) { local = g_locale_from_utf8(passphrase, strlen(passphrase), NULL, NULL, NULL); if (local != NULL) { puts(local); memset(local, '\0', strlen(local)); g_free(local); } else { puts(passphrase); } } /* Zero passphrase in memory */ memset(passphrase, '\b', strlen(passphrase)); gtk_entry_set_text(GTK_ENTRY(entry), passphrase); memset(passphrase, '\0', strlen(passphrase)); g_free(passphrase); gtk_widget_destroy(dialog); return (result == GTK_RESPONSE_OK ? 0 : -1); /* At least one grab failed - ungrab what we got, and report the failure to the user. Note that XGrabServer() cannot fail. */ nograbkb: gdk_pointer_ungrab(GDK_CURRENT_TIME); nograb: if (grab_server) XUngrabServer(GDK_DISPLAY()); gtk_widget_destroy(dialog); report_failed_grab(failed); return (-1); }
static void add_address_row (CEPageIP6 *page, const gchar *address, const gchar *network, const gchar *gateway) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *label; GtkWidget *widget; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_widget_set_halign (label, GTK_ALIGN_END); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Prefix")); gtk_widget_set_halign (label, GTK_ALIGN_END); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "prefix", widget); gtk_entry_set_text (GTK_ENTRY (widget), network); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_widget_set_halign (label, GTK_ALIGN_END); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Address")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 2, 1, 1); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_start (row_grid, 10); gtk_widget_set_margin_end (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->address_list), row); update_row_sensitivity (page, page->address_list); }
/* construct widget above */ void gui_init(struct dt_imageio_module_storage_t *self) { self->gui_data = g_malloc0(sizeof(dt_storage_facebook_gui_data_t)); dt_storage_facebook_gui_data_t *ui = self->gui_data; ui->facebook_api = fb_api_init(); self->widget = gtk_vbox_new(FALSE, 0); //create labels ui->label_album_title = GTK_LABEL( gtk_label_new( _("title") ) ); ui->label_album_summary = GTK_LABEL( gtk_label_new( _("summary") ) ); ui->label_album_privacy = GTK_LABEL(gtk_label_new(_("privacy"))); ui->label_status = GTK_LABEL(gtk_label_new(NULL)); gtk_misc_set_alignment(GTK_MISC(ui->label_album_title), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label_album_summary), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label_album_privacy), 0.0, 0.5); //create entries GtkListStore *model_username = gtk_list_store_new (COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); //text, token, id ui->comboBox_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username))); GtkCellRenderer *p_cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, "text", 0, NULL); ui->entry_album_title = GTK_ENTRY(gtk_entry_new()); ui->entry_album_summary = GTK_ENTRY(gtk_entry_new()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->comboBox_username)); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title)); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_summary)); //retrieve saved accounts ui_refresh_users(ui); //////// album list ///////// GtkWidget *albumlist = gtk_hbox_new(FALSE, 0); GtkListStore *model_album = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); //name, id ui->comboBox_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album))); p_cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, "text", 0, NULL); gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE); gtk_combo_box_set_row_separator_func(ui->comboBox_album,combobox_separator,ui->comboBox_album,NULL); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox_album), TRUE, TRUE, 0); ui->comboBox_privacy= GTK_COMBO_BOX(gtk_combo_box_text_new()); GtkListStore *list_store = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_INT); GtkTreeIter iter; gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("only me"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_SELF, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_ALL_FRIENDS, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("public"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_EVERYONE, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends of friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS, -1); gtk_combo_box_set_model(ui->comboBox_privacy, GTK_TREE_MODEL(list_store)); gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox_privacy), 1); // Set default permission to private ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login"))); ui->connected = FALSE; //pack the ui ////the auth box GtkWidget *hbox_auth = gtk_hbox_new(FALSE,5); GtkWidget *vbox_auth_labels=gtk_vbox_new(FALSE,0); GtkWidget *vbox_auth_fields=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->comboBox_username), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2); ////the album creation box ui->hbox_album = GTK_BOX(gtk_hbox_new(FALSE,5)); gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); //hide it by default GtkWidget *vbox_album_labels=gtk_vbox_new(FALSE,0); GtkWidget *vbox_album_fields=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_summary), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_summary), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_privacy), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->comboBox_privacy), TRUE, FALSE, 0); //connect buttons to signals g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox_username), "changed", G_CALLBACK(ui_combo_username_changed), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui); g_object_unref(model_username); g_object_unref(model_album); g_object_unref(list_store); }
GtkWidget *pref_start_gui(){ GtkWidget *vbox; GtkWidget *hbox; GtkWidget *table; GtkWidget *label; GtkObject *adj; GtkAttachOptions xoption, yoption; LOG(LOG_DEBUG, "IN : pref_start_gui()"); vbox = gtk_vbox_new(FALSE, 0); gtk_widget_set_size_request(vbox, 300, 200); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); xoption = GTK_SHRINK|GTK_FILL; yoption = GTK_SHRINK; table = gtk_table_new(2, 12, FALSE); gtk_box_pack_start (GTK_BOX(vbox) , table,FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE,10); gtk_container_set_border_width(GTK_CONTAINER(hbox), 2); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 0, 1, xoption, yoption, 10, 10); label = gtk_label_new(_("Maximum words in history")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); adj = gtk_adjustment_new( 10, //value 0, // lower 20, //upper 1, // step increment 10,// page_increment, (gfloat)0.0); spin_words = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_words), max_remember_words ); gtk_widget_set_size_request(spin_words,60,20); gtk_table_attach(GTK_TABLE(table), spin_words, 1, 2, 0, 1, xoption, yoption, 10, 10); gtk_widget_set_tooltip_text(spin_words, _("Maximum number of words to remember in word history")); hbox = gtk_hbox_new(FALSE,10); gtk_container_set_border_width(GTK_CONTAINER(hbox), 2); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 1, 2, xoption, yoption, 10, 10); label = gtk_label_new(_("Chars in dictionary bar")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); adj = gtk_adjustment_new( 10, //value 1, // lower 32, //upper 1, // step increment 1,// page_increment, 0.0); spin_dict_label = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_dict_label), dict_button_length ); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(spin_dict_label), TRUE); gtk_widget_set_size_request(spin_dict_label,60,20); gtk_table_attach(GTK_TABLE(table), spin_dict_label, 1, 2, 1, 2, xoption, yoption, 10, 10); gtk_widget_set_tooltip_text(spin_dict_label, _("Specify the number of characters to display on top of each toggle buttons in dictionary bar.")); check_splash = gtk_check_button_new_with_label(_("Show splash screen")); gtk_widget_set_tooltip_text(check_splash, _("Show splash screen on loading.")); gtk_table_attach(GTK_TABLE(table), check_splash, 0, 1, 5, 6, xoption, yoption, 10, 10); // gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_splash), bshow_splash); check_heading_auto = gtk_check_button_new_with_label(_("Calculate heading automatically")); gtk_widget_set_tooltip_text(check_heading_auto, _("Calculate the number of cells in heading list to suit the window size.")); gtk_table_attach(GTK_TABLE(table), check_heading_auto, 0, 1, 6, 7, xoption, yoption, 10, 10); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_heading_auto), bheading_auto_calc); // hbox = gtk_hbox_new(FALSE,10); gtk_container_set_border_width(GTK_CONTAINER(hbox), 2); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 7, 8, xoption, yoption, 10, 10); label = gtk_label_new(_("Maximum hits to display")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); adj = gtk_adjustment_new( 100, //value 1, // lower 1000, //upper 1, // step increment 10,// page_increment, 0.0); spin_max_heading = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_max_heading), max_heading ); gtk_widget_set_size_request(spin_max_heading,60,20); gtk_table_attach(GTK_TABLE(table), spin_max_heading, 1, 2, 7, 8, xoption, yoption, 10, 10); gtk_widget_set_tooltip_text(spin_max_heading, _("Maximum number of hits to be displayed at once.\nYou can go forward and backward using buttons. Valid only if automatic calculation is disabled.")); // check_button_color = gtk_check_button_new_with_label(_("Enable dictionary button color")); gtk_widget_set_tooltip_text(check_button_color, _("Enable background color of dictionary button.")); gtk_table_attach(GTK_TABLE(table), check_button_color, 0, 1, 8, 9, xoption, yoption, 10, 10); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_color), benable_button_color); LOG(LOG_DEBUG, "OUT : pref_start_gui()"); return(vbox); }
void dt_iop_gui_init_blendif(GtkVBox *blendw, dt_iop_module_t *module) { dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t*)module->blend_data; /* create and add blendif support if module supports it */ if (bd->blendif_support) { char *Lab_labels[] = { " L ", " a ", " b ", " C ", " h " }; char *Lab_tooltips[] = { _("sliders for L channel"), _("sliders for a channel"), _("sliders for b channel"), _("sliders for chroma channel (of LCh)"), _("sliders for hue channel (of LCh)") }; char *rgb_labels[] = { _(" g "), _(" R "), _(" G "), _(" B "), _(" H "), _(" S "), _(" L ") }; char *rgb_tooltips[] = { _("sliders for gray value"), _("sliders for red channel"), _("sliders for green channel"), _("sliders for blue channel"), _("sliders for hue channel (of HSL)"), _("sliders for chroma channel (of HSL)"), _("sliders for value channel (of HSL)") }; char *ttinput = _("adjustment based on input received by this module:\n* range defined by upper markers: blend fully\n* range defined by lower markers: do not blend at all\n* range between adjacent upper/lower markers: blend gradually"); char *ttoutput = _("adjustment based on unblended output of this module:\n* range defined by upper markers: blend fully\n* range defined by lower markers: do not blend at all\n* range between adjacent upper/lower markers: blend gradually"); bd->tab = 0; int maxchannels = 0; char **labels = NULL; char **tooltips = NULL; switch(bd->csp) { case iop_cs_Lab: maxchannels = 5; labels = Lab_labels; tooltips = Lab_tooltips; bd->scale_print[0] = _blendif_scale_print_L; bd->scale_print[1] = _blendif_scale_print_ab; bd->scale_print[2] = _blendif_scale_print_ab; bd->scale_print[3] = _blendif_scale_print_default; bd->scale_print[4] = _blendif_scale_print_hue; bd->increments[0] = 1.0f/100.0f; bd->increments[1] = 1.0f/256.0f; bd->increments[2] = 1.0f/256.0f; bd->increments[3] = 1.0f/100.0f; bd->increments[4] = 1.0f/360.0f; bd->channels[0][0] = DEVELOP_BLENDIF_L_in; bd->channels[0][1] = DEVELOP_BLENDIF_L_out; bd->channels[1][0] = DEVELOP_BLENDIF_A_in; bd->channels[1][1] = DEVELOP_BLENDIF_A_out; bd->channels[2][0] = DEVELOP_BLENDIF_B_in; bd->channels[2][1] = DEVELOP_BLENDIF_B_out; bd->channels[3][0] = DEVELOP_BLENDIF_C_in; bd->channels[3][1] = DEVELOP_BLENDIF_C_out; bd->channels[4][0] = DEVELOP_BLENDIF_h_in; bd->channels[4][1] = DEVELOP_BLENDIF_h_out; bd->colorstops[0] = _gradient_L; bd->numberstops[0] = sizeof(_gradient_L)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[1] = _gradient_a; bd->numberstops[1] = sizeof(_gradient_a)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[2] = _gradient_b; bd->numberstops[2] = sizeof(_gradient_b)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[3] = _gradient_chroma; bd->numberstops[3] = sizeof(_gradient_chroma)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[4] = _gradient_hue; bd->numberstops[4] = sizeof(_gradient_hue)/sizeof(dt_iop_gui_blendif_colorstop_t); break; case iop_cs_rgb: maxchannels = 7; labels = rgb_labels; tooltips = rgb_tooltips; bd->scale_print[0] = _blendif_scale_print_rgb; bd->scale_print[1] = _blendif_scale_print_rgb; bd->scale_print[2] = _blendif_scale_print_rgb; bd->scale_print[3] = _blendif_scale_print_rgb; bd->scale_print[4] = _blendif_scale_print_hue; bd->scale_print[5] = _blendif_scale_print_default; bd->scale_print[6] = _blendif_scale_print_L; bd->increments[0] = 1.0f/255.0f; bd->increments[1] = 1.0f/255.0f; bd->increments[2] = 1.0f/255.0f; bd->increments[3] = 1.0f/255.0f; bd->increments[4] = 1.0f/360.0f; bd->increments[5] = 1.0f/100.0f; bd->increments[6] = 1.0f/100.0f; bd->channels[0][0] = DEVELOP_BLENDIF_GRAY_in; bd->channels[0][1] = DEVELOP_BLENDIF_GRAY_out; bd->channels[1][0] = DEVELOP_BLENDIF_RED_in; bd->channels[1][1] = DEVELOP_BLENDIF_RED_out; bd->channels[2][0] = DEVELOP_BLENDIF_GREEN_in; bd->channels[2][1] = DEVELOP_BLENDIF_GREEN_out; bd->channels[3][0] = DEVELOP_BLENDIF_BLUE_in; bd->channels[3][1] = DEVELOP_BLENDIF_BLUE_out; bd->channels[4][0] = DEVELOP_BLENDIF_H_in; bd->channels[4][1] = DEVELOP_BLENDIF_H_out; bd->channels[5][0] = DEVELOP_BLENDIF_S_in; bd->channels[5][1] = DEVELOP_BLENDIF_S_out; bd->channels[6][0] = DEVELOP_BLENDIF_l_in; bd->channels[6][1] = DEVELOP_BLENDIF_l_out; bd->colorstops[0] = _gradient_gray; bd->numberstops[0] = sizeof(_gradient_gray)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[1] = _gradient_red; bd->numberstops[1] = sizeof(_gradient_red)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[2] = _gradient_green; bd->numberstops[2] = sizeof(_gradient_green)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[3] = _gradient_blue; bd->numberstops[3] = sizeof(_gradient_blue)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[4] = _gradient_HUE; bd->numberstops[4] = sizeof(_gradient_HUE)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[5] = _gradient_chroma; bd->numberstops[5] = sizeof(_gradient_chroma)/sizeof(dt_iop_gui_blendif_colorstop_t); bd->colorstops[6] = _gradient_gray; bd->numberstops[6] = sizeof(_gradient_gray)/sizeof(dt_iop_gui_blendif_colorstop_t); break; default: assert(FALSE); // blendif not supported for RAW, which is already catched upstream; we should not get here } bd->blendif_box = GTK_VBOX(gtk_vbox_new(FALSE,DT_GUI_IOP_MODULE_CONTROL_SPACING)); GtkWidget *uplabel = gtk_hbox_new(FALSE,0); GtkWidget *lowlabel = gtk_hbox_new(FALSE,0); GtkWidget *upslider = gtk_hbox_new(FALSE,0); GtkWidget *lowslider = gtk_hbox_new(FALSE,0); GtkWidget *notebook = gtk_vbox_new(FALSE,0); GtkWidget *header = gtk_hbox_new(FALSE, 0); bd->blendif_enable = dt_bauhaus_combobox_new(module); dt_bauhaus_widget_set_label(bd->blendif_enable, _("blend")); dt_bauhaus_combobox_add(bd->blendif_enable, _("uniformly")); dt_bauhaus_combobox_add(bd->blendif_enable, _("only, if..")); bd->channel_tabs = GTK_NOTEBOOK(gtk_notebook_new()); for(int ch=0; ch<maxchannels; ch++) { gtk_notebook_append_page(GTK_NOTEBOOK(bd->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(labels[ch])); g_object_set(G_OBJECT(gtk_notebook_get_tab_label(bd->channel_tabs, gtk_notebook_get_nth_page(bd->channel_tabs, -1))), "tooltip-text", tooltips[ch], NULL); } gtk_widget_show_all(GTK_WIDGET(gtk_notebook_get_nth_page(bd->channel_tabs, bd->tab))); gtk_notebook_set_current_page(GTK_NOTEBOOK(bd->channel_tabs), bd->tab); g_object_set(G_OBJECT(bd->channel_tabs), "homogeneous", TRUE, (char *)NULL); gtk_notebook_set_scrollable(bd->channel_tabs, TRUE); gtk_box_pack_start(GTK_BOX(notebook), GTK_WIDGET(bd->channel_tabs), FALSE, FALSE, 0); GtkWidget *tb = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); g_object_set(G_OBJECT(tb), "tooltip-text", _("pick gui color from image"), (char *)NULL); GtkWidget *sm = dtgtk_togglebutton_new(dtgtk_cairo_paint_showmask, CPF_STYLE_FLAT); g_object_set(G_OBJECT(sm), "tooltip-text", _("display mask"), (char *)NULL); GtkWidget *res = dtgtk_button_new(dtgtk_cairo_paint_reset, CPF_STYLE_FLAT); g_object_set(G_OBJECT(res), "tooltip-text", _("reset blend mask settings"), (char *)NULL); GtkWidget *sup = dtgtk_togglebutton_new(dtgtk_cairo_paint_eye_toggle, CPF_STYLE_FLAT); g_object_set(G_OBJECT(sup), "tooltip-text", _("temporarily switch off blend mask. only for module in focus."), (char *)NULL); gtk_box_pack_start(GTK_BOX(header), GTK_WIDGET(notebook), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(header), GTK_WIDGET(res), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(header), GTK_WIDGET(tb), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(header), GTK_WIDGET(sm), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(header), GTK_WIDGET(sup), FALSE, FALSE, 0); bd->lower_slider = DTGTK_GRADIENT_SLIDER_MULTIVALUE(dtgtk_gradient_slider_multivalue_new(4)); bd->upper_slider = DTGTK_GRADIENT_SLIDER_MULTIVALUE(dtgtk_gradient_slider_multivalue_new(4)); bd->lower_polarity = dtgtk_togglebutton_new(dtgtk_cairo_paint_plusminus, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER); g_object_set(G_OBJECT(bd->lower_polarity), "tooltip-text", _("toggle polarity. best seen by enabling 'display mask'"), (char *)NULL); bd->upper_polarity = dtgtk_togglebutton_new(dtgtk_cairo_paint_plusminus, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER); g_object_set(G_OBJECT(bd->upper_polarity), "tooltip-text", _("toggle polarity. best seen by enabling 'display mask'"), (char *)NULL); gtk_box_pack_start(GTK_BOX(upslider), GTK_WIDGET(bd->upper_slider), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(upslider), GTK_WIDGET(bd->upper_polarity), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(lowslider), GTK_WIDGET(bd->lower_slider), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(lowslider), GTK_WIDGET(bd->lower_polarity), FALSE, FALSE, 0); GtkWidget *output = gtk_label_new(_("output")); bd->upper_picker_label = GTK_LABEL(gtk_label_new("")); gtk_box_pack_start(GTK_BOX(uplabel), GTK_WIDGET(output), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(uplabel), GTK_WIDGET(bd->upper_picker_label), TRUE, TRUE, 0); for(int k=0; k < 4 ; k++) { bd->upper_label[k] = GTK_LABEL(gtk_label_new(NULL)); gtk_label_set_width_chars(bd->upper_label[k], 6); gtk_box_pack_start(GTK_BOX(uplabel), GTK_WIDGET(bd->upper_label[k]), FALSE, FALSE, 0); } GtkWidget *input = gtk_label_new(_("input")); bd->lower_picker_label = GTK_LABEL(gtk_label_new("")); gtk_box_pack_start(GTK_BOX(lowlabel), GTK_WIDGET(input), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(lowlabel), GTK_WIDGET(bd->lower_picker_label), TRUE, TRUE, 0); for(int k=0; k < 4 ; k++) { bd->lower_label[k] = GTK_LABEL(gtk_label_new(NULL)); gtk_label_set_width_chars(bd->lower_label[k], 6); gtk_box_pack_start(GTK_BOX(lowlabel), GTK_WIDGET(bd->lower_label[k]), FALSE, FALSE, 0); } bd->radius_slider = dt_bauhaus_slider_new_with_range(module, 0.0, 50.0, 0.1, 0.0, 1); dt_bauhaus_widget_set_label(bd->radius_slider, _("mask blur")); dt_bauhaus_slider_set_format(bd->radius_slider, "%.1f"); gtk_object_set(GTK_OBJECT(bd->blendif_enable), "tooltip-text", _("enable conditional blending"), (char *)NULL); gtk_object_set(GTK_OBJECT(bd->lower_slider), "tooltip-text", _("double click to reset"), (char *)NULL); gtk_object_set(GTK_OBJECT(bd->upper_slider), "tooltip-text", _("double click to reset"), (char *)NULL); gtk_object_set(GTK_OBJECT(output), "tooltip-text", ttoutput, (char *)NULL); gtk_object_set(GTK_OBJECT(input), "tooltip-text", ttinput, (char *)NULL); gtk_object_set(GTK_OBJECT(bd->radius_slider), "tooltip-text", _("radius for gaussian blur of blend mask"), (char *)NULL); g_signal_connect (G_OBJECT (bd->lower_slider), "expose-event", G_CALLBACK (_blendop_blendif_expose), module); g_signal_connect (G_OBJECT (bd->upper_slider), "expose-event", G_CALLBACK (_blendop_blendif_expose), module); g_signal_connect (G_OBJECT (bd->blendif_enable), "value-changed", G_CALLBACK (_blendop_blendif_callback), bd); g_signal_connect(G_OBJECT (bd->channel_tabs), "switch_page", G_CALLBACK (_blendop_blendif_tab_switch), bd); g_signal_connect (G_OBJECT (bd->upper_slider), "value-changed", G_CALLBACK (_blendop_blendif_upper_callback), bd); g_signal_connect (G_OBJECT (bd->radius_slider), "value-changed", G_CALLBACK (_blendop_blendif_radius_callback), bd); g_signal_connect (G_OBJECT (bd->lower_slider), "value-changed", G_CALLBACK (_blendop_blendif_lower_callback), bd); g_signal_connect (G_OBJECT(tb), "toggled", G_CALLBACK (_blendop_blendif_pick_toggled), module); g_signal_connect (G_OBJECT(sm), "toggled", G_CALLBACK (_blendop_blendif_showmask_toggled), module); g_signal_connect (G_OBJECT(res), "clicked", G_CALLBACK (_blendop_blendif_reset), module); g_signal_connect (G_OBJECT(sup), "toggled", G_CALLBACK (_blendop_blendif_suppress_toggled), module); g_signal_connect (G_OBJECT(bd->lower_polarity), "toggled", G_CALLBACK (_blendop_blendif_polarity_callback), bd); g_signal_connect (G_OBJECT(bd->upper_polarity), "toggled", G_CALLBACK (_blendop_blendif_polarity_callback), bd); gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(header), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(uplabel), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(upslider), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(lowlabel), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(lowslider), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(bd->radius_slider), TRUE, FALSE, 0); gtk_box_pack_end(GTK_BOX(blendw), GTK_WIDGET(bd->blendif_box),TRUE,TRUE,0); gtk_box_pack_end(GTK_BOX(blendw), GTK_WIDGET(bd->blendif_enable),TRUE,TRUE,0); } }
void pp_cms_refresh(pp_CMS *ob) { Debug[TRACE] << "In pp_cms_refresh" << endl; int pa=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ob->printeractive)); int ga=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ob->greyactive)); int ra=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ob->rgbactive)); int ca=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ob->cmykactive)); int ma=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ob->monitoractive)); gtk_widget_set_sensitive(ob->printerprof,pa); gtk_widget_set_sensitive(ob->intent,pa); gtk_widget_set_sensitive(ob->displaymode,ma); gtk_widget_set_sensitive(ob->colourspace,!pa); gtk_widget_set_sensitive(ob->greyprof,ga); gtk_widget_set_sensitive(ob->rgbprof,ra); gtk_widget_set_sensitive(ob->cmykprof,ca); gtk_widget_set_sensitive(ob->monitorprof,ma); IS_TYPE colourspace=simplecombo_get_index(SIMPLECOMBO(ob->colourspace)) ? IS_TYPE_CMYK : IS_TYPE_RGB; IS_TYPE dlcolourspace=colourspace; bool isdevicelink=false; Debug[TRACE] << "Getting profiles from widgets..." << endl; // Get colourspace from printer profile, if set. if(pa) { Debug[TRACE] << "Getting printer profile..." << endl; CMSProfile *p=ob->pm->GetProfile(profileselector_get_filename(PROFILESELECTOR(ob->printerprof))); if(p) { Debug[TRACE] << "Got printer profile..." << endl; colourspace=p->GetColourSpace(); if((isdevicelink=p->IsDeviceLink())) { dlcolourspace=colourspace; colourspace=p->GetDeviceLinkOutputSpace(); } delete p; } else { Debug[TRACE] << "Couldn't get printer profile..." << endl; pa=false; } } // Check RGB profile... if(ga) { CMSProfile *p=ob->pm->GetProfile(profileselector_get_filename(PROFILESELECTOR(ob->greyprof))); if(p) delete p; else ga=false; } // Check RGB profile... if(ra) { CMSProfile *p=ob->pm->GetProfile(profileselector_get_filename(PROFILESELECTOR(ob->rgbprof))); if(p) delete p; else ra=false; } // Check CMYK profile... if(ra) { CMSProfile *p=ob->pm->GetProfile(profileselector_get_filename(PROFILESELECTOR(ob->cmykprof))); if(p) delete p; else ca=false; } // Check Monitor profile... if(ra) { CMSProfile *p=ob->pm->GetProfile(profileselector_get_filename(PROFILESELECTOR(ob->monitorprof))); if(p) delete p; else ma=false; } Debug[TRACE] << "Got colourspace: " << colourspace << endl; const gchar *rgbok=GTK_STOCK_NO; const char *rgbstatus=""; // Work out implications of current settings for RGB images if(isdevicelink) // implies printer active... { if(dlcolourspace==IS_TYPE_CMYK) { if(ca && ra) // do we have both RGB and CMYK default profiles { // Devicelink with CMYK input, CMYK profile available rgbok=GTK_STOCK_DIALOG_WARNING; rgbstatus=_("Printer profile is a devicelink with CMYK input - RGB images\nwill first be converted to the default CMYK profile"); } else if(ra) { // Devicelink with CMYK input, no CMYK profile available rgbok=GTK_STOCK_NO; rgbstatus=_("Printer profile is a devicelink with CMYK input - RGB images\ncannot be printed without a default CMYK profile."); } else { // Devicelink with CMYK input, no RGB or CMYK profile available rgbok=GTK_STOCK_NO; rgbstatus=_("Printer profile is a devicelink with CMYK input - RGB images\ncannot be printed without a default RGB and CMYK profile."); // Exception: input RGB files with embedded profiles - but explaining that would be complicated. } } else if(ra) { // Devicelink with RGB input rgbok=GTK_STOCK_DIALOG_WARNING; rgbstatus=_("Printer profile is a devicelink - RGB images with embedded profiles\nwill first be converted to the default RGB profile."); } else { // Devicelink with RGB input rgbok=GTK_STOCK_DIALOG_WARNING; rgbstatus=_("Printer profile is a devicelink - RGB images with embedded profiles will not\nprint correctly, since there is no default RGB profile."); } } else if(pa && ra) { rgbok=GTK_STOCK_YES; rgbstatus=_("RGB images will print correctly"); } else if(pa && colourspace==IS_TYPE_RGB) { rgbok=GTK_STOCK_DIALOG_WARNING; rgbstatus=_("RGB images can be printed but colours depend on the driver\n(Colours will be accurate for images that contain an embedded profile)"); } else if(colourspace==IS_TYPE_RGB) { rgbok=GTK_STOCK_DIALOG_WARNING; rgbstatus=_("RGB images can be printed but colours depend on the driver"); } else if(pa && colourspace==IS_TYPE_CMYK) { rgbok=GTK_STOCK_DIALOG_WARNING; rgbstatus=_("RGB images can only be printed if they have an embedded profile\n(Workflow is CMYK and there is no default RGB profile)"); } else if(colourspace==IS_TYPE_CMYK) { rgbok=GTK_STOCK_NO; rgbstatus=_("RGB images cannot be printed\n(Workflow is CMYK and there is no printer profile)"); } const gchar *cmykok=GTK_STOCK_NO; const char *cmykstatus=""; // Work out implications of current settings for CMYK images... if(isdevicelink) { if(dlcolourspace==IS_TYPE_RGB) { if(ra && ca) { // Devicelink with RGB input, CMYK profile available cmykok=GTK_STOCK_DIALOG_WARNING; cmykstatus=_("Printer profile is a devicelink with RGB input - CMYK images\nwill first be converted to the default RGB profile"); } else if(ca) { // Devicelink with RGB input, no CMYK profile available cmykok=GTK_STOCK_NO; cmykstatus=_("Printer profile is a devicelink with RGB input - CMYK images\ncannot be printed without a default RGB profile."); } else { // Devicelink with RGB input, no RGB or CMYK profile available cmykok=GTK_STOCK_NO; cmykstatus=_("Printer profile is a devicelink with RGB input - CMYK images\ncannot be printed without a default RGB and CMYK profile."); } } else if(ca) { // Devicelink with CMYK input cmykok=GTK_STOCK_DIALOG_WARNING; cmykstatus=_("Printer profile is a devicelink - CMYK images with embedded profiles\nwill first be converted to the default CMYK profile."); } else { // Devicelink with CMYK input cmykok=GTK_STOCK_DIALOG_WARNING; cmykstatus=_("Printer profile is a devicelink - CMYK images with embedded profiles will not\nprint correctly since there is no default CMYK profile."); } } else if(pa && ca) { cmykok=GTK_STOCK_YES; cmykstatus=_("CMYK images will print correctly"); } else if(pa && colourspace==IS_TYPE_CMYK) { cmykok=GTK_STOCK_DIALOG_WARNING; cmykstatus=_("CMYK images can be printed but colours depend on the driver\n(Colours will be accurate for images that contain an embedded profile)"); } else if(colourspace==IS_TYPE_CMYK) { cmykok=GTK_STOCK_DIALOG_WARNING; cmykstatus=_("CMYK images can be printed but colours depend on the driver"); } else if(pa && colourspace==IS_TYPE_RGB) { cmykok=GTK_STOCK_DIALOG_WARNING; cmykstatus=_("CMYK images can only be printed if they have an embedded profile\n(Workflow is RGB and there is no default CMYK profile)"); } else if(colourspace==IS_TYPE_RGB) { cmykok=GTK_STOCK_NO; cmykstatus=_("CMYK images cannot be printed\n(Workflow is RGB and there is no printer profile)"); } const gchar *monok=GTK_STOCK_NO; const char *monstatus=""; if(ma && ra) { monok=GTK_STOCK_YES; monstatus=_("Images will be displayed correctly"); } else if(ma) { monok=GTK_STOCK_DIALOG_WARNING; monstatus=_("Images will only be displayed correctly if they have an embedded profile"); } else { monok=GTK_STOCK_NO; monstatus=_("Images will not be displayed correctly"); } gtk_label_set_text(GTK_LABEL(ob->statusline[0]),rgbstatus); gtk_image_set_from_stock(GTK_IMAGE(ob->indicator[0]),rgbok, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_label_set_text(GTK_LABEL(ob->statusline[1]),cmykstatus); gtk_image_set_from_stock(GTK_IMAGE(ob->indicator[1]),cmykok, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_label_set_text(GTK_LABEL(ob->statusline[2]),monstatus); gtk_image_set_from_stock(GTK_IMAGE(ob->indicator[2]),monok, GTK_ICON_SIZE_SMALL_TOOLBAR); }
static gboolean curvature_dialog(CurvatureArgs *args, GwyContainer *data, GwyDataField *dfield, GwyDataField *mfield, gint id) { enum { RESPONSE_RESET = 1 }; GtkWidget *dialog, *table, *label, *hbox, *vbox, *treeview, *button, *hbox2; GwyDataChooser *chooser; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GwyPixmapLayer *player; GwyVectorLayer *vlayer; CurvatureControls controls; gint response; gint row; controls.args = args; controls.unit = gwy_data_field_get_si_unit_xy(dfield); gwy_clear(controls.params, PARAM_NPARAMS); controls.gmodel = gwy_graph_model_new(); init_graph_model_units(controls.gmodel, dfield); dialog = gtk_dialog_new_with_buttons(_("Curvature"), NULL, 0, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT); controls.dialog = dialog; hbox = gtk_hbox_new(FALSE, 8); gtk_container_set_border_width(GTK_CONTAINER(hbox), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0); controls.data = gwy_container_new(); gwy_container_set_object_by_name(controls.data, "/0/data", dfield); if (mfield) gwy_container_set_object_by_name(controls.data, "/0/mask", mfield); gwy_app_sync_data_items(data, controls.data, id, 0, FALSE, GWY_DATA_ITEM_PALETTE, GWY_DATA_ITEM_MASK_COLOR, GWY_DATA_ITEM_RANGE, GWY_DATA_ITEM_REAL_SQUARE, 0); controls.view = gwy_data_view_new(controls.data); player = gwy_layer_basic_new(); g_object_set(player, "data-key", "/0/data", "gradient-key", "/0/base/palette", "range-type-key", "/0/base/range-type", "min-max-key", "/0/base", NULL); gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), player); gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE); vlayer = g_object_new(g_type_from_name("GwyLayerLine"), NULL); gwy_vector_layer_set_selection_key(vlayer, "/0/select/line"); gwy_vector_layer_set_editable(vlayer, FALSE); gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.view), GWY_VECTOR_LAYER(vlayer)); controls.selection = gwy_vector_layer_ensure_selection(vlayer); g_object_set(controls.selection, "max-objects", 2, NULL); gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 4); table = gtk_table_new(5 + (mfield ? 4 : 0), 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); row = 0; label = gwy_label_new_header(_("Output Type")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.set_selection = gtk_check_button_new_with_mnemonic(_("_Set selection")); gtk_table_attach(GTK_TABLE(table), controls.set_selection, 0, 4, row, row+1, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.set_selection), args->set_selection); g_signal_connect(controls.set_selection, "toggled", G_CALLBACK(curvature_set_selection_changed), &controls); row++; controls.plot_graph = gtk_check_button_new_with_mnemonic(_("_Plot graph")); gtk_table_attach(GTK_TABLE(table), controls.plot_graph, 0, 4, row, row+1, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.plot_graph), args->plot_graph); g_signal_connect(controls.plot_graph, "toggled", G_CALLBACK(curvature_plot_graph_changed), &controls); row++; gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8); controls.target_hbox = hbox2 = gtk_hbox_new(FALSE, 6); gtk_widget_set_sensitive(controls.target_hbox, args->plot_graph); gtk_table_attach(GTK_TABLE(table), hbox2, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); label = gtk_label_new_with_mnemonic(_("Target _graph:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); controls.target_graph = gwy_data_chooser_new_graphs(); chooser = GWY_DATA_CHOOSER(controls.target_graph); gwy_data_chooser_set_none(chooser, _("New graph")); gwy_data_chooser_set_active(chooser, NULL, -1); gwy_data_chooser_set_filter(chooser, filter_target_graphs, &controls, NULL); gwy_data_chooser_set_active_id(chooser, &args->target_graph); gwy_data_chooser_get_active_id(chooser, &args->target_graph); gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.target_graph); gtk_box_pack_end(GTK_BOX(hbox2), controls.target_graph, FALSE, FALSE, 0); g_signal_connect_swapped(controls.target_graph, "changed", G_CALLBACK(target_graph_changed), &controls); row++; if (mfield) { gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8); label = gwy_label_new_header(_("Masking Mode")); gtk_table_attach(GTK_TABLE(table), label, 0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.masking_group = gwy_radio_buttons_create(gwy_masking_type_get_enum(), -1, G_CALLBACK(curvature_masking_changed), &controls, args->masking); row = gwy_radio_buttons_attach_to_table(controls.masking_group, GTK_TABLE(table), 3, row); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); } else controls.masking_group = NULL; controls.warning = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(controls.warning), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.warning, 0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0); controls.graph = gwy_graph_new(controls.gmodel); gtk_widget_set_size_request(controls.graph, 320, 260); g_object_unref(controls.gmodel); gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 4); controls.paramstore = gwy_null_store_new(PARAM_NPARAMS); treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(controls.paramstore)); g_object_unref(controls.paramstore); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); gtk_box_pack_start(GTK_BOX(vbox), treeview, FALSE, FALSE, 4); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Parameter"), renderer, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, render_name, param_names, NULL); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Symbol"), renderer, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, render_symbol, param_symbols, NULL); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "xalign", 1.0, NULL); column = gtk_tree_view_column_new_with_attributes(_("Value"), renderer, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, render_value, &controls, NULL); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); button = curvature_add_aux_button(hbox, GTK_STOCK_SAVE, _("Save table to a file")); g_signal_connect_swapped(button, "clicked", G_CALLBACK(curvature_save), &controls); button = curvature_add_aux_button(hbox, GTK_STOCK_COPY, _("Copy table to clipboard")); g_signal_connect_swapped(button, "clicked", G_CALLBACK(curvature_copy), &controls); curvature_update_preview(&controls, args); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: *args = curvature_defaults; curvature_dialog_update(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gtk_widget_destroy(dialog); return TRUE; }
static GtkWidget * make_info_table(PidginXferDialog *dialog) { GtkWidget *table; GtkWidget *label; int i; struct { GtkWidget **desc_label; GtkWidget **val_label; const char *desc; } labels[] = { { &dialog->local_user_desc_label, &dialog->local_user_label, NULL }, { &dialog->remote_user_desc_label, &dialog->remote_user_label, NULL }, { &label, &dialog->protocol_label, _("Protocol:") }, { &label, &dialog->filename_label, _("Filename:") }, { &label, &dialog->localfile_label, _("Local File:") }, { &label, &dialog->status_label, _("Status:") }, { &label, &dialog->speed_label, _("Speed:") }, { &label, &dialog->time_elapsed_label, _("Time Elapsed:") }, { &label, &dialog->time_remaining_label, _("Time Remaining:") } }; /* Setup the initial table */ dialog->table = table = gtk_table_new(9, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), PIDGIN_HIG_BOX_SPACE); gtk_table_set_col_spacings(GTK_TABLE(table), PIDGIN_HIG_BOX_SPACE); /* Setup the labels */ for (i = 0; i < sizeof(labels) / sizeof(*labels); i++) { GtkWidget *label; char buf[256]; g_snprintf(buf, sizeof(buf), "<b>%s</b>", labels[i].desc != NULL ? labels[i].desc : ""); *labels[i].desc_label = label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), buf); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, i, i + 1, GTK_FILL, 0, 0, 0); gtk_widget_show(label); *labels[i].val_label = label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 1, 2, i, i + 1, GTK_FILL | GTK_EXPAND, 0, 0, 0); gtk_widget_show(label); } /* Setup the progress bar */ dialog->progress = gtk_progress_bar_new(); gtk_table_attach(GTK_TABLE(table), dialog->progress, 0, 2, 8, 9, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show(dialog->progress); return table; }
static void update_detailed_info(PidginXferDialog *dialog, PurpleXfer *xfer) { PidginXferUiData *data; char *kbsec, *time_elapsed, *time_remaining; char *status, *utf8; if (dialog == NULL || xfer == NULL) return; data = PIDGINXFER(xfer); get_xfer_info_strings(xfer, &kbsec, &time_elapsed, &time_remaining); status = g_strdup_printf("%d%% (%" G_GSIZE_FORMAT " of %" G_GSIZE_FORMAT " bytes)", (int)(purple_xfer_get_progress(xfer)*100), purple_xfer_get_bytes_sent(xfer), purple_xfer_get_size(xfer)); if (purple_xfer_is_completed(xfer)) { GdkPixbuf *pixbuf = NULL; pixbuf = gtk_widget_render_icon(xfer_dialog->window, PIDGIN_STOCK_FILE_DONE, GTK_ICON_SIZE_MENU, NULL); gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter, COLUMN_STATUS, pixbuf, -1); g_object_unref(pixbuf); } if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) { gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label), _("<b>Receiving As:</b>")); gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label), _("<b>Receiving From:</b>")); } else { gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label), _("<b>Sending To:</b>")); gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label), _("<b>Sending As:</b>")); } gtk_label_set_text(GTK_LABEL(dialog->local_user_label), purple_account_get_username(xfer->account)); gtk_label_set_text(GTK_LABEL(dialog->remote_user_label), xfer->who); gtk_label_set_text(GTK_LABEL(dialog->protocol_label), purple_account_get_protocol_name(xfer->account)); if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) { gtk_label_set_text(GTK_LABEL(dialog->filename_label), purple_xfer_get_filename(xfer)); } else { char *tmp; tmp = g_path_get_basename(purple_xfer_get_local_filename(xfer)); utf8 = g_filename_to_utf8(tmp, -1, NULL, NULL, NULL); g_free(tmp); gtk_label_set_text(GTK_LABEL(dialog->filename_label), utf8); g_free(utf8); } utf8 = g_filename_to_utf8((purple_xfer_get_local_filename(xfer)), -1, NULL, NULL, NULL); gtk_label_set_text(GTK_LABEL(dialog->localfile_label), utf8); g_free(utf8); gtk_label_set_text(GTK_LABEL(dialog->status_label), status); gtk_label_set_text(GTK_LABEL(dialog->speed_label), kbsec); gtk_label_set_text(GTK_LABEL(dialog->time_elapsed_label), time_elapsed); gtk_label_set_text(GTK_LABEL(dialog->time_remaining_label), time_remaining); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dialog->progress), purple_xfer_get_progress(xfer)); g_free(kbsec); g_free(time_elapsed); g_free(time_remaining); g_free(status); }
static void grilo_media_browse_cb (GrlSource *grilo_source, guint operation_id, GrlMedia *media, guint remaining, RBGriloSource *source, const GError *error) { if (operation_id != source->priv->media_browse_op) { return; } if (error != NULL) { /* do something? */ rb_debug ("got error for %s: %s", grl_source_get_name (grilo_source), error->message); return; } GDK_THREADS_ENTER (); if (media != NULL) { source->priv->media_browse_got_results = TRUE; source->priv->media_browse_position++; if (GRL_IS_MEDIA_AUDIO (media)) { RhythmDBEntry *entry; entry = create_entry_for_media (source->priv->db, source->priv->entry_type, GRL_DATA (media), GRL_DATA (source->priv->browse_container)); if (entry != NULL) { rhythmdb_query_model_add_entry (source->priv->query_model, entry, -1); } } else if (GRL_IS_MEDIA_BOX (media)) { source->priv->media_browse_got_containers = TRUE; } } if (remaining == 0) { source->priv->media_browse_op = 0; if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (source->priv->query_model), NULL) == 0 && source->priv->media_browse_position >= CONTAINER_GIVE_UP_POINT) { /* if we don't find any media within the first 100 or so results, * assume this container doesn't have any. otherwise we'd load * the entire thing when it got selected, which would suck. */ rb_debug ("didn't find any media in %s, giving up", grl_media_get_title (source->priv->media_browse_container)); gtk_tree_store_set (source->priv->browser_model, &source->priv->media_browse_container_iter, 2, CONTAINER_NO_MEDIA, -1); } else if (source->priv->media_browse_got_results) { if (source->priv->media_browse_position < source->priv->media_browse_limit) { media_browse_next (source); } else { char *text; text = g_strdup_printf (ngettext ("Only showing %d result", "Only showing %d results", source->priv->media_browse_position), source->priv->media_browse_position); gtk_label_set_text (GTK_LABEL (source->priv->info_bar_label), text); g_free (text); gtk_widget_show (source->priv->info_bar); } } else if (source->priv->media_browse_got_containers == FALSE && source->priv->media_browse_container != NULL) { /* make sure there's no marker row for this container */ delete_marker_row (source, &source->priv->media_browse_container_iter); } } GDK_THREADS_LEAVE (); }
void cc_build_edit_dialog (CcNotificationsPanel *panel, GAppInfo *app, GSettings *settings) { GtkWindow *shell; GtkDialog *win; GtkWidget *content_area; GtkGrid *content_grid; int i; shell = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (panel))); win = GTK_DIALOG (gtk_dialog_new ()); g_object_set (win, "modal", TRUE, "title", g_app_info_get_name (app), "width-request", 450, "transient-for", shell, "resizable", FALSE, NULL); gtk_dialog_add_button (win, "gtk-close", GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response (win, GTK_RESPONSE_CLOSE); content_area = gtk_dialog_get_content_area (win); content_grid = GTK_GRID (gtk_grid_new ()); g_object_set (content_grid, "row-spacing", 10, "margin-left", 15, "margin-right", 5, NULL); gtk_container_add (GTK_CONTAINER (content_area), GTK_WIDGET (content_grid)); for (i = 0; i < G_N_ELEMENTS (policy_settings); i++) { GtkWidget *label; GtkWidget *_switch; label = gtk_label_new (g_dpgettext2 (GETTEXT_PACKAGE, "notifications", policy_settings[i].label)); g_object_set (label, "xalign", 0.0, "hexpand", TRUE, NULL); if (policy_settings[i].bold) { PangoAttrList *list; PangoAttribute *weight; list = pango_attr_list_new (); weight = pango_attr_weight_new (PANGO_WEIGHT_BOLD); pango_attr_list_insert (list, weight); gtk_label_set_attributes (GTK_LABEL (label), list); pango_attr_list_unref (list); } _switch = gtk_switch_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), _switch); g_settings_bind (settings, policy_settings[i].setting_key, _switch, "active", G_SETTINGS_BIND_DEFAULT); gtk_grid_attach (content_grid, GTK_WIDGET (label), 0, i, 1, 1); gtk_grid_attach (content_grid, _switch, 1, i, 1, 1); } g_signal_connect (win, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show_all (GTK_WIDGET (win)); }
void dlg_export_to_picasaweb (GthBrowser *browser, GList *file_list) { DialogData *data; GtkTreeSelection *selection; GList *scan; int n_total; goffset total_size; char *total_size_formatted; char *text; data = g_new0 (DialogData, 1); data->browser = browser; data->location = gth_file_data_dup (gth_browser_get_location_data (browser)); data->builder = _gtk_builder_new_from_file ("export-to-picasaweb.ui", "picasaweb"); data->dialog = _gtk_builder_get_widget (data->builder, "export_dialog"); data->cancellable = g_cancellable_new (); { GtkCellLayout *cell_layout; GtkCellRenderer *renderer; cell_layout = GTK_CELL_LAYOUT (GET_WIDGET ("name_treeviewcolumn")); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (cell_layout, renderer, FALSE); gtk_cell_layout_set_attributes (cell_layout, renderer, "icon-name", ALBUM_ICON_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (cell_layout, renderer, TRUE); gtk_cell_layout_set_attributes (cell_layout, renderer, "text", ALBUM_NAME_COLUMN, NULL); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (cell_layout, renderer, FALSE); gtk_cell_layout_set_attributes (cell_layout, renderer, "icon-name", ALBUM_EMBLEM_COLUMN, NULL); } _gtk_window_resize_to_fit_screen_height (data->dialog, 500); data->file_list = NULL; n_total = 0; total_size = 0; for (scan = file_list; scan; scan = scan->next) { GthFileData *file_data = scan->data; const char *mime_type; mime_type = gth_file_data_get_mime_type (file_data); if (g_content_type_equals (mime_type, "image/bmp") || g_content_type_equals (mime_type, "image/gif") || g_content_type_equals (mime_type, "image/jpeg") || g_content_type_equals (mime_type, "image/png")) { total_size += g_file_info_get_size (file_data->info); n_total++; data->file_list = g_list_prepend (data->file_list, g_object_ref (file_data)); } } data->file_list = g_list_reverse (data->file_list); if (data->file_list == NULL) { GError *error; if (data->conn != NULL) gth_task_dialog (GTH_TASK (data->conn), TRUE); error = g_error_new_literal (GTH_ERROR, GTH_ERROR_GENERIC, _("No valid file selected.")); _gtk_error_dialog_from_gerror_show (GTK_WINDOW (browser), _("Could not export the files"), &error); destroy_dialog (data); return; } total_size_formatted = g_format_size_for_display (total_size); text = g_strdup_printf (g_dngettext (NULL, "%d file (%s)", "%d files (%s)", n_total), n_total, total_size_formatted); gtk_label_set_text (GTK_LABEL (GET_WIDGET ("images_info_label")), text); g_free (text); g_free (total_size_formatted); /* Set the widget data */ data->list_view = gth_file_list_new (GTH_FILE_LIST_TYPE_NO_SELECTION, FALSE); gth_file_list_set_thumb_size (GTH_FILE_LIST (data->list_view), 112); gth_file_view_set_spacing (GTH_FILE_VIEW (gth_file_list_get_view (GTH_FILE_LIST (data->list_view))), 0); gth_file_list_enable_thumbs (GTH_FILE_LIST (data->list_view), TRUE); gth_file_list_set_caption (GTH_FILE_LIST (data->list_view), "none"); gth_file_list_set_sort_func (GTH_FILE_LIST (data->list_view), gth_main_get_sort_type ("file::name")->cmp_func, FALSE); gtk_widget_show (data->list_view); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("images_box")), data->list_view, TRUE, TRUE, 0); gth_file_list_set_files (GTH_FILE_LIST (data->list_view), data->file_list); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("album_liststore")), ALBUM_NAME_COLUMN, GTK_SORT_ASCENDING); gtk_widget_set_sensitive (GET_WIDGET ("upload_button"), FALSE); /* Set the signals handlers. */ g_signal_connect (data->dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (data->dialog, "response", G_CALLBACK (export_dialog_response_cb), data); g_signal_connect (GET_WIDGET ("add_album_button"), "clicked", G_CALLBACK (add_album_button_clicked_cb), data); g_signal_connect (GET_WIDGET ("edit_accounts_button"), "clicked", G_CALLBACK (edit_accounts_button_clicked_cb), data); g_signal_connect (GET_WIDGET ("account_combobox"), "changed", G_CALLBACK (account_combobox_changed_cb), data); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (GET_WIDGET ("albums_treeview"))); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (albums_treeview_selection_changed_cb), data); data->accounts = picasa_web_accounts_load_from_file (&data->email); auto_select_account (data); }
void pLabel::setText(const string &text) { gtk_label_set_text(GTK_LABEL(gtkWidget), text); }
void change_timezone_label() { // change the label to green-crossed/nearest_timezone GtkWidget *label = lookup_widget(MainWindow,"label14"); gtk_label_set_text(GTK_LABEL(label),nearest_timezone->tz); }
static void add_route_row (CEPageIP6 *page, const gchar *address, gint prefix, const gchar *gateway, gint metric) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *label; GtkWidget *widget; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_widget_set_halign (label, GTK_ALIGN_END); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Prefix")); gtk_widget_set_halign (label, GTK_ALIGN_END); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "prefix", widget); if (prefix > 0) { gchar *s = g_strdup_printf ("%d", prefix); gtk_entry_set_text (GTK_ENTRY (widget), s); g_free (s); } gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_widget_set_halign (label, GTK_ALIGN_END); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); /* Translators: Please see https://en.wikipedia.org/wiki/Metrics_(networking) */ label = gtk_label_new (C_("network parameters", "Metric")); gtk_widget_set_halign (label, GTK_ALIGN_END); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 4, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "metric", widget); if (metric > 0) { gchar *s = g_strdup_printf ("%d", metric); gtk_entry_set_text (GTK_ENTRY (widget), s); g_free (s); } gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 4, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Route")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_widget_set_halign (delete_button, GTK_ALIGN_CENTER); gtk_widget_set_valign (delete_button, GTK_ALIGN_CENTER); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 1, 1, 4); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_start (row_grid, 10); gtk_widget_set_margin_end (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->routes_list), row); update_row_sensitivity (page, page->routes_list); }
void set_time(struct tm dt) { GtkWidget *curr_time = lookup_widget(MainWindow,"label7"); gchar string[9]; sprintf(string,"%02d:%02d:%02d",dt.tm_hour,dt.tm_min,dt.tm_sec); gtk_label_set_text(GTK_LABEL(curr_time),string); }
GtkWidget * AP_UnixDialog_PageSetup::_constructWindow (void) { // get the path where our UI file is located std::string ui_path = static_cast<XAP_UnixApp*>(XAP_App::getApp())->getAbiSuiteAppUIDir() + "/ap_UnixDialog_PageSetup.xml"; // load the dialog from the UI file m_pBuilder = gtk_builder_new(); gtk_builder_add_from_file(m_pBuilder, ui_path.c_str(), NULL); const XAP_StringSet * pSS = m_pApp->getStringSet (); GList *glist; GtkLabel *orientation; m_window = _getWidget("ap_UnixDialog_PageSetup"); m_wHelp = _getWidget("wHelp"); m_comboPageSize = _getWidget("comboPageSize"); m_entryPageWidth = _getWidget("wWidthSpin"); m_entryPageHeight = _getWidget("wHeightSpin"); m_optionPageUnits = _getWidget("optionPageUnits"); m_radioPagePortrait = _getWidget("rbPortrait"); m_radioPageLandscape = _getWidget("rbLandscape"); m_spinPageScale = _getWidget("wPageScale"); m_optionMarginUnits = _getWidget("optionMarginUnits"); m_spinMarginTop = _getWidget("wTopSpin"); m_spinMarginBottom = _getWidget("wBottomSpin"); m_spinMarginLeft = _getWidget("wLeftSpin"); m_spinMarginRight = _getWidget("wRightSpin"); m_spinMarginHeader = _getWidget("wHeaderSpin"); m_spinMarginFooter = _getWidget("wFooterSpin"); m_MarginHbox = _getWidget("hbox15"); m_PageHbox = _getWidget("hbox16"); /* required for translations */ gtk_label_set_text (GTK_LABEL (_getWidget("lbPage")), _(AP, DLG_PageSetup_Page)); gtk_label_set_text (GTK_LABEL (_getWidget("lbMargin")), _(AP, DLG_PageSetup_Margin)); Markup (_getWidget("lbPaper"), pSS, _(AP, DLG_PageSetup_Paper)); gtk_label_set_text (GTK_LABEL (_getWidget("lbPaperSize")), _(AP, DLG_PageSetup_Paper_Size)); gtk_label_set_text (GTK_LABEL (_getWidget("lbPageUnits")), _(AP, DLG_PageSetup_Units)); gtk_label_set_text (GTK_LABEL (_getWidget("lbWidth")), _(AP, DLG_PageSetup_Width)); gtk_label_set_text (GTK_LABEL (_getWidget("lbHeight")), _(AP, DLG_PageSetup_Height)); Markup (_getWidget("lbOrientation"), pSS, _(AP, DLG_PageSetup_Orient)); /* radio button labels */ glist = gtk_container_get_children (GTK_CONTAINER (m_radioPagePortrait)); orientation = GTK_LABEL (g_list_nth_data (glist, 0)); gtk_label_set_text (GTK_LABEL (orientation), _(AP, DLG_PageSetup_Portrait)); glist = gtk_container_get_children (GTK_CONTAINER (m_radioPageLandscape)); orientation = GTK_LABEL (g_list_nth_data (glist, 0)); gtk_label_set_text (GTK_LABEL (orientation), _(AP, DLG_PageSetup_Landscape)); Markup (_getWidget("lbScale"), pSS, _(AP, DLG_PageSetup_Scale)); gtk_label_set_text (GTK_LABEL (_getWidget("lbAdjust")), _(AP, DLG_PageSetup_Adjust)); gtk_label_set_text (GTK_LABEL (_getWidget("lbPercentNormalSize")), _(AP, DLG_PageSetup_Percent)); gtk_label_set_text (GTK_LABEL (_getWidget("lbMarginUnits")), _(AP, DLG_PageSetup_Units)); gtk_label_set_text (GTK_LABEL (_getWidget("lbTop")), _(AP, DLG_PageSetup_Top)); gtk_label_set_text (GTK_LABEL (_getWidget("lbRight")), _(AP, DLG_PageSetup_Right)); gtk_label_set_text (GTK_LABEL (_getWidget("lbLeft")), _(AP, DLG_PageSetup_Left)); gtk_label_set_text (GTK_LABEL (_getWidget("lbBottom")), _(AP, DLG_PageSetup_Bottom)); gtk_label_set_text (GTK_LABEL (_getWidget("lbHeader")), _(AP, DLG_PageSetup_Header)); gtk_label_set_text (GTK_LABEL (_getWidget("lbFooter")), _(AP, DLG_PageSetup_Footer)); /* end translation req */ /* setup page width and height */ if (!getPageOrientation () == PORTRAIT) { m_PageSize.setLandscape(); } gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_entryPageWidth), m_PageSize.Width (getPageUnits ())); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_entryPageHeight), m_PageSize.Height (getPageUnits ())); /* setup margin numbers */ gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginTop), getMarginTop ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginBottom), getMarginBottom ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginLeft), getMarginLeft ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginRight), getMarginRight ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginHeader), getMarginHeader ()); gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginFooter), getMarginFooter ()); /* setup scale number */ gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinPageScale), static_cast<float>(getPageScale ())); // fill the combobox all of our supported page sizes GtkListStore* pagesize_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); GtkTreeIter pagesize_iter; for (UT_uint32 i = fp_PageSize::_first_predefined_pagesize_; i < fp_PageSize::_last_predefined_pagesize_dont_use_; i++) { gtk_list_store_append(pagesize_store, &pagesize_iter); gtk_list_store_set(pagesize_store, &pagesize_iter, 0, fp_PageSize::PredefinedToName ((fp_PageSize::Predefined)i), 1, this, -1); } gtk_combo_box_set_model(GTK_COMBO_BOX(m_comboPageSize), GTK_TREE_MODEL(pagesize_store)); m_iComboPageSizeListID = g_signal_connect(G_OBJECT(m_comboPageSize), "changed", G_CALLBACK(s_page_size_changed), static_cast<gpointer>(this)); /* setup page units menu */ GtkComboBox *combo = GTK_COMBO_BOX(m_optionPageUnits); XAP_makeGtkComboBoxText(combo, G_TYPE_INT); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_inch), DIM_IN); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_cm), DIM_CM); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_mm), DIM_MM); XAP_comboBoxSetActiveFromIntCol(combo, 1, getPageUnits ()); /* setup margin units menu */ combo = GTK_COMBO_BOX(m_optionMarginUnits); XAP_makeGtkComboBoxText(combo, G_TYPE_INT); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_inch), DIM_IN); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_cm), DIM_CM); XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_mm), DIM_MM); last_margin_unit = getMarginUnits (); XAP_comboBoxSetActiveFromIntCol(combo, 1, last_margin_unit); /* add margin XPM image to the margin window */ customPreview = create_pixmap (m_MarginHbox, margin_xpm); gtk_widget_show (customPreview); gtk_box_pack_start (GTK_BOX (m_MarginHbox), customPreview, FALSE, FALSE, 0); /* add correct page XPM image to the page window */ if (getPageOrientation () == PORTRAIT) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_radioPagePortrait), TRUE); customPreview = create_pixmap (m_PageHbox, orient_vertical_xpm); gtk_widget_show (customPreview); gtk_box_pack_start (GTK_BOX (m_PageHbox), customPreview, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (m_PageHbox), customPreview, 0); } else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_radioPageLandscape), TRUE); customPreview = create_pixmap (m_PageHbox, orient_horizontal_xpm); gtk_widget_show (customPreview); gtk_box_pack_start (GTK_BOX (m_PageHbox), customPreview, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (m_PageHbox), customPreview, 0); } abiAddStockButton(GTK_DIALOG(m_window), GTK_STOCK_CANCEL, BUTTON_CANCEL); abiAddStockButton(GTK_DIALOG(m_window), GTK_STOCK_OK, BUTTON_OK); _connectSignals (); return m_window; }
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; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; gchar *build_date; 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_window_set_icon_name(GTK_WINDOW(dialog), "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); 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_from_icon_name("geany", GTK_ICON_SIZE_DIALOG); 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_get_content_area(GTK_DIALOG(dialog))), header_eventbox, FALSE, FALSE, 0); /* 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_get_content_area(GTK_DIALOG(dialog))), 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); build_date = utils_parse_and_format_build_date(__DATE__); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), build_date); g_free(build_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), 6); 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); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN); license_textview = gtk_text_view_new(); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2); 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; }
G_MODULE_EXPORT void on_menu_docstat_activate (GtkWidget *widget, void *user) { gint i = 0; gchar* output = 0; gchar* cmd = 0; gchar** matched = NULL; GError* err = NULL; GMatchInfo* match_info; GRegex* regexs[TEXCOUNT_OUTPUT_LINES]; gchar* res[TEXCOUNT_OUTPUT_LINES] = { 0 }; /* TODO: can we deprecate this? */ const gchar* terms[] = { _("Words in text"), _("Words in headers"), _("Words in float captions"), _("Number of headers"), _("Number of floats"), _("Number of math inlines"), _("Number of math displayed") }; const gchar* terms_regex[] = { "Words in text: ([0-9]*)", "Words in headers: ([0-9]*)", "Words in float captions: ([0-9]*)", "Number of headers: ([0-9]*)", "Number of floats: ([0-9]*)", "Number of math inlines: ([0-9]*)", "Number of math displayed: ([0-9]*)" }; /* TODO: move to non gui class (latex perhaps) */ if (external_exists ("texcount")) { /* Copy workfile to /tmp to remove any spaces in filename to avoid * segfaults */ gchar* tmpfile = g_strdup_printf ("%s.state", g_active_editor->fdname); if (!utils_copy_file (g_active_editor->workfile, tmpfile, &err)) { slog (L_G_ERROR, "utils_copy_file (): %s\n", err->message); g_free (tmpfile); g_error_free (err); goto cleanup; } cmd = g_strdup_printf ("texcount '%s'", tmpfile); Tuple2 result = utils_popen_r (cmd, NULL); for (i = 0; i < TEXCOUNT_OUTPUT_LINES; ++i) if (! (regexs[i] = g_regex_new (terms_regex[i], 0, 0, &err))) { slog (L_G_ERROR, "utils_copy_file (): %s\n", err->message); g_free (tmpfile); g_error_free (err); goto cleanup; } for (i = 0; i < TEXCOUNT_OUTPUT_LINES; ++i) { if (g_regex_match (regexs[i], result.second, 0, &match_info)) { matched = g_match_info_fetch_all (match_info); if (NULL == matched[1]) { slog (L_WARNING, "can't extract info: %s\n", terms[i]); res[i] = g_strdup ("N/A"); } else { res[i] = g_strdup (matched[1]); } g_strfreev (matched); g_match_info_free (match_info); } } g_free (result.second); g_free (tmpfile); } else { cmd = NULL; slog (L_G_ERROR, "The 'texcount' utility could not be found.\n"); return; } gchararray items[6] = {"stats_words", "stats_head", "stats_float", "stats_nrhead", "stats_nrfloat", "stats_nrmath"}; int j = 0; GtkLabel *tmp; for (j = 0; j < 6; j++) { gchar *value = items[j]; tmp = GTK_LABEL(gtk_builder_get_object (gui->builder, value)); gtk_label_set_text (tmp, res[j]); } gtk_label_set_text (GTK_LABEL (gtk_builder_get_object (gui->builder, "stats_filename")), tabmanagergui_get_labeltext (g_active_tab->page)); gtk_widget_show (gui->docstatswindow); return; cleanup: for (i = 0; i < TEXCOUNT_OUTPUT_LINES; ++i) { g_regex_unref (regexs[i]); g_free (res[i]); } g_free (cmd); g_free (output); }
GtkWidget *load_gtk_widget() { GtkWidget *pVBox, *pFrame, *pHBoxFrame, *pVBoxFrame, *phboxtemp, *labeltemp; GtkWidget *hboxview; GtkWidget *labelinfo, *labeldesc; GtkWidget *info; GtkListStore *store; GtkTreeModel *model; GtkTreeViewColumn *col; GtkCellRenderer *renderer; pVBoxFrame = gtk_vbox_new(FALSE, 0); pHBoxFrame = gtk_hbox_new(FALSE, 0); pVBox = gtk_vbox_new(FALSE, 0); hboxview = gtk_hbox_new(FALSE, 0); info = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(info), _("<span face=\"Courier New\"><b>You can configure all network interfaces you need</b></span>")); gtk_box_pack_start(GTK_BOX(pVBox), info, FALSE, FALSE, 5); gtk_box_pack_start (GTK_BOX (pVBox), info, FALSE, FALSE, 5); store = gtk_list_store_new(6, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); model = GTK_TREE_MODEL(store); viewif = gtk_tree_view_new_with_model(model); g_object_unref (model); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(viewif), TRUE); renderer = gtk_cell_renderer_pixbuf_new(); col = gtk_tree_view_column_new_with_attributes ("", renderer, "pixbuf", COLUMN_NET_IMAGE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Device"), renderer, "text", COLUMN_NET_NAME, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Ip Address"), renderer, "text", COLUMN_NET_IP, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Netmask"), renderer, "text", COLUMN_NET_NETMASK, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Gateway"), renderer, "text", COLUMN_NET_GATEWAY, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("DHCP Nameserver"), renderer, "text", COLUMN_NET_NAMESERV, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); gtk_box_pack_start(GTK_BOX(hboxview), viewif, TRUE, TRUE, 10); gtk_box_pack_start(GTK_BOX(pVBox), hboxview, TRUE, TRUE, 5); pFrame = gtk_frame_new(_("Network configuration")); gtk_container_add(GTK_CONTAINER(pFrame), pVBoxFrame); gtk_box_pack_start(GTK_BOX(pVBox), pFrame, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(pVBoxFrame), pHBoxFrame, FALSE, FALSE, 12); labeldesc = gtk_label_new(_("Interface :")); gtk_box_pack_start(GTK_BOX(pHBoxFrame), labeldesc, FALSE, FALSE, 5); intercombo = gtk_combo_box_new_text(); gtk_box_pack_start(GTK_BOX(pHBoxFrame), intercombo, TRUE, TRUE, 5); labelinfo = gtk_label_new(""); gtk_box_pack_start(GTK_BOX(pHBoxFrame), labelinfo, TRUE, TRUE, 0); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("Network configuration : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *btnsave = gtk_button_new_from_stock (GTK_STOCK_ADD); gtk_box_pack_start(GTK_BOX(phboxtemp), btnsave, FALSE, FALSE, 10); GtkWidget *btndel = gtk_button_new_from_stock (GTK_STOCK_REMOVE); gtk_box_pack_start(GTK_BOX(phboxtemp), btndel, FALSE, FALSE, 10); gtk_frame_set_label_widget(GTK_FRAME(pFrame), phboxtemp); g_signal_connect(G_OBJECT(intercombo), "changed", G_CALLBACK(change_interface), labelinfo); g_signal_connect(G_OBJECT(btnsave), "clicked", G_CALLBACK(add_interface), viewif); g_signal_connect(G_OBJECT(btndel), "clicked", G_CALLBACK(del_interface), viewif); return pVBox; }
/* Make the insides of an about box. */ static void about_build( iDialog *idlg, GtkWidget *work ) { /* Translators: translate this to a credit for you, and it'll appear in * the About box. */ char *translator_credits = _( "translator_credits" ); GtkWidget *hb; GtkWidget *lab; char txt[MAX_DIALOG_TEXT]; char txt2[MAX_DIALOG_TEXT]; VipsBuf buf = VIPS_BUF_STATIC( txt ); GtkWidget *image; im_snprintf( txt2, MAX_DIALOG_TEXT, _( "About %s." ), PACKAGE ); vips_buf_appendf( &buf, "<b><big>%s</big></b>\n\n", txt2 ); im_snprintf( txt2, MAX_DIALOG_TEXT, _( "%s is an image processing package." ), PACKAGE ); vips_buf_appendf( &buf, "%s\n\n", txt2 ); im_snprintf( txt2, MAX_DIALOG_TEXT, _( "%s comes with ABSOLUTELY NO WARRANTY. This is " "free software and you are welcome to redistribute " "it under certain conditions, see http://www.gnu.org." ), PACKAGE ); vips_buf_appendf( &buf, "%s\n\n", txt2 ); im_snprintf( txt2, MAX_DIALOG_TEXT, _( NIP_COPYRIGHT ), PACKAGE ); vips_buf_appendf( &buf, "%s\n\n", txt2 ); { char buf1[FILENAME_MAX]; char buf2[FILENAME_MAX]; im_snprintf( buf1, FILENAME_MAX, "%s" G_DIR_SEPARATOR_S "start", get_savedir() ); expand_variables( buf1, buf2 ); nativeize_path( buf2 ); escape_markup( buf2, buf1, FILENAME_MAX ); vips_buf_appendf( &buf, "<b>%s:</b> %s\n", _( "Personal start folder" ), buf1 ); } vips_buf_appendf( &buf, "<b>%s:</b> %s\n", _( "Homepage" ), VIPS_HOMEPAGE ); escape_markup( im_version_string(), txt2, MAX_DIALOG_TEXT ); vips_buf_appendf( &buf, "<b>%s:</b> %s\n", _( "Linked to VIPS" ), txt2 ); escape_markup( IM_VERSION_STRING, txt2, MAX_DIALOG_TEXT ); vips_buf_appendf( &buf, "<b>%s:</b> %s\n", _( "Built against VIPS" ), txt2 ); escape_markup( PACKAGE, txt2, MAX_DIALOG_TEXT ); vips_buf_appendf( &buf, "<b>$PACKAGE:</b> %s\n", txt2 ); escape_markup( VERSION, txt2, MAX_DIALOG_TEXT ); vips_buf_appendf( &buf, "<b>$VERSION:</b> %s\n", txt2 ); escape_markup( NN( g_getenv( "VIPSHOME" ) ), txt2, MAX_DIALOG_TEXT ); vips_buf_appendf( &buf, "<b>$VIPSHOME:</b> %s\n", txt2 ); escape_markup( NN( g_getenv( "HOME" ) ), txt2, MAX_DIALOG_TEXT ); vips_buf_appendf( &buf, "<b>$HOME:</b> %s\n", txt2 ); escape_markup( NN( g_getenv( "SAVEDIR" ) ), txt2, MAX_DIALOG_TEXT ); vips_buf_appendf( &buf, "<b>$SAVEDIR:</b> %s\n", txt2 ); escape_markup( PATH_TMP, txt2, MAX_DIALOG_TEXT ); vips_buf_appendf( &buf, "<b>%s:</b> %s\n", _( "Temp files in" ), txt2 ); if( strcmp( translator_credits, "translator_credits" ) != 0 ) { vips_buf_appendf( &buf, "\n" ); vips_buf_appends( &buf, translator_credits ); } vips_buf_appendf( &buf, "\n" ); mainw_find_disc( &buf ); /* Expands to (eg.) "14GB free in /pics/tmp" */ vips_buf_appendf( &buf, _( " in \"%s\"" ), PATH_TMP ); vips_buf_appends( &buf, "\n" ); vips_buf_appendf( &buf, _( "%d cells in heap, %d cells free, %d cells maximum" ), reduce_context->heap->ncells, reduce_context->heap->nfree, reduce_context->heap->max_fn( reduce_context->heap ) ); vips_buf_appends( &buf, "\n" ); vips_buf_appendf( &buf, _( "%d vips calls cached by nip2" ), cache_history_size ); vips_buf_appends( &buf, "\n" ); vips_buf_appendf( &buf, _( "%d vips operations cached by libvips" ), vips_cache_get_size() ); vips_buf_appends( &buf, "\n" ); vips_buf_appendf( &buf, _( "using %d threads" ), im_concurrency_get() ); vips_buf_appends( &buf, "\n" ); vips_buf_appendf( &buf, _( "%d pixel buffers in vips" ), vips_tracked_get_allocs() ); vips_buf_appends( &buf, "\n" ); vips_buf_append_size( &buf, vips_tracked_get_mem() ); vips_buf_appendf( &buf, _( " of ram in pixel buffers" ) ); vips_buf_appends( &buf, "\n" ); vips_buf_append_size( &buf, vips_tracked_get_mem_highwater() ); vips_buf_appendf( &buf, _( " of ram highwater mark" ) ); vips_buf_appends( &buf, "\n" ); hb = gtk_hbox_new( FALSE, 0 ); gtk_container_border_width( GTK_CONTAINER( hb ), 10 ); gtk_container_add( GTK_CONTAINER( work ), hb ); gtk_widget_show( hb ); image = image_new_from_file( "$VIPSHOME/share/$PACKAGE/data/vips-128.png" ); gtk_box_pack_start( GTK_BOX( hb ), image, FALSE, FALSE, 2 ); gtk_widget_show( image ); lab = gtk_label_new( "" ); gtk_label_set_markup( GTK_LABEL( lab ), vips_buf_all( &buf ) ); gtk_label_set_justify( GTK_LABEL( lab ), GTK_JUSTIFY_LEFT ); gtk_label_set_selectable( GTK_LABEL( lab ), TRUE ); gtk_label_set_line_wrap( GTK_LABEL( lab ), TRUE ); gtk_box_pack_start( GTK_BOX( hb ), lab, FALSE, FALSE, 2 ); gtk_widget_show( lab ); }
void on_xiphos_web_listener_ready_callback (SoupSession *session, SoupMessage *msg, gpointer user_data) { if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { // Get the response body. string body (msg->response_body->data); body = trim (body); // Log it. //printf ("%s\n", body.c_str()); //fflush (stdout); ParseLine parseline (body); if (parseline.lines.size() >= 3) { // It retrieves the message ID and uses this to ask for a higher ID next poll. // Update GUI. last_message_id = parseline.lines[0]; gtk_label_set_text (GTK_LABEL (label_id), last_message_id.c_str()); string command = parseline.lines[1]; gtk_label_set_text (GTK_LABEL (label_command), command.c_str()); string body = parseline.lines[2]; gtk_label_set_text (GTK_LABEL (label_body), body.c_str()); // Handle "quit" command. if (command == "quit") { gtk_main_quit (); } // Handle "focus" command. if (command == "focus") { Parse parse (body, false, "."); if (parse.words.size() == 3) { string book; switch (convert_to_int (parse.words[0])) { case 1: book = "Gen"; break; case 2: book = "Exod"; break; case 3: book = "Lev"; break; case 4: book = "Num"; break; case 5: book = "Deut"; break; case 6: book = "Josh"; break; case 7: book = "Judg"; break; case 8: book = "Ruth"; break; case 9: book = "1Sam"; break; case 10: book = "2Sam"; break; case 11: book = "1Kgs"; break; case 12: book = "2Kgs"; break; case 13: book = "1Chr"; break; case 14: book = "2Chr"; break; case 15: book = "Ezra"; break; case 16: book = "Neh"; break; case 17: book = "Esth"; break; case 18: book = "Job"; break; case 19: book = "Ps"; break; case 20: book = "Prov"; break; case 21: book = "Eccl"; break; case 22: book = "Song"; break; case 23: book = "Isa"; break; case 24: book = "Jer"; break; case 25: book = "Lam"; break; case 26: book = "Ezek"; break; case 27: book = "Dan"; break; case 28: book = "Hos"; break; case 29: book = "Joel"; break; case 30: book = "Amos"; break; case 31: book = "Obad"; break; case 32: book = "Jonah"; break; case 33: book = "Mic"; break; case 34: book = "Nah"; break; case 35: book = "Hab"; break; case 36: book = "Zeph"; break; case 37: book = "Hag"; break; case 38: book = "Zech"; break; case 39: book = "Mal"; break; case 40: book = "Matt"; break; case 41: book = "Mark"; break; case 42: book = "Luke"; break; case 43: book = "John"; break; case 44: book = "Acts"; break; case 45: book = "Rom"; break; case 46: book = "1Cor"; break; case 47: book = "2Cor"; break; case 48: book = "Gal"; break; case 49: book = "Eph"; break; case 50: book = "Phil"; break; case 51: book = "Col"; break; case 52: book = "1Thess"; break; case 53: book = "2Thess"; break; case 54: book = "1Tim"; break; case 55: book = "2Tim"; break; case 56: book = "Titus"; break; case 57: book = "Phlm"; break; case 58: book = "Heb"; break; case 59: book = "Jas"; break; case 60: book = "1Pet"; break; case 61: book = "2Pet"; break; case 62: book = "1John"; break; case 63: book = "2John"; break; case 64: book = "3John"; break; case 65: book = "Jude"; break; case 66: book = "Rev"; break; } if (!book.empty()) { string reference = "sword://" + book + "." + parse.words[1] + "." + parse.words[2]; send_to_xiphos (xiphos_dbus_object (), xiphos_dbus_interface (), "setCurrentReference", reference); reference.insert (0, "setCurrentReference "); gtk_label_set_text (GTK_LABEL (label_xiphos), reference.c_str()); } } } } } else { // If the message was cancelled, do not start it again, just quit. if (msg->status_code == 1) { return; } // If it needs to quit, just quit. if (quit) return; // Handle error. printf ("Xiphos web listener failure, code: %d, reason: %s\n", msg->status_code, msg->reason_phrase); fflush (stdout); for (unsigned int i = 0; i < 10; i++) { while (gtk_events_pending()) gtk_main_iteration(); g_usleep (100000); } } g_usleep (100000); start_xiphos_web_listener (); }
static void preview_alt_normal(gint32 image_ID) { /******************************************************************************* * Begin H and Normal ******************************************************************************/ gint32 mergedLayer_ID = -1; gint32 normalmap_ID = -1; gfloat wsize = (gfloat)gimp_image_width(image_ID); gfloat hsize = (gfloat)gimp_image_width(image_ID); /** Get active layer. */ gint32 drawable_temp_ID = gimp_image_get_active_layer(image_ID); /** Copy active layer. */ /** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */ gint32 diffuse_ID = gimp_layer_copy (drawable_temp_ID); /** Add new layer to image. */ gimp_image_add_layer(image_ID, diffuse_ID, -1); /** Set new layer as active. */ gimp_image_set_active_layer(image_ID, diffuse_ID); /** Here I should hide previous active layer, make not visible. */ gtk_label_set_text(GTK_LABEL(progress_label), "Smoothing"); /** * Since copied, don't need this here. * blur seems to not create an extra layer. */ blur(image_ID, diffuse_ID, wsize, hsize, local_vals.LargeDetails, 0, local_vals.ao); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.15); normalmap_ID = gimp_image_get_active_layer(image_ID); if(local_vals.smoothstep) { gtk_label_set_text(GTK_LABEL(progress_label), "Smoothing"); /** * Filter "Blur" applied * Standard plug-in. Source code ships with GIMP. */ if (plug_in_blur_connector(image_ID, normalmap_ID) != 1) return; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.20); } else { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.20); } if(local_vals.invh) { /** * Colors Menu->Invert * Standard plug-in. Source code ships with GIMP. */ if (plug_in_vinvert_connector(image_ID, normalmap_ID) != 1) return; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.25); } else { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.25); } /** Here is _p Displacement drawable. */ pDrawables.drawable_p = gimp_drawable_get(normalmap_ID); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.30); /** Extra layer here. */ /** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */ gtk_label_set_text(GTK_LABEL(progress_label), "Base Mapping"); doBaseMap(image_ID, diffuse_ID, local_vals.Depth, local_vals.LargeDetails, local_vals.ao); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.35); normalmap_ID = gimp_image_get_active_layer(image_ID); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.40); /** Here is _ln low normal. l l l l l l l l l l l l l l l l */ if (gcNeedNormal == 'l') { pDrawables.drawable_n = gimp_drawable_get(normalmap_ID); } /** Creates an extra layer. */ /** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */ shapeRecognise(image_ID, normalmap_ID, local_vals.ShapeRecog, local_vals.ao); if(local_vals.smoothstep) { normalmap_ID = gimp_image_get_active_layer(image_ID); gtk_label_set_text(GTK_LABEL(progress_label), "Smoothing"); /** * Filter "Blur" applied * Standard plug-in. Source code ships with GIMP. */ if (plug_in_blur_connector(image_ID, normalmap_ID) != 1) return; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.45); } else { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.45); } /** Here is _sn super normal. s s s s s s s s s s s s s s s s */ if (gcNeedNormal == 's') { pDrawables.drawable_n = gimp_drawable_get(normalmap_ID); } gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.50); gtk_label_set_text(GTK_LABEL(progress_label), "Sharpen"); /** Creates an extra layer. */ /** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */ sharpen(image_ID, diffuse_ID, local_vals.Depth, 0, local_vals.SmallDetails); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.55); normalmap_ID = gimp_image_get_active_layer(image_ID); gtk_label_set_text(GTK_LABEL(progress_label), "Sharpen more"); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.65); /** * Filter Enhance "Sharpen" applied * Standard plug-in. Source code ships with GIMP. */ if (plug_in_sharpen_connector(image_ID, normalmap_ID, 20) != 1) return; /** Here is _hn high normal. h h h h h h h h h h h h h h h h */ if (gcNeedNormal == 'h') { pDrawables.drawable_n = gimp_drawable_get(normalmap_ID); } gtk_label_set_text(GTK_LABEL(progress_label), "Sharpen again"); /** Creates an extra layer. */ /** LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL */ sharpen(image_ID, diffuse_ID, local_vals.Depth, 6, local_vals.MediumDetails); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.70); normalmap_ID = gimp_image_get_active_layer(image_ID); gtk_label_set_text(GTK_LABEL(progress_label), "Smoothing"); /** * Filter "Blur" applied * Standard plug-in. Source code ships with GIMP. */ if (plug_in_blur_connector(image_ID, normalmap_ID) != 1) return; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.75); /** Here is _mn medium normal m m m m m m m m m m m m m m m m */ if (gcNeedNormal == 'm') { pDrawables.drawable_n = gimp_drawable_get(normalmap_ID); } gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.78); gimp_drawable_set_visible(diffuse_ID, 0); /** * Don't do the next line: * * gimp_image_merge_visible_layers(image_ID, 0); * * Do this instead for preview: */ mergedLayer_ID = gimp_layer_new_from_visible(image_ID, image_ID, "temp"); /** Add copied layer to image. */ gimp_image_add_layer(image_ID, mergedLayer_ID, -1); }
static gboolean nsgtk_window_draw_event(GtkWidget *widget, cairo_t *cr, gpointer data) { struct gui_window *gw = data; struct gui_window *z; struct rect clip; struct redraw_context ctx = { .interactive = true, .background_images = true, .plot = &nsgtk_plotters }; double x1; double y1; double x2; double y2; assert(gw); assert(gw->bw); for (z = window_list; z && z != gw; z = z->next) continue; assert(z); assert(GTK_WIDGET(gw->layout) == widget); current_widget = (GtkWidget *)gw->layout; current_cr = cr; cairo_clip_extents(cr, &x1, &y1, &x2, &y2); clip.x0 = x1; clip.y0 = y1; clip.x1 = x2; clip.y1 = y2; browser_window_redraw(gw->bw, 0, 0, &clip, &ctx); if (gw->careth != 0) { nsgtk_plot_caret(gw->caretx, gw->carety, gw->careth); } current_widget = NULL; return FALSE; } #else static gboolean nsgtk_window_draw_event(GtkWidget *widget, GdkEventExpose *event, gpointer data) { struct gui_window *gw = data; struct gui_window *z; struct rect clip; struct redraw_context ctx = { .interactive = true, .background_images = true, .plot = &nsgtk_plotters }; assert(gw); assert(gw->bw); for (z = window_list; z && z != gw; z = z->next) continue; assert(z); assert(GTK_WIDGET(gw->layout) == widget); current_widget = (GtkWidget *)gw->layout; current_cr = gdk_cairo_create(nsgtk_layout_get_bin_window(gw->layout)); clip.x0 = event->area.x; clip.y0 = event->area.y; clip.x1 = event->area.x + event->area.width; clip.y1 = event->area.y + event->area.height; browser_window_redraw(gw->bw, 0, 0, &clip, &ctx); if (gw->careth != 0) { nsgtk_plot_caret(gw->caretx, gw->carety, gw->careth); } cairo_destroy(current_cr); current_widget = NULL; return FALSE; } #endif static gboolean nsgtk_window_motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data) { struct gui_window *g = data; bool shift = event->state & GDK_SHIFT_MASK; bool ctrl = event->state & GDK_CONTROL_MASK; if ((abs(event->x - g->last_x) < 5) && (abs(event->y - g->last_y) < 5)) { /* Mouse hasn't moved far enough from press coordinate for this * to be considered a drag. */ return FALSE; } else { /* This is a drag, ensure it's always treated as such, even if * we drag back over the press location */ g->last_x = INT_MIN; g->last_y = INT_MIN; } if (g->mouse.state & BROWSER_MOUSE_PRESS_1) { /* Start button 1 drag */ browser_window_mouse_click(g->bw, BROWSER_MOUSE_DRAG_1, g->mouse.pressed_x, g->mouse.pressed_y); /* Replace PRESS with HOLDING and declare drag in progress */ g->mouse.state ^= (BROWSER_MOUSE_PRESS_1 | BROWSER_MOUSE_HOLDING_1); g->mouse.state |= BROWSER_MOUSE_DRAG_ON; } else if (g->mouse.state & BROWSER_MOUSE_PRESS_2) { /* Start button 2 drag */ browser_window_mouse_click(g->bw, BROWSER_MOUSE_DRAG_2, g->mouse.pressed_x, g->mouse.pressed_y); /* Replace PRESS with HOLDING and declare drag in progress */ g->mouse.state ^= (BROWSER_MOUSE_PRESS_2 | BROWSER_MOUSE_HOLDING_2); g->mouse.state |= BROWSER_MOUSE_DRAG_ON; } /* Handle modifiers being removed */ if (g->mouse.state & BROWSER_MOUSE_MOD_1 && !shift) g->mouse.state ^= BROWSER_MOUSE_MOD_1; if (g->mouse.state & BROWSER_MOUSE_MOD_2 && !ctrl) g->mouse.state ^= BROWSER_MOUSE_MOD_2; browser_window_mouse_track(g->bw, g->mouse.state, event->x / g->bw->scale, event->y / g->bw->scale); return TRUE; } static gboolean nsgtk_window_button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data) { struct gui_window *g = data; gtk_widget_grab_focus(GTK_WIDGET(g->layout)); gtk_widget_hide(GTK_WIDGET(nsgtk_scaffolding_history_window( g->scaffold)->window)); g->mouse.pressed_x = event->x / g->bw->scale; g->mouse.pressed_y = event->y / g->bw->scale; switch (event->button) { case 1: /* Left button, usually. Pass to core as BUTTON 1. */ g->mouse.state = BROWSER_MOUSE_PRESS_1; break; case 2: /* Middle button, usually. Pass to core as BUTTON 2 */ g->mouse.state = BROWSER_MOUSE_PRESS_2; break; case 3: /* Right button, usually. Action button, context menu. */ browser_window_remove_caret(g->bw); nsgtk_scaffolding_popup_menu(g->scaffold, g->mouse.pressed_x, g->mouse.pressed_y); return TRUE; default: return FALSE; } /* Handle the modifiers too */ if (event->state & GDK_SHIFT_MASK) g->mouse.state |= BROWSER_MOUSE_MOD_1; if (event->state & GDK_CONTROL_MASK) g->mouse.state |= BROWSER_MOUSE_MOD_2; /* Record where we pressed, for use when determining whether to start * a drag in motion notify events. */ g->last_x = event->x; g->last_y = event->y; browser_window_mouse_click(g->bw, g->mouse.state, g->mouse.pressed_x, g->mouse.pressed_y); return TRUE; } static gboolean nsgtk_window_button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data) { struct gui_window *g = data; bool shift = event->state & GDK_SHIFT_MASK; bool ctrl = event->state & GDK_CONTROL_MASK; /* If the mouse state is PRESS then we are waiting for a release to emit * a click event, otherwise just reset the state to nothing */ if (g->mouse.state & BROWSER_MOUSE_PRESS_1) g->mouse.state ^= (BROWSER_MOUSE_PRESS_1 | BROWSER_MOUSE_CLICK_1); else if (g->mouse.state & BROWSER_MOUSE_PRESS_2) g->mouse.state ^= (BROWSER_MOUSE_PRESS_2 | BROWSER_MOUSE_CLICK_2); /* Handle modifiers being removed */ if (g->mouse.state & BROWSER_MOUSE_MOD_1 && !shift) g->mouse.state ^= BROWSER_MOUSE_MOD_1; if (g->mouse.state & BROWSER_MOUSE_MOD_2 && !ctrl) g->mouse.state ^= BROWSER_MOUSE_MOD_2; if (g->mouse.state & (BROWSER_MOUSE_CLICK_1|BROWSER_MOUSE_CLICK_2)) { browser_window_mouse_click(g->bw, g->mouse.state, event->x / g->bw->scale, event->y / g->bw->scale); } else { browser_window_mouse_track(g->bw, 0, event->x / g->bw->scale, event->y / g->bw->scale); } g->mouse.state = 0; return TRUE; } static gboolean nsgtk_window_scroll_event(GtkWidget *widget, GdkEventScroll *event, gpointer data) { struct gui_window *g = data; double value; GtkAdjustment *vscroll = nsgtk_layout_get_vadjustment(g->layout); GtkAdjustment *hscroll = nsgtk_layout_get_hadjustment(g->layout); GtkAllocation alloc; LOG(("%d", event->direction)); switch (event->direction) { case GDK_SCROLL_LEFT: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, -100, 0) != true) { /* core did not handle event do horizontal scroll */ value = gtk_adjustment_get_value(hscroll) - (nsgtk_adjustment_get_step_increment(hscroll) *2); if (value < nsgtk_adjustment_get_lower(hscroll)) { value = nsgtk_adjustment_get_lower(hscroll); } gtk_adjustment_set_value(hscroll, value); } break; case GDK_SCROLL_UP: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, 0, -100) != true) { /* core did not handle event change vertical * adjustment. */ value = gtk_adjustment_get_value(vscroll) - (nsgtk_adjustment_get_step_increment(vscroll) * 2); if (value < nsgtk_adjustment_get_lower(vscroll)) { value = nsgtk_adjustment_get_lower(vscroll); } gtk_adjustment_set_value(vscroll, value); } break; case GDK_SCROLL_RIGHT: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, 100, 0) != true) { /* core did not handle event change horizontal * adjustment. */ value = gtk_adjustment_get_value(hscroll) + (nsgtk_adjustment_get_step_increment(hscroll) * 2); /* @todo consider gtk_widget_get_allocated_width() */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); if (value > nsgtk_adjustment_get_upper(hscroll) - alloc.width) { value = nsgtk_adjustment_get_upper(hscroll) - alloc.width; } gtk_adjustment_set_value(hscroll, value); } break; case GDK_SCROLL_DOWN: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, 0, 100) != true) { /* core did not handle event change vertical * adjustment. */ value = gtk_adjustment_get_value(vscroll) + (nsgtk_adjustment_get_step_increment(vscroll) * 2); /* @todo consider gtk_widget_get_allocated_height */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); if (value > nsgtk_adjustment_get_upper(vscroll) - alloc.height) { value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; } gtk_adjustment_set_value(vscroll, value); } break; default: break; } return TRUE; } static gboolean nsgtk_window_keypress_event(GtkWidget *widget, GdkEventKey *event, gpointer data) { struct gui_window *g = data; uint32_t nskey = gtk_gui_gdkkey_to_nskey(event); if (browser_window_key_press(g->bw, nskey)) return TRUE; if ((event->state & 0x7) != 0) return TRUE; double value; GtkAdjustment *vscroll = nsgtk_layout_get_vadjustment(g->layout); GtkAdjustment *hscroll = nsgtk_layout_get_hadjustment(g->layout); GtkAllocation alloc; /* @todo consider gtk_widget_get_allocated_width() */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); switch (event->keyval) { case GDK_KEY(Home): case GDK_KEY(KP_Home): value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(End): case GDK_KEY(KP_End): value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; if (value < nsgtk_adjustment_get_lower(vscroll)) value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Left): case GDK_KEY(KP_Left): value = gtk_adjustment_get_value(hscroll) - nsgtk_adjustment_get_step_increment(hscroll); if (value < nsgtk_adjustment_get_lower(hscroll)) value = nsgtk_adjustment_get_lower(hscroll); gtk_adjustment_set_value(hscroll, value); break; case GDK_KEY(Up): case GDK_KEY(KP_Up): value = gtk_adjustment_get_value(vscroll) - nsgtk_adjustment_get_step_increment(vscroll); if (value < nsgtk_adjustment_get_lower(vscroll)) value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Right): case GDK_KEY(KP_Right): value = gtk_adjustment_get_value(hscroll) + nsgtk_adjustment_get_step_increment(hscroll); if (value > nsgtk_adjustment_get_upper(hscroll) - alloc.width) value = nsgtk_adjustment_get_upper(hscroll) - alloc.width; gtk_adjustment_set_value(hscroll, value); break; case GDK_KEY(Down): case GDK_KEY(KP_Down): value = gtk_adjustment_get_value(vscroll) + nsgtk_adjustment_get_step_increment(vscroll); if (value > nsgtk_adjustment_get_upper(vscroll) - alloc.height) value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Page_Up): case GDK_KEY(KP_Page_Up): value = gtk_adjustment_get_value(vscroll) - nsgtk_adjustment_get_page_increment(vscroll); if (value < nsgtk_adjustment_get_lower(vscroll)) value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Page_Down): case GDK_KEY(KP_Page_Down): value = gtk_adjustment_get_value(vscroll) + nsgtk_adjustment_get_page_increment(vscroll); if (value > nsgtk_adjustment_get_upper(vscroll) - alloc.height) value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; gtk_adjustment_set_value(vscroll, value); break; default: break; } return TRUE; } static gboolean nsgtk_window_size_allocate_event(GtkWidget *widget, GtkAllocation *allocation, gpointer data) { struct gui_window *g = data; g->bw->reformat_pending = true; browser_reformat_pending = true; if (g->paned != NULL) { /* Set status bar / scroll bar proportion according to * option_toolbar_status_width */ /* TODO: Probably want to detect when the user adjusts the * status bar width, remember that proportion for the * window, and use that here. */ gtk_paned_set_position(g->paned, (nsoption_int(toolbar_status_width) * allocation->width) / 10000); } return TRUE; } /* Core interface docuemnted in desktop/gui.h to create a gui_window */ struct gui_window *gui_create_browser_window(struct browser_window *bw, struct browser_window *clone, bool new_tab) { struct gui_window *g; /**< what we're creating to return */ g = calloc(1, sizeof(*g)); if (!g) { warn_user("NoMemory", 0); return 0; } LOG(("Creating gui window %p for browser window %p", g, bw)); g->bw = bw; g->paned = NULL; g->mouse.state = 0; g->current_pointer = GUI_POINTER_DEFAULT; if (clone != NULL) { bw->scale = clone->scale; } else { bw->scale = (float) nsoption_int(scale) / 100.0; } g->careth = 0; if (new_tab) { assert(clone != NULL); g->scaffold = clone->window->scaffold; } else { /* Now construct and attach a scaffold */ g->scaffold = nsgtk_new_scaffolding(g); } if (g->scaffold == NULL) { warn_user("NoMemory", 0); free(g); return NULL; } /* Construct our primary elements */ /* top-level document (not a frame) => create a new tab */ GError* error = NULL; GtkBuilder* xml = gtk_builder_new(); if (!gtk_builder_add_from_file(xml, glade_file_location->tabcontents, &error)) { g_warning ("Couldn't load builder file: %s", error->message); g_error_free(error); return 0; } g->layout = GTK_LAYOUT(gtk_builder_get_object(xml, "layout")); g->status_bar = GTK_LABEL(gtk_builder_get_object(xml, "status_bar")); g->paned = GTK_PANED(gtk_builder_get_object(xml, "hpaned1")); /* connect the scrollbars to the layout widget */ nsgtk_layout_set_hadjustment(g->layout, gtk_range_get_adjustment(GTK_RANGE( gtk_builder_get_object(xml, "hscrollbar")))); nsgtk_layout_set_vadjustment(g->layout, gtk_range_get_adjustment(GTK_RANGE( gtk_builder_get_object(xml, "vscrollbar")))); /* add the tab to the scaffold */ bool tempback = true; switch (temp_open_background) { case -1: tempback = !(nsoption_bool(focus_new)); break; case 0: tempback = false; break; case 1: tempback = true; break; } GtkWidget *tab_contents = GTK_WIDGET(gtk_builder_get_object(xml, "tabContents")); g_object_set_data(G_OBJECT(tab_contents), "gui_window", g); nsgtk_tab_add(g, tab_contents, tempback); g_object_unref(xml); /* Attach ourselves to the list (push_top) */ if (window_list) window_list->prev = g; g->next = window_list; g->prev = NULL; window_list = g; /* set the events we're interested in receiving from the browser's * drawing area. */ gtk_widget_add_events(GTK_WIDGET(g->layout), GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_SCROLL_MASK); nsgtk_widget_set_can_focus(GTK_WIDGET(g->layout), TRUE); /* set the default background colour of the drawing area to white. */ nsgtk_widget_override_background_color(GTK_WIDGET(g->layout), GTK_STATE_NORMAL, 0, 0xffff, 0xffff, 0xffff); nsgtk_connect_draw_event(GTK_WIDGET(g->layout), G_CALLBACK(nsgtk_window_draw_event), g); #define CONNECT(obj, sig, callback, ptr) \ g_signal_connect(G_OBJECT(obj), (sig), G_CALLBACK(callback), (ptr)) CONNECT(g->layout, "motion_notify_event", nsgtk_window_motion_notify_event, g); g->signalhandler[NSGTK_WINDOW_SIGNAL_CLICK] = CONNECT(g->layout, "button_press_event", nsgtk_window_button_press_event, g); CONNECT(g->layout, "button_release_event", nsgtk_window_button_release_event, g); CONNECT(g->layout, "key_press_event", nsgtk_window_keypress_event, g); CONNECT(g->layout, "size_allocate", nsgtk_window_size_allocate_event, g); CONNECT(g->layout, "scroll_event", nsgtk_window_scroll_event, g); return g; } void nsgtk_reflow_all_windows(void) { for (struct gui_window *g = window_list; g; g = g->next) { nsgtk_tab_options_changed( nsgtk_scaffolding_notebook(g->scaffold)); g->bw->reformat_pending = true; } browser_reformat_pending = true; } /** * Process pending reformats */ void nsgtk_window_process_reformats(void) { struct gui_window *g; GtkAllocation alloc; browser_reformat_pending = false; for (g = window_list; g; g = g->next) { if (!g->bw->reformat_pending) continue; g->bw->reformat_pending = false; /* @todo consider gtk_widget_get_allocated_width() */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); browser_window_reformat(g->bw, false, alloc.width, alloc.height); } } void nsgtk_window_destroy_browser(struct gui_window *g) { browser_window_destroy(g->bw); } void gui_window_destroy(struct gui_window *g) { if (g->prev) g->prev->next = g->next; else window_list = g->next; if (g->next) g->next->prev = g->prev; LOG(("Destroying gui_window %p", g)); assert(g != NULL); assert(g->bw != NULL); LOG((" Scaffolding: %p", g->scaffold)); LOG((" Window name: %s", g->bw->name)); /* tab => remove tab */ gtk_widget_destroy(gtk_widget_get_parent(GTK_WIDGET(g->layout))); } /** * set favicon */ void gui_window_set_icon(struct gui_window *gw, hlcache_handle *icon) { struct bitmap *icon_bitmap = NULL; /* free any existing icon */ if (gw->icon != NULL) { g_object_unref(gw->icon); gw->icon = NULL; } if (icon != NULL) { icon_bitmap = content_get_bitmap(icon); if (icon_bitmap != NULL) { LOG(("Using %p bitmap", icon_bitmap)); gw->icon = nsgdk_pixbuf_get_from_surface(icon_bitmap->surface, 16, 16); } } if (gw->icon == NULL) { LOG(("Using default favicon")); g_object_ref(favicon_pixbuf); gw->icon = favicon_pixbuf; } nsgtk_scaffolding_set_icon(gw); } static void nsgtk_redraw_caret(struct gui_window *g) { int sx, sy; if (g->careth == 0) return; gui_window_get_scroll(g, &sx, &sy); gtk_widget_queue_draw_area(GTK_WIDGET(g->layout), g->caretx - sx, g->carety - sy, 1, g->careth + 1); }
bool wxNotebook::InsertPage( size_t position, wxNotebookPage* win, const wxString& text, bool select, int imageId ) { wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") ); wxCHECK_MSG( win->GetParent() == this, FALSE, wxT("Can't add a page whose parent is not the notebook!") ); wxCHECK_MSG( position <= GetPageCount(), FALSE, wxT("invalid page index in wxNotebookPage::InsertPage()") ); // Hack Alert! (Part II): See above in wxInsertChildInNotebook callback // why this has to be done. NOTE: using gtk_widget_unparent here does not // work as it seems to undo too much and will cause errors in the // gtk_notebook_insert_page below, so instead just clear the parent by // hand here. win->m_widget->parent = NULL; // don't receive switch page during addition gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget), GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this ); if (m_themeEnabled) win->SetThemeEnabled(true); GtkNotebook *notebook = GTK_NOTEBOOK(m_widget); wxGtkNotebookPage *nb_page = new wxGtkNotebookPage(); if ( position == GetPageCount() ) m_pagesData.Append( nb_page ); else m_pagesData.Insert( position, nb_page ); m_pages.Insert(win, position); nb_page->m_box = gtk_hbox_new( FALSE, 1 ); gtk_container_border_width( GTK_CONTAINER(nb_page->m_box), 2 ); gtk_signal_connect( GTK_OBJECT(win->m_widget), "size_allocate", GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)win ); gtk_notebook_insert_page( notebook, win->m_widget, nb_page->m_box, position ); nb_page->m_page = (GtkNotebookPage*) g_list_last(notebook->children)->data; /* set the label image */ nb_page->m_image = imageId; if (imageId != -1) { wxASSERT( HasImageList() ); const wxBitmap *bmp = GetImageList()->GetBitmapPtr(imageId); GdkPixmap *pixmap = bmp->GetPixmap(); GdkBitmap *mask = NULL; if ( bmp->GetMask() ) { mask = bmp->GetMask()->GetBitmap(); } GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask ); gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding); gtk_widget_show(pixmapwid); } /* set the label text */ nb_page->m_text = text; if (nb_page->m_text.empty()) nb_page->m_text = wxEmptyString; nb_page->m_label = GTK_LABEL( gtk_label_new(wxGTK_CONV(nb_page->m_text)) ); gtk_box_pack_end( GTK_BOX(nb_page->m_box), GTK_WIDGET(nb_page->m_label), FALSE, FALSE, m_padding ); /* apply current style */ GtkRcStyle *style = CreateWidgetStyle(); if ( style ) { gtk_widget_modify_style(GTK_WIDGET(nb_page->m_label), style); gtk_rc_style_unref(style); } /* show the label */ gtk_widget_show( GTK_WIDGET(nb_page->m_label) ); if (select && (m_pagesData.GetCount() > 1)) { SetSelection( position ); } gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page", GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this ); InvalidateBestSize(); return true; }
void cb_image_uploaded (ScreenshooterJob *job, gchar *upload_name, gchar **last_user) { GtkWidget *dialog; GtkWidget *main_alignment, *vbox; GtkWidget *link_label; GtkWidget *image_link, *thumbnail_link, *small_thumbnail_link; GtkWidget *example_label, *html_label, *bb_label; GtkWidget *html_code_view, *bb_code_view; GtkWidget *html_frame, *bb_frame; GtkWidget *links_alignment, *code_alignment; GtkWidget *links_box, *code_box; GtkTextBuffer *html_buffer, *bb_buffer; const gchar *image_url, *thumbnail_url, *small_thumbnail_url; const gchar *image_markup, *thumbnail_markup, *small_thumbnail_markup; const gchar *html_code, *bb_code; gchar *job_type, *title; gchar *last_user_temp; g_return_if_fail (upload_name != NULL); job_type = g_object_get_data(G_OBJECT (job), "jobtype"); if (!strcmp(job_type, "imgur")) { title = _("My screenshot on Imgur"); image_url = g_strdup_printf ("http://i.imgur.com/%s.png", upload_name); thumbnail_url = g_strdup_printf ("http://imgur.com/%sl.png", upload_name); small_thumbnail_url = g_strdup_printf ("http://imgur.com/%ss.png", upload_name); } else { g_return_if_fail (last_user == NULL || *last_user == NULL); title = _("My screenshot on ZimageZ"); image_url = g_strdup_printf ("http://www.zimagez.com/zimage/%s.php", upload_name); thumbnail_url = g_strdup_printf ("http://www.zimagez.com/miniature/%s.php", upload_name); small_thumbnail_url = g_strdup_printf ("http://www.zimagez.com/avatar/%s.php", upload_name); last_user_temp = g_object_get_data (G_OBJECT (job), "user"); if (last_user_temp == NULL) last_user_temp = g_strdup (""); *last_user = g_strdup (last_user_temp); } image_markup = g_markup_printf_escaped (_("<a href=\"%s\">Full size image</a>"), image_url); thumbnail_markup = g_markup_printf_escaped (_("<a href=\"%s\">Large thumbnail</a>"), thumbnail_url); small_thumbnail_markup = g_markup_printf_escaped (_("<a href=\"%s\">Small thumbnail</a>"), small_thumbnail_url); html_code = g_markup_printf_escaped ("<a href=\"%s\">\n <img src=\"%s\" />\n</a>", image_url, thumbnail_url); bb_code = g_strdup_printf ("[url=%s]\n [img]%s[/img]\n[/url]", image_url, thumbnail_url); /* Dialog */ dialog = xfce_titled_dialog_new_with_buttons (title, NULL, GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 0); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 12); gtk_window_set_icon_name (GTK_WINDOW (dialog), "applications-internet"); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); /* Create the main alignment for the dialog */ main_alignment = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (main_alignment), 6, 0, 10, 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_alignment, TRUE, TRUE, 0); /* Create the main box for the dialog */ vbox = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_add (GTK_CONTAINER (main_alignment), vbox); /* Links bold label */ link_label = gtk_label_new (""); gtk_label_set_markup (GTK_LABEL (link_label), _("<span weight=\"bold\" stretch=\"semiexpanded\">" "Links</span>")); gtk_misc_set_alignment (GTK_MISC (link_label), 0, 0); gtk_container_add (GTK_CONTAINER (vbox), link_label); /* Links alignment */ links_alignment = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (links_alignment), 0, 0, 12, 0); gtk_container_add (GTK_CONTAINER (vbox), links_alignment); /* Links box */ links_box = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (links_box), 0); gtk_container_add (GTK_CONTAINER (links_alignment), links_box); /* Create the image link */ image_link = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (image_link), image_markup); gtk_misc_set_alignment (GTK_MISC (image_link), 0, 0); gtk_widget_set_tooltip_text (image_link, image_url); gtk_container_add (GTK_CONTAINER (links_box), image_link); /* Create the thumbnail link */ thumbnail_link = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (thumbnail_link), thumbnail_markup); gtk_misc_set_alignment (GTK_MISC (thumbnail_link), 0, 0); gtk_widget_set_tooltip_text (thumbnail_link, thumbnail_url); gtk_container_add (GTK_CONTAINER (links_box), thumbnail_link); /* Create the small thumbnail link */ small_thumbnail_link = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (small_thumbnail_link), small_thumbnail_markup); gtk_misc_set_alignment (GTK_MISC (small_thumbnail_link), 0, 0); gtk_widget_set_tooltip_text (small_thumbnail_link, small_thumbnail_url); gtk_container_add (GTK_CONTAINER (links_box), small_thumbnail_link); /* Examples bold label */ example_label = gtk_label_new (""); gtk_label_set_markup (GTK_LABEL (example_label), _("<span weight=\"bold\" stretch=\"semiexpanded\">" "Code for a thumbnail pointing to the full size image</span>")); gtk_misc_set_alignment (GTK_MISC (example_label), 0, 0); gtk_container_add (GTK_CONTAINER (vbox), example_label); /* Code alignment */ code_alignment = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (code_alignment), 0, 0, 12, 0); gtk_container_add (GTK_CONTAINER (vbox), code_alignment); /* Links box */ code_box = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (code_box), 0); gtk_container_add (GTK_CONTAINER (code_alignment), code_box); /* HTML title */ html_label = gtk_label_new (_("HTML")); gtk_misc_set_alignment (GTK_MISC (html_label), 0, 0); gtk_container_add (GTK_CONTAINER (code_box), html_label); /* HTML frame */ html_frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (html_frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (code_box), html_frame); /* HTML code text view */ html_buffer = gtk_text_buffer_new (NULL); gtk_text_buffer_set_text (html_buffer, html_code, -1); html_code_view = gtk_text_view_new_with_buffer (html_buffer); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (html_code_view), 10); gtk_text_view_set_editable (GTK_TEXT_VIEW (html_code_view), FALSE); gtk_container_add (GTK_CONTAINER (html_frame), html_code_view); /* BB title */ bb_label = gtk_label_new (_("BBCode for forums")); gtk_misc_set_alignment (GTK_MISC (bb_label), 0, 0); gtk_container_add (GTK_CONTAINER (code_box), bb_label); /* BB frame */ bb_frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (bb_frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (code_box), bb_frame); /* BBcode text view */ bb_buffer = gtk_text_buffer_new (NULL); gtk_text_buffer_set_text (bb_buffer, bb_code, -1); bb_code_view = gtk_text_view_new_with_buffer (bb_buffer); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (bb_code_view), 10); gtk_text_view_set_editable (GTK_TEXT_VIEW (bb_code_view), FALSE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (bb_code_view), GTK_WRAP_CHAR); gtk_container_add (GTK_CONTAINER (bb_frame), bb_code_view); /* Show the dialog and run it */ gtk_widget_show_all (GTK_DIALOG(dialog)->vbox); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); g_object_unref (html_buffer); g_object_unref (bb_buffer); }