static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpParasite *parasite; gint32 image; gint32 drawable; gint32 orig_image; GimpExportReturn export = GIMP_EXPORT_CANCEL; GError *error = NULL; run_mode = param[0].data.d_int32; INIT_I18N (); gegl_init (NULL, NULL); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; TIFFSetWarningHandler (tiff_warning); TIFFSetErrorHandler (tiff_error); if ((strcmp (name, SAVE_PROC) == 0) || (strcmp (name, SAVE2_PROC) == 0)) { /* Plug-in is either file_tiff_save or file_tiff_save2 */ image = orig_image = param[1].data.d_int32; drawable = param[2].data.d_int32; /* Do this right this time, if POSSIBLE query for parasites, otherwise or if there isn't one, choose the default comment from the gimprc. */ /* eventually export the image */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: case GIMP_RUN_WITH_LAST_VALS: gimp_ui_init (PLUG_IN_BINARY, FALSE); export = gimp_export_image (&image, &drawable, NULL, (GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_INDEXED | GIMP_EXPORT_CAN_HANDLE_ALPHA )); if (export == GIMP_EXPORT_CANCEL) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } break; default: break; }
static gint separate_import_dialog (SeparateContext *sc) { sc->dialogresult = FALSE; gimp_ui_init( "separate_import", FALSE ); sc->filenamefileselector = gtk_file_chooser_dialog_new( _("Import separated TIFF..."), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL ); gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( sc->filenamefileselector ), sc->filename ); sc->dialogresult = gtk_dialog_run( GTK_DIALOG( sc->filenamefileselector ) ); if ( sc->dialogresult == GTK_RESPONSE_ACCEPT ) { g_free( sc->filename ); sc->filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( sc->filenamefileselector ) ); sc->dialogresult = TRUE; } else { g_free( sc->filename ); sc->filename = NULL; sc->dialogresult = FALSE; } gtk_widget_destroy( sc->filenamefileselector ); return sc->dialogresult; }
static gboolean ico_save_dialog (gint32 image_ID, IcoSaveInfo *info) { GtkWidget *dialog; gint i; gint response; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = ico_dialog_new (info); for (i = 0; i < info->num_icons; i++) { /* if (gimp_layer_get_visible(layers[i])) */ ico_dialog_add_icon (dialog, info->layers[i], i); } /* Scale the thing to approximately fit its content, but not too large ... */ gtk_window_set_default_size (GTK_WINDOW (dialog), -1, 200 + (info->num_icons > 4 ? 500 : info->num_icons * 120)); gtk_widget_show (dialog); response = gimp_dialog_run (GIMP_DIALOG (dialog)); gtk_widget_destroy (dialog); return (response == GTK_RESPONSE_OK); }
/* show our results */ static void doDialog (void) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *frame; GtkWidget *preview; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Colorcube Analysis"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gimp_window_set_transient (GTK_WINDOW (dialog)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); /* use preview for histogram window */ preview = gimp_preview_area_new (); gtk_widget_set_size_request (preview, PREWIDTH, PREHEIGHT); gtk_container_add (GTK_CONTAINER (frame), preview); /* output results */ doLabel (vbox, _("Image dimensions: %d × %d"), width, height); if (uniques == 0) doLabel (vbox, _("No colors")); else if (uniques == 1) doLabel (vbox, _("Only one unique color")); else doLabel (vbox, _("Number of unique colors: %d"), uniques); /* show stuff */ gtk_widget_show_all (dialog); fillPreview (preview); gimp_dialog_run (GIMP_DIALOG (dialog)); gtk_widget_destroy (dialog); }
static GimpPDBStatusType run_pspi (const gchar *pdb_name, gint n_params, const GimpParam *param) { GimpRunMode run_mode = param[0].data.d_int32; GimpDrawable *drawable; GimpPDBStatusType status = GIMP_PDB_SUCCESS; PSPlugInEntry *pspie; gint x1, y1, x2, y2; get_saved_plugin_data (); if ((pspie = g_hash_table_lookup (entry_hash, pdb_name)) != NULL) { gchar *name; if (run_mode == GIMP_RUN_NONINTERACTIVE) { if (n_params != standard_nargs) return GIMP_PDB_CALLING_ERROR; } else if (run_mode == GIMP_RUN_INTERACTIVE) { if ((status = pspi_params (pspie)) != GIMP_PDB_SUCCESS) return status; } drawable = gimp_drawable_get (param[2].data.d_drawable); gimp_ui_init (PLUGIN_NAME, TRUE); if ((status = pspi_prepare (pspie, drawable)) != GIMP_PDB_SUCCESS) return status; name = g_strdup_printf (_("Applying %s:"), strrchr (pspie->menu_path, '/') + 1); gimp_progress_init (name); g_free (name); if ((status = pspi_apply (pspie, drawable)) != GIMP_PDB_SUCCESS) return status; gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); gimp_displays_flush (); return GIMP_PDB_SUCCESS; } return GIMP_PDB_CALLING_ERROR; }
gboolean uri_backend_init (const gchar *plugin_name, gboolean run, GimpRunMode run_mode, GError **error) { if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_ui_init (plugin_name, FALSE); } return TRUE; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpRunMode run_mode; run_mode = param[0].data.d_int32; *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_SUCCESS; INIT_I18N (); switch (run_mode) { case GIMP_RUN_INTERACTIVE: { GtkWidget *dialog; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_proc_browser_dialog_new (_("Procedure Browser"), PLUG_IN_BINARY, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } break; case GIMP_RUN_WITH_LAST_VALS: case GIMP_RUN_NONINTERACTIVE: g_warning (PLUG_IN_PROC " allows only interactive invocation"); values[0].data.d_status = GIMP_PDB_CALLING_ERROR; break; default: break; } }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpExportReturn export = GIMP_EXPORT_CANCEL; run_mode = param[0].data.d_int32; *nreturn_vals = 1; *return_vals = values; INIT_I18N (); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; if (run_mode == GIMP_RUN_INTERACTIVE && strcmp (name, SAVE_PROC) == 0) { gint32 image_ID = param[1].data.d_int32; gint32 drawable_ID = param[2].data.d_int32; GimpParasite *parasite; gchar *x; GimpImageType drawable_type = gimp_drawable_type (drawable_ID); gimp_get_data (SAVE_PROC, &config); config.prefixed_name = "gimp_image"; config.comment = NULL; config.file_name = param[3].data.d_string; config.alpha = (drawable_type == GIMP_RGBA_IMAGE || drawable_type == GIMP_GRAYA_IMAGE || drawable_type == GIMP_INDEXEDA_IMAGE); parasite = gimp_image_parasite_find (image_ID, "gimp-comment"); if (parasite) { config.comment = g_strndup (gimp_parasite_data (parasite), gimp_parasite_data_size (parasite)); gimp_parasite_free (parasite); } x = config.comment; gimp_ui_init (PLUG_IN_BINARY, FALSE); export = gimp_export_image (&image_ID, &drawable_ID, "C Source",
static void webx_run (gint32 image_ID, gint32 drawable_ID) { GtkWidget *dlg; gimp_ui_init (PLUG_IN_BINARY, FALSE); global_image_ID = image_ID; global_drawable_ID = drawable_ID; dlg = webx_dialog_new (image_ID, drawable_ID); webx_dialog_run (WEBX_DIALOG (dlg)); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; INIT_I18N (); gegl_init (NULL, NULL); run_mode = param[0].data.d_int32; *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; if (strcmp (name, SAVE_PROC) == 0) { gint32 image_ID; gint32 drawable_ID; GimpExportReturn export = GIMP_EXPORT_CANCEL; image_ID = param[1].data.d_int32; drawable_ID = param[2].data.d_int32; /* eventually export the image */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: case GIMP_RUN_WITH_LAST_VALS: gimp_ui_init (PLUG_IN_BINARY, FALSE); export = gimp_export_image (&image_ID, &drawable_ID, NULL, GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_INDEXED); if (export == GIMP_EXPORT_CANCEL) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } break; default: break; }
/* Build the dialog up. This was the hard part! */ static gint sel2path_dialog (SELVALS *sels) { GtkWidget *dlg; GtkWidget *table; retVal = FALSE; gimp_ui_init (PLUG_IN_BINARY, FALSE); dlg = gimp_dialog_new (_("Selection to Path Advanced Settings"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, "plug-in-sel2path-advanced", GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); g_signal_connect (dlg, "response", G_CALLBACK (sel2path_response), NULL); g_signal_connect (dlg, "destroy", G_CALLBACK (gtk_main_quit), NULL); table = dialog_create_selection_area (sels); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), table, TRUE, TRUE, 0); gtk_widget_show (table); gtk_widget_show (dlg); gtk_main (); return retVal; }
static gboolean octave_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *button_update; gboolean run; //default entries: reset_default(); gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new("Hipstagram", PLUG_IN_BINARY, NULL, (GtkDialogFlags)0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),GTK_RESPONSE_OK,GTK_RESPONSE_CANCEL,-1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox); gtk_widget_show (main_vbox); // preview preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect(preview, "invalidated", G_CALLBACK (preview_update),NULL); // update button button_update = gtk_button_new_with_label("Update"); gtk_box_pack_start (GTK_BOX (main_vbox), button_update, TRUE, TRUE, 0); gtk_widget_show (button_update); g_signal_connect_swapped (button_update, "released", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint output_type = 0; gint32 image_ID; gint32 drawable_ID; GimpExportReturn export = GIMP_EXPORT_CANCEL; INIT_I18N (); /* Set us up to return a status. */ *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; run_mode = param[0].data.d_int32; image_ID = param[1].data.d_int32; drawable_ID = param[2].data.d_int32; /* eventually export the image */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: case GIMP_RUN_WITH_LAST_VALS: gimp_ui_init (PLUG_IN_BINARY, FALSE); export = gimp_export_image (&image_ID, &drawable_ID, "AA", GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_ALPHA); if (export == GIMP_EXPORT_CANCEL) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } break; default: break; }
/* The main GUI function for saving single-paged PDFs */ static gboolean gui_single (void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *vectorize_c; GtkWidget *ignore_hidden_c; GtkWidget *apply_c; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); window = gimp_export_dialog_new ("PDF", PLUG_IN_ROLE, SAVE_PROC); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (window)), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (window), 12); ignore_hidden_c = gtk_check_button_new_with_label (_("Omit hidden layers and layers with zero opacity")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ignore_hidden_c), optimize.ignore_hidden); gtk_box_pack_end (GTK_BOX (vbox), ignore_hidden_c, TRUE, TRUE, 0); vectorize_c = gtk_check_button_new_with_label (_("Convert bitmaps to vector graphics where possible")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vectorize_c), optimize.vectorize); gtk_box_pack_end (GTK_BOX (vbox), vectorize_c, TRUE, TRUE, 0); apply_c = gtk_check_button_new_with_label (_("Apply layer masks before saving")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (apply_c), optimize.apply_masks); gtk_box_pack_end (GTK_BOX (vbox), apply_c, TRUE, TRUE, 0); gimp_help_set_help_data (apply_c, _("Keeping the masks will not change the output"), NULL); gtk_widget_show_all (window); run = gtk_dialog_run (GTK_DIALOG (window)) == GTK_RESPONSE_OK; optimize.ignore_hidden = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ignore_hidden_c)); optimize.vectorize = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vectorize_c)); optimize.apply_masks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (apply_c)); gtk_widget_destroy (window); return run; }
gboolean uri_backend_init (const gchar *plugin_name, gboolean run, GimpRunMode run_mode, GError **error) { if (! gnome_vfs_init ()) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s", "Could not initialize GnomeVFS"); return FALSE; } #ifdef HAVE_GNOMEUI if (run) { if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_ui_init (plugin_name, FALSE); gnome_authentication_manager_init (); } else { #ifdef HAVE_GNOME_KEYRING gnome_vfs_async_module_callback_set_default (GNOME_VFS_MODULE_CALLBACK_FILL_AUTHENTICATION, vfs_async_fill_authentication_callback, GINT_TO_POINTER (0), NULL); gnome_vfs_module_callback_set_default (GNOME_VFS_MODULE_CALLBACK_FILL_AUTHENTICATION, vfs_fill_authentication_callback, GINT_TO_POINTER (0), NULL); #endif /* HAVE_GNOME_KEYRING */ } } #endif /* HAVE_GNOMEUI */ return TRUE; }
static void webx_run (gint32 image_ID, gint32 drawable_ID) { GtkWidget *dlg; gimp_ui_init (PLUG_IN_BINARY, FALSE); global_image_ID = image_ID; global_drawable_ID = drawable_ID; if (gimp_image_width (image_ID) > WEBX_MAX_SIZE || gimp_image_height (image_ID) > WEBX_MAX_SIZE) { gimp_message (_("The image is too large for Save for Web!")); return; } dlg = webx_dialog_new (image_ID, drawable_ID); webx_dialog_run (WEBX_DIALOG (dlg)); }
static GimpPDBStatusType page_setup (gint32 image_ID) { GtkPrintOperation *operation; GimpParam *return_vals; gchar *name; gint n_return_vals; gimp_ui_init (PLUG_IN_BINARY, FALSE); operation = gtk_print_operation_new (); print_page_setup_load (operation, image_ID); print_page_setup_dialog (operation); print_page_setup_save (operation, image_ID); g_object_unref (operation); /* now notify a running print procedure about this change */ name = print_temp_proc_name (image_ID); /* we don't want the core to show an error message if the * temporary procedure does not exist */ gimp_plugin_set_pdb_error_handler (GIMP_PDB_ERROR_HANDLER_PLUGIN); return_vals = gimp_run_procedure (name, &n_return_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); gimp_destroy_params (return_vals, n_return_vals); g_free (name); return GIMP_PDB_SUCCESS; }
/* * snap_dialog * * Bring up the GTK dialog for setting snapshot * parameters. */ static gboolean snap_dialog (void) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkObject *adj; GSList *radio_group = NULL; gint radio_pressed[2]; gint decorations; gboolean run; /* Set defaults */ radio_pressed[0] = (winsnapvals.root == FALSE); radio_pressed[1] = (winsnapvals.root == TRUE); decorations = winsnapvals.decor; /* Init GTK */ gimp_ui_init (PLUG_IN_BINARY, FALSE); /* Main Dialog */ dialog = gimp_dialog_new (PLUG_IN_PRINT_NAME, PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Grab"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); winsnapintf.single_button = gtk_radio_button_new_with_label (radio_group, _("Grab a single window")); gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.single_button, FALSE, FALSE, 0); g_signal_connect (winsnapintf.single_button, "toggled", G_CALLBACK (snap_toggle_update), &radio_pressed[0]); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.single_button), radio_pressed[0]); gtk_widget_show (winsnapintf.single_button); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.single_button)); winsnapintf.root_button = gtk_radio_button_new_with_label (radio_group, _("Grab the whole screen")); gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.root_button, FALSE, FALSE, 0); g_signal_connect (winsnapintf.root_button, "toggled", G_CALLBACK (snap_toggle_update), &radio_pressed[1]); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.root_button), radio_pressed[1]); gtk_widget_show (winsnapintf.root_button); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.root_button)); /* with delay */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("after")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); winsnapintf.delay_spinner = gimp_spin_button_new (&adj, winsnapvals.delay, 0.0, 100.0, 1.0, 5.0, 0.0, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), winsnapintf.delay_spinner, FALSE, FALSE, 0); gtk_widget_show (winsnapintf.delay_spinner); label = gtk_label_new (_("Seconds delay")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); #ifdef CAN_SET_DECOR /* With decorations */ winsnapintf.decor_button = gtk_check_button_new_with_label (_("Include decorations")); g_signal_connect (winsnapintf.decor_button, "toggled", G_CALLBACK (snap_toggle_update), &decorations); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.decor_button), decorations); gtk_box_pack_end (GTK_BOX (vbox), winsnapintf.decor_button, FALSE, FALSE, 0); gtk_widget_set_sensitive (winsnapintf.decor_button, radio_pressed[0]); gtk_widget_show (winsnapintf.decor_button); #endif /* CAN_SET_DECOR */ gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { winsnapvals.root = radio_pressed[1]; winsnapvals.decor = decorations; winsnapvals.delay = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (winsnapintf.delay_spinner)); } gtk_widget_destroy (dialog); return run; }
static gboolean tile_dialog (gint32 image_ID, gint32 drawable_ID) { GtkWidget *dlg; GtkWidget *vbox; GtkWidget *frame; GtkWidget *sizeentry; GtkWidget *chainbutton; GtkWidget *toggle; gint width; gint height; gdouble xres; gdouble yres; GimpUnit unit; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); width = gimp_drawable_width (drawable_ID); height = gimp_drawable_height (drawable_ID); unit = gimp_image_get_unit (image_ID); gimp_image_get_resolution (image_ID, &xres, &yres); tvals.new_width = width; tvals.new_height = height; dlg = gimp_dialog_new (_("Tile"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gimp_frame_new (_("Tile to New Size")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); sizeentry = gimp_coordinates_new (unit, "%a", TRUE, TRUE, 8, GIMP_SIZE_ENTRY_UPDATE_SIZE, tvals.constrain, TRUE, _("_Width:"), width, xres, 1, GIMP_MAX_IMAGE_SIZE, 0, width, _("_Height:"), height, yres, 1, GIMP_MAX_IMAGE_SIZE, 0, height); gtk_container_add (GTK_CONTAINER (frame), sizeentry); gtk_table_set_row_spacing (GTK_TABLE (sizeentry), 1, 6); gtk_widget_show (sizeentry); chainbutton = GTK_WIDGET (GIMP_COORDINATES_CHAINBUTTON (sizeentry)); toggle = gtk_check_button_new_with_mnemonic (_("C_reate new image")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), tvals.new_image); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &tvals.new_image); gtk_widget_show (dlg); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); if (run) { tvals.new_width = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 0)); tvals.new_height = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 1)); tvals.constrain = gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (chainbutton)); } gtk_widget_destroy (dlg); return run; }
static gboolean save_dialog (void) { GtkWidget *dlg; GtkWidget *main_vbox; GtkWidget *entry; GtkWidget *table; GtkWidget *scrolled_window; GtkWidget *text_view; GtkTextBuffer *text_buffer; gchar *gump_from; gint row = 0; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); /* check gimprc for a preferred "From:" address */ gump_from = gimp_gimprc_query ("gump-from"); if (gump_from) { g_strlcpy (mail_info.from, gump_from, BUFFER_SIZE); g_free (gump_from); } dlg = gimp_dialog_new (_("Send by Email"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Send"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); /* table */ table = gtk_table_new (5, 2, FALSE); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 12); gtk_table_set_col_spacings (GTK_TABLE (table), 6); /* Filename entry */ entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1); gtk_entry_set_text (GTK_ENTRY (entry), mail_info.filename); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, _("_Filename:"), 0.0, 0.5, entry, 1, FALSE); g_signal_connect (entry, "changed", G_CALLBACK (mail_entry_callback), mail_info.filename); /* To entry */ entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1); gtk_entry_set_text (GTK_ENTRY (entry), mail_info.receipt); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, C_("email-address", "_To:"), 0.0, 0.5, entry, 1, FALSE); g_signal_connect (entry, "changed", G_CALLBACK (mail_entry_callback), mail_info.receipt); gtk_widget_grab_focus (entry); /* From entry */ entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1); gtk_entry_set_text (GTK_ENTRY (entry), mail_info.from); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, C_("email-address", "_From:"), 0.0, 0.5, entry, 1, FALSE); g_signal_connect (entry, "changed", G_CALLBACK (mail_entry_callback), mail_info.from); /* Subject entry */ entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1); gtk_entry_set_text (GTK_ENTRY (entry), mail_info.subject); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, _("S_ubject:"), 0.0, 0.5, entry, 1, FALSE); g_signal_connect (entry, "changed", G_CALLBACK (mail_entry_callback), mail_info.subject); /* Body */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (main_vbox), scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); text_buffer = gtk_text_buffer_new (NULL); g_signal_connect (text_buffer, "changed", G_CALLBACK (mesg_body_callback), NULL); gtk_text_buffer_set_text (text_buffer, mail_info.comment, -1); text_view = gtk_text_view_new_with_buffer (text_buffer); g_object_unref (text_buffer); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD); gtk_container_add (GTK_CONTAINER (scrolled_window), text_view); gtk_widget_show (text_view); gtk_widget_show (dlg); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); gtk_widget_destroy (dlg); return run; }
static gint dog_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *button; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *coord; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("DoG Edge Detect"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview); gtk_widget_show (preview); g_signal_connect (preview, "invalidated", G_CALLBACK (preview_update_preview), drawable); frame = gimp_frame_new (_("Smoothing Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* Get the image resolution and unit */ gimp_image_get_resolution (image_ID, &xres, &yres); unit = gimp_image_get_unit (image_ID); coord = gimp_coordinates_new (unit, "%a", TRUE, FALSE, -1, GIMP_SIZE_ENTRY_UPDATE_SIZE, FALSE, TRUE, _("_Radius 1:"), dogvals.inner, xres, 0, 8 * MAX (drawable->width, drawable->height), 0, 0, _("R_adius 2:"), dogvals.outer, yres, 0, 8 * MAX (drawable->width, drawable->height), 0, 0); gtk_container_add (GTK_CONTAINER (frame), coord); gtk_widget_show (coord); gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (coord), 1); g_signal_connect (coord, "value-changed", G_CALLBACK (change_radius_callback), preview); button = gtk_check_button_new_with_mnemonic (_("_Normalize")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.normalize); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dogvals.normalize); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (button); button = gtk_check_button_new_with_mnemonic (_("_Invert")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.invert); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dogvals.invert); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (button); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { dogvals.inner = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 0); dogvals.outer = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 1); } gtk_widget_destroy (dialog); return run; }
void browser_dialog_open (const gchar *plug_in_binary) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *paned; GtkWidget *scrolled; GtkToolItem *item; GtkAction *action; DialogData data = { 720, 560, 240, TRUE, 1.0 }; gimp_ui_init (plug_in_binary, TRUE); gimp_get_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data); /* the dialog window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser")); gtk_window_set_role (GTK_WINDOW (window), plug_in_binary); gtk_window_set_default_size (GTK_WINDOW (window), data.width, data.height); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); window_set_icons (window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); ui_manager = ui_manager_new (window); toolbar = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar"); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0); gtk_widget_show (toolbar); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/forward"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_next = GTK_WIDGET (item); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/back"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_prev = GTK_WIDGET (item); item = GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar/space")); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); gtk_tool_item_set_expand (item, TRUE); /* the horizontal paned */ paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0); gtk_widget_show (paned); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (paned), scrolled); gtk_paned_set_position (GTK_PANED (paned), data.paned_position); sidebar = scrolled; if (data.show_index) gtk_widget_show (sidebar); tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); gtk_container_add (GTK_CONTAINER (scrolled), tree_view); gtk_widget_show (tree_view); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, NULL, gtk_cell_renderer_text_new (), "text", 1, NULL); g_signal_connect (tree_view, "row-activated", G_CALLBACK (row_activated), NULL); /* HTML view */ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (main_vbox); gtk_paned_pack2 (GTK_PANED (paned), main_vbox, TRUE, TRUE); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scrolled, 300, 200); gtk_box_pack_start (GTK_BOX (main_vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show (scrolled); view = webkit_web_view_new (); webkit_web_view_set_maintains_back_forward_list (WEBKIT_WEB_VIEW (view), TRUE); gtk_container_add (GTK_CONTAINER (scrolled), view); gtk_widget_show (view); g_signal_connect (view, "realize", G_CALLBACK (view_realize), NULL); g_signal_connect (view, "unrealize", G_CALLBACK (view_unrealize), NULL); g_signal_connect (view, "popup-menu", G_CALLBACK (view_popup_menu), NULL); g_signal_connect (view, "button-press-event", G_CALLBACK (view_button_press), NULL); g_signal_connect (view, "key-press-event", G_CALLBACK (view_key_press), NULL); webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (view), data.zoom); g_signal_connect (view, "title-changed", G_CALLBACK (title_changed), window); g_signal_connect (view, "load-started", G_CALLBACK (load_started), NULL); g_signal_connect (view, "load-finished", G_CALLBACK (load_finished), NULL); gtk_widget_grab_focus (view); g_signal_connect (window, "unmap", G_CALLBACK (dialog_unmap), paned); update_actions (); /* Searchbar */ searchbar = build_searchbar (); gtk_box_pack_start (GTK_BOX (main_vbox), searchbar, FALSE, FALSE, 0); }
/* The main GUI function for saving multi-paged PDFs */ static gboolean gui_multi (void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *file_label; GtkWidget *file_entry; GtkWidget *file_browse; GtkWidget *file_hbox; GtkWidget *vectorize_c; GtkWidget *ignore_hidden_c; GtkWidget *apply_c; GtkWidget *scroll; GtkWidget *page_view; GtkWidget *h_but_box; GtkWidget *del; GtkWidget *h_box; GtkWidget *img_combo; GtkWidget *add_image; gboolean run; const gchar *temp; gimp_ui_init (PLUG_IN_BINARY, FALSE); window = gimp_export_dialog_new ("PDF", PLUG_IN_ROLE, SAVE_MULTI_PROC); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (window)), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (window), 12); file_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); file_label = gtk_label_new (_("Save to:")); file_entry = gtk_entry_new (); if (file_name != NULL) gtk_entry_set_text (GTK_ENTRY (file_entry), file_name); file_browse = gtk_button_new_with_label (_("Browse...")); file_choose = gtk_file_chooser_dialog_new (_("Multipage PDF export"), GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE, "gtk-save", GTK_RESPONSE_OK, "gtk-cancel", GTK_RESPONSE_CANCEL, NULL); gtk_box_pack_start (GTK_BOX (file_hbox), file_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (file_hbox), file_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (file_hbox), file_browse, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), file_hbox, TRUE, TRUE, 0); page_view = gtk_icon_view_new (); model = create_model (); gtk_icon_view_set_model (GTK_ICON_VIEW (page_view), model); gtk_icon_view_set_reorderable (GTK_ICON_VIEW (page_view), TRUE); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (page_view), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (page_view), THUMB); gtk_icon_view_set_text_column (GTK_ICON_VIEW (page_view), PAGE_NUMBER); gtk_icon_view_set_tooltip_column (GTK_ICON_VIEW (page_view), IMAGE_NAME); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (scroll, -1, 300); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (scroll), page_view); gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0); h_but_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (h_but_box), GTK_BUTTONBOX_START); del = gtk_button_new_with_label (_("Remove the selected pages")); gtk_box_pack_start (GTK_BOX (h_but_box), del, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), h_but_box, FALSE, FALSE, 0); h_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); img_combo = gimp_image_combo_box_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (h_box), img_combo, FALSE, FALSE, 0); add_image = gtk_button_new_with_label (_("Add this image")); gtk_box_pack_start (GTK_BOX (h_box), add_image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), h_box, FALSE, FALSE, 0); ignore_hidden_c = gtk_check_button_new_with_label (_("Omit hidden layers and layers with zero opacity")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ignore_hidden_c), optimize.ignore_hidden); gtk_box_pack_end (GTK_BOX (vbox), ignore_hidden_c, FALSE, FALSE, 0); vectorize_c = gtk_check_button_new_with_label (_("Convert bitmaps to vector graphics where possible")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vectorize_c), optimize.vectorize); gtk_box_pack_end (GTK_BOX (vbox), vectorize_c, FALSE, FALSE, 0); apply_c = gtk_check_button_new_with_label (_("Apply layer masks before saving")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (apply_c), optimize.apply_masks); gtk_box_pack_end (GTK_BOX (vbox), apply_c, FALSE, FALSE, 0); gimp_help_set_help_data (apply_c, _("Keeping the masks will not change the output"), NULL); gtk_widget_show_all (window); g_signal_connect (G_OBJECT (file_browse), "clicked", G_CALLBACK (choose_file_call), G_OBJECT (file_entry)); g_signal_connect (G_OBJECT (add_image), "clicked", G_CALLBACK (add_image_call), G_OBJECT (img_combo)); g_signal_connect (G_OBJECT (del), "clicked", G_CALLBACK (del_image_call), G_OBJECT (page_view)); g_signal_connect (G_OBJECT (model), "row-deleted", G_CALLBACK (remove_call), NULL); run = gtk_dialog_run (GTK_DIALOG (window)) == GTK_RESPONSE_OK; run &= get_image_list (); temp = gtk_entry_get_text (GTK_ENTRY (file_entry)); g_stpcpy (file_name, temp); optimize.ignore_hidden = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ignore_hidden_c)); optimize.vectorize = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vectorize_c)); optimize.apply_masks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (apply_c)); gtk_widget_destroy (window); return run; }
static gboolean load_dialog (const gchar *filename) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *image; GtkWidget *table; GtkWidget *table2; GtkWidget *abox; GtkWidget *res; GtkWidget *label; GtkWidget *spinbutton; GtkObject *adj; guchar *pixels; gboolean run = FALSE; WmfLoadVals vals = { WMF_DEFAULT_RESOLUTION, - WMF_PREVIEW_SIZE, - WMF_PREVIEW_SIZE }; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Render Windows Metafile"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, LOAD_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); /* The WMF preview */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (abox), frame); gtk_widget_show (frame); pixels = wmf_get_pixbuf (filename, &vals.width, &vals.height); image = gimp_preview_area_new (); gtk_widget_set_size_request (image, vals.width, vals.height); gtk_container_add (GTK_CONTAINER (frame), image); gtk_widget_show (image); g_signal_connect (image, "size-allocate", G_CALLBACK (wmf_preview_callback), pixels); size_label = gtk_label_new (NULL); gtk_label_set_justify (GTK_LABEL (size_label), GTK_JUSTIFY_CENTER); gtk_misc_set_alignment (GTK_MISC (size_label), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (vbox), size_label, TRUE, TRUE, 4); gtk_widget_show (size_label); /* query the initial size after the size label is created */ vals.resolution = load_vals.resolution; load_wmf_size (filename, &vals); wmf_width = vals.width; wmf_height = vals.height; table = gtk_table_new (7, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2); gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0); gtk_widget_show (table); /* Width and Height */ label = gtk_label_new (_("Width:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); label = gtk_label_new (_("Height:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); size = GIMP_SIZE_ENTRY (gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE)); gtk_table_set_col_spacing (GTK_TABLE (size), 1, 6); gimp_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL); gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0); gtk_widget_show (GTK_WIDGET (size)); gimp_size_entry_set_refval_boundaries (size, 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (size, 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval (size, 0, wmf_width); gimp_size_entry_set_refval (size, 1, wmf_height); gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE); gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE); g_signal_connect (size, "value-changed", G_CALLBACK (load_dialog_size_callback), NULL); /* Scale ratio */ hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); table2 = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table2), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table2), 0, 4); gtk_box_pack_start (GTK_BOX (hbox), table2, FALSE, FALSE, 0); spinbutton = gimp_spin_button_new (&xadj, ratio_x, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_width, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_width, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1); gtk_widget_show (spinbutton); g_signal_connect (xadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_X ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&yadj, ratio_y, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_height, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_height, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2); gtk_widget_show (spinbutton); g_signal_connect (yadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_Y ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* the constrain ratio chainbutton */ constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE); gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2); gtk_widget_show (constrain); gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button, _("Constrain aspect ratio"), NULL); gtk_widget_show (table2); /* Resolution */ label = gtk_label_new (_("Resolution:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"), FALSE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6); gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res); /* don't let the resolution become too small ? does libwmf tend to crash with very small resolutions */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0, 5.0, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution); g_signal_connect (res, "value-changed", G_CALLBACK (load_dialog_resolution_callback), (gpointer) filename); gtk_widget_show (dialog); if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK) { load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0)); load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1)); run = TRUE; } gtk_widget_destroy (GTK_WIDGET (dialog)); return run; }
static gboolean cartoon_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *table; GtkObject *scale_data; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Cartoon"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (cartoon), drawable); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* Label, scale, entry for cvals.amount */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Mask radius:"), 100, 5, cvals.mask_radius, 1.0, 50.0, 1, 5.0, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &cvals.mask_radius); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Label, scale, entry for cvals.amount */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Percent black:"), 50, 5, cvals.pct_black, 0.0, 1.0, 0.01, 0.1, 3, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &cvals.pct_black); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean mblur_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *frame; GtkWidget *table; GtkWidget *entry; GtkWidget *spinbutton; GtkWidget *label; GtkWidget *button; GtkObject *adj; gdouble xres, yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Motion Blur"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (mblur), drawable); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); frame = gimp_int_radio_group_new (TRUE, _("Blur Type"), G_CALLBACK (mblur_radio_button_update), &mbvals.mblur_type, mbvals.mblur_type, _("_Linear"), MBLUR_LINEAR, NULL, _("_Radial"), MBLUR_RADIAL, NULL, _("_Zoom"), MBLUR_ZOOM, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); center = gimp_frame_new (_("Blur Center")); gtk_box_pack_start (GTK_BOX (hbox), center, FALSE, FALSE, 0); gtk_widget_show (center); vbox = gtk_vbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (center), vbox); gtk_widget_show (vbox); gimp_image_get_resolution (image_ID, &xres, &yres); entry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 5, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_row_spacings (GTK_TABLE (entry), 2); gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6); gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_widget_show (entry); g_signal_connect (entry, "value-changed", G_CALLBACK (mblur_center_update), NULL); g_signal_connect_swapped (entry, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); spinbutton = gimp_spin_button_new (&adj, 1, 0, 1, 1, 10, 1, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, xres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 0, mbvals.center_x); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_X:"), 0, 0, 0.0); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, yres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 1, mbvals.center_y); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Y:"), 1, 0, 0.0); button = gtk_check_button_new_with_mnemonic (_("Blur _outward")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), mbvals.blur_outward); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &mbvals.blur_outward); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); dir_button = button; frame = gimp_frame_new (_("Blur Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); length = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("L_ength:"), 150, 3, mbvals.length, 1.0, MBLUR_LENGTH_MAX, 1.0, 8.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (length, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.length); g_signal_connect_swapped (length, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); angle = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Angle:"), 150, 3, mbvals.angle, 0.0, 360.0, 1.0, 15.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (angle, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.angle); g_signal_connect_swapped (angle, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); mblur_set_sensitivity (); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; /* Setting mandatory output values */ *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Getting run_mode - we won't display a dialog if * we are in NONINTERACTIVE mode */ run_mode = param[0].data.d_int32; /* Set up the dialog */ if (run_mode != GIMP_RUN_NONINTERACTIVE) { gimp_ui_init ("jsfu", FALSE); Console console; GtkTextIter iter; const gchar *header = "Welcome to Javascript-Fu Console\n\0"; const gchar *subheader = "Interactive Javascript Development\n\n\0"; const gchar *submit = "Submit..."; /* Main dialog */ console.window = gimp_dialog_new ("JS-Fu Console", "jsfu", NULL, 0, gimp_standard_help_func, "script-js", GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); /* Box to package all of the pieces */ console.box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (console.box), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (console.window))), console.box, TRUE, TRUE, 0); /* Show the box */ gtk_widget_show (console.box); /* Create the scrolled window */ console.scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (console.scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); /* Pack and show the scrolled window */ gtk_box_pack_start (GTK_BOX (console.box), console.scrolled_window, TRUE, TRUE, 0); gtk_widget_show (console.scrolled_window); /* Create the text buffer and textbox */ console.buffer = gtk_text_buffer_new (NULL); gtk_text_buffer_get_start_iter (console.buffer, &iter); gtk_text_buffer_create_tag (console.buffer, "header", "weight", PANGO_WEIGHT_BOLD, "scale", PANGO_SCALE_LARGE, NULL); gtk_text_buffer_create_tag (console.buffer, "subheader", "style", PANGO_STYLE_OBLIQUE, NULL); gtk_text_buffer_insert_with_tags_by_name (console.buffer, &iter, header, -1, "header", NULL); gtk_text_buffer_insert_with_tags_by_name (console.buffer, &iter, subheader, -1, "subheader", NULL); console.textbox = gtk_text_view_new_with_buffer (console.buffer); /* Create the button */ console.button = gtk_button_new_with_label(submit); gtk_misc_set_padding (GTK_MISC (gtk_bin_get_child (GTK_BIN (console.button))), 0, 0); gtk_box_pack_start (GTK_BOX (console.box), console.button, FALSE, TRUE, 0); gtk_widget_show (console.button); /* Connect the callback signal for when the button is pressed */ g_signal_connect (console.button, "clicked", G_CALLBACK (js_fu_submit), console.buffer); /* Set the properties of the textbox */ gtk_text_view_set_editable (GTK_TEXT_VIEW (console.textbox), TRUE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (console.textbox), GTK_WRAP_WORD); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (console.textbox), 6); gtk_text_view_set_right_margin (GTK_TEXT_VIEW (console.textbox), 6); gtk_widget_set_size_request (console.textbox, 400, 480); /* Add and show the textbox */ gtk_container_add (GTK_CONTAINER (console.scrolled_window), console.textbox); gtk_widget_show (console.window); gtk_widget_show (console.textbox); int run = (gimp_dialog_run (GIMP_DIALOG (console.window)) == GTK_RESPONSE_OK); gtk_widget_destroy (console.window); } }
static void open_dialog (void) { GtkWidget *dialog; GtkWidget *main_hbox; GtkWidget *button; GtkObject *adjustment; GtkWidget *vbox; GtkWidget *table; GtkWidget *frame; GtkWidget *color_button; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Paper Tile"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); /* Left */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); frame = gimp_frame_new (_("Division")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (4, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); button = gimp_spin_button_new (&w.division_x_adj, p.params.division_x, 1.0, p.drawable->width, 1.0, 5.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_X:"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (w.division_x_adj, "value-changed", G_CALLBACK (division_x_adj_changed), NULL); button = gimp_spin_button_new (&w.division_y_adj, p.params.division_y, 1.0, p.drawable->width, 1.0, 5.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("_Y:"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (w.division_y_adj, "value-changed", G_CALLBACK (division_y_adj_changed), NULL); button = gimp_spin_button_new (&w.tile_width_adj, p.params.tile_width, 1.0, MAX (p.drawable->width, p.drawable->height), 1.0, 5.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("_Width:"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (w.tile_width_adj, "value-changed", G_CALLBACK (tile_width_adj_changed), NULL); button = gimp_spin_button_new (&w.tile_height_adj, p.params.tile_height, 1.0, MAX (p.drawable->width, p.drawable->height), 1.0, 5.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("_Height:"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (w.tile_height_adj, "value-changed", G_CALLBACK (tile_height_adj_changed), NULL); frame = gimp_int_radio_group_new (TRUE, _("Fractional Pixels"), G_CALLBACK (gimp_radio_button_update), &p.params.fractional_type, p.params.fractional_type, _("_Background"), FRACTIONAL_TYPE_BACKGROUND, NULL, _("_Ignore"), FRACTIONAL_TYPE_IGNORE, NULL, _("_Force"), FRACTIONAL_TYPE_FORCE, NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); button = gtk_check_button_new_with_mnemonic(_("C_entering")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), p.params.centering); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &p.params.centering); /* Right */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gimp_frame_new (_("Movement")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); button = gimp_spin_button_new (&adjustment, p.params.move_max_rate, 0.0, 100.0, 1.0, 10.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Max (%):"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &p.params.move_max_rate); button = gtk_check_button_new_with_mnemonic (_("_Wrap around")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), p.params.wrap_around); gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 2, 1, 2); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &p.params.wrap_around); frame = gimp_int_radio_group_new (TRUE, _("Background Type"), G_CALLBACK (gimp_radio_button_update), &p.params.background_type, p.params.background_type, _("_Transparent"), BACKGROUND_TYPE_TRANSPARENT, NULL, _("I_nverted image"), BACKGROUND_TYPE_INVERTED, NULL, _("Im_age"), BACKGROUND_TYPE_IMAGE, NULL, _("Fo_reground color"), BACKGROUND_TYPE_FOREGROUND, NULL, _("Bac_kground color"), BACKGROUND_TYPE_BACKGROUND, NULL, _("S_elect here:"), BACKGROUND_TYPE_COLOR, &button, NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); color_button = gimp_color_button_new (_("Background Color"), 100, 16, &p.params.background_color, p.drawable_has_alpha ? GIMP_COLOR_AREA_SMALL_CHECKS : GIMP_COLOR_AREA_FLAT); gtk_box_pack_start (GTK_BOX (gtk_bin_get_child (GTK_BIN (frame))), color_button, TRUE, TRUE, 0); gtk_widget_show (color_button); g_signal_connect (color_button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &p.params.background_color); g_object_bind_property (button, "active", color_button, "sensitive", G_BINDING_SYNC_CREATE); gtk_widget_show (dialog); p.run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); }
static gboolean pixelize_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *sizeentry; guint32 image_id; GimpUnit unit; gdouble xres, yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Pixelize"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PIXELIZE_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (pixelize), drawable); image_id = gimp_drawable_get_image (drawable->drawable_id); unit = gimp_image_get_unit (image_id); gimp_image_get_resolution (image_id, &xres, &yres); sizeentry = gimp_coordinates_new (unit, "%a", TRUE, TRUE, ENTRY_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE, TRUE, FALSE, _("Pixel _width:"), pvals.pixelwidth, xres, 1, drawable->width, 1, drawable->width, _("Pixel _height:"), pvals.pixelheight, yres, 1, drawable->height, 1, drawable->height); gtk_box_pack_start (GTK_BOX (main_vbox), sizeentry, FALSE, FALSE, 0); gtk_widget_show (sizeentry); g_signal_connect (sizeentry, "value-changed", G_CALLBACK (update_pixelsize), preview); g_signal_connect (sizeentry, "refval-changed", G_CALLBACK (update_pixelsize), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
gint sinus_dialog (void) { GtkWidget *dlg; GtkWidget *main_hbox; GtkWidget *preview; GtkWidget *notebook; GtkWidget *page; GtkWidget *frame; GtkWidget *label; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *hbox; GtkWidget *table; GtkWidget *toggle; GtkWidget *push_col1 = NULL; GtkWidget *push_col2 = NULL; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); /* Create Main window with a vbox */ /* ============================== */ dlg = gimp_dialog_new (_("Sinus"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); main_hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); /* Create preview */ /* ============== */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); preview = mw_preview_new (vbox, thePreview); /* Create the notebook */ /* =================== */ notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_box_pack_start (GTK_BOX (main_hbox), notebook, FALSE, FALSE, 0); gtk_widget_show (notebook); /* Create the drawing settings frame */ /* ================================= */ page = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (page), 12); frame = gimp_frame_new (_("Drawing Settings")); gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER(frame), table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_X scale:"), 140, 8, svals.scalex, 0.0001, 100.0, 0.0001, 5, 4, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.scalex); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Y scale:"), 140, 8, svals.scaley, 0.0001, 100.0, 0.0001, 5, 4, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.scaley); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("Co_mplexity:"), 140, 8, svals.cmplx, 0.0, 15.0, 0.01, 5, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.cmplx); gtk_widget_show (table); frame= gimp_frame_new (_("Calculation Settings")); gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); table = gtk_table_new (3, 1, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); hbox = gimp_random_seed_new (&svals.seed, &svals.random_seed); label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("R_andom seed:"), 1.0, 0.5, hbox, 1, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), GIMP_RANDOM_SEED_SPINBUTTON (hbox)); g_signal_connect (GIMP_RANDOM_SEED_SPINBUTTON_ADJ (hbox), "value-changed", G_CALLBACK (sinus_random_update), NULL); gtk_widget_show (table); toggle = gtk_check_button_new_with_mnemonic (_("_Force tiling?")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), svals.tiling); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (sinus_toggle_button_update), &svals.tiling); vbox2 = gimp_int_radio_group_new (FALSE, NULL, G_CALLBACK (sinus_radio_button_update), &svals.perturbation, svals.perturbation, _("_Ideal"), IDEAL, NULL, _("_Distorted"), PERTURBED, NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); gtk_widget_show (vbox2); label = gtk_label_new_with_mnemonic (_("_Settings")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); /* Color settings dialog: */ /* ====================== */ page = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (page), 12); if (drawable_is_grayscale) { frame = gimp_frame_new (_("Colors")); gtk_box_pack_start(GTK_BOX(page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /*if in grey scale, the colors are necessarily black and white */ label = gtk_label_new (_("The colors are white and black.")); gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5); gtk_container_add (GTK_CONTAINER (vbox), label); gtk_widget_show (label); } else { frame = gimp_int_radio_group_new (TRUE, _("Colors"), G_CALLBACK (sinus_radio_button_update), &svals.colors, svals.colors, _("Bl_ack & white"), B_W, NULL, _("_Foreground & background"), USE_FG_BG, NULL, _("C_hoose here:"), USE_COLORS, NULL, NULL); gtk_box_pack_start(GTK_BOX(page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = GTK_BIN (frame)->child; hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); push_col1 = gimp_color_button_new (_("First color"), 32, 32, &svals.col1, GIMP_COLOR_AREA_SMALL_CHECKS); gtk_box_pack_start (GTK_BOX (hbox), push_col1, FALSE, FALSE, 0); gtk_widget_show (push_col1); g_signal_connect (push_col1, "color-changed", G_CALLBACK (gimp_color_button_get_color), &svals.col1); push_col2 = gimp_color_button_new (_("Second color"), 32, 32, &svals.col2, GIMP_COLOR_AREA_SMALL_CHECKS); gtk_box_pack_start (GTK_BOX (hbox), push_col2, FALSE, FALSE, 0); gtk_widget_show (push_col2); g_signal_connect (push_col2, "color-changed", G_CALLBACK (gimp_color_button_get_color), &svals.col2); gtk_widget_show (hbox); } frame = gimp_frame_new (_("Alpha Channels")); gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); gtk_widget_set_sensitive (frame, gimp_drawable_has_alpha (drawable->drawable_id)); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("F_irst color:"), 0, 0, svals.col1.a, 0.0, 1.0, 0.01, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (alpha_scale_cb), push_col1); if (push_col1) g_signal_connect (push_col1, "color-changed", G_CALLBACK (alpha_scale_update), adj); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("S_econd color:"), 0, 0, svals.col2.a, 0.0, 1.0, 0.01, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (alpha_scale_cb), push_col2); if (push_col2) g_signal_connect (push_col2, "color-changed", G_CALLBACK (alpha_scale_update), adj); gtk_widget_show (table); label = gtk_label_new_with_mnemonic (_("Co_lors")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); /* blend settings dialog: */ /* ====================== */ page = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (page), 12); frame = gimp_frame_new (_("Blend Settings")); gtk_box_pack_start (GTK_BOX (page), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); frame = gimp_int_radio_group_new (TRUE, _("Gradient"), G_CALLBACK (sinus_radio_button_update), &svals.colorization, svals.colorization, _("L_inear"), LINEAR, NULL, _("Bili_near"), BILINEAR, NULL, _("Sin_usoidal"), SINUS, NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (vbox), table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Exponent:"), 0, 0, svals.blend_power, -7.5, 7.5, 0.01, 5.0, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.blend_power); gtk_widget_show (table); label = gtk_label_new_with_mnemonic (_("_Blend")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); gtk_widget_show (dlg); sinus_do_preview (preview); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); gtk_widget_destroy (dlg); return run; }