mirror of https://github.com/GNOME/gimp.git
998 lines
23 KiB
C
998 lines
23 KiB
C
/* The GIMP -- an image manipulation program
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
* Copyright (C) 1998 Andy Thomas.
|
|
*
|
|
* Gradient editor module copyight (C) 1996-1997 Federico Mena Quintero
|
|
* federico@nuclecu.unam.mx
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURIGHTE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
|
|
/* This is the popup for the gradient selection stuff..
|
|
* idea is a cut down version of the gradient selection widget
|
|
* just a clist on which each gradient can be selected.
|
|
* Of course all the support functions for getting the slected gradient and
|
|
* setting the slection all need to be done as well.
|
|
*/
|
|
|
|
|
|
/* Main structure for the dialog. There can be multiple of these
|
|
* so every thing has to go into the strcuture and we have to have a list
|
|
* the structures so we can find which one we are taking about.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include "appenv.h"
|
|
#include "colormaps.h"
|
|
#include "cursorutil.h"
|
|
#include "datafiles.h"
|
|
#include "errors.h"
|
|
#include "general.h"
|
|
#include "gimprc.h"
|
|
#include "gradient.h"
|
|
#include "gradient_header.h"
|
|
#include "interface.h"
|
|
#include "palette.h"
|
|
#include "session.h"
|
|
#include "actionarea.h"
|
|
#include "dialog_handler.h"
|
|
|
|
#include "libgimp/gimpintl.h"
|
|
|
|
#define G_SAMPLE 40
|
|
|
|
typedef struct _GradSelect _GradSelect, *GradSelectP;
|
|
|
|
struct _GradSelect {
|
|
GtkWidget *shell;
|
|
GtkWidget *frame;
|
|
GtkWidget *preview;
|
|
GtkWidget *clist;
|
|
gchar *callback_name;
|
|
gradient_t *grad;
|
|
gint sample_size;
|
|
GdkColor black;
|
|
GdkGC *gc;
|
|
};
|
|
|
|
static GSList *active_dialogs = NULL; /* List of active dialogs */
|
|
GradSelectP gradient_select_dialog = NULL; /* The main selection dialog */
|
|
static int success;
|
|
static Argument *return_args;
|
|
|
|
static void grad_select_close_callback (GtkWidget *, gpointer);
|
|
static void grad_select_edit_callback (GtkWidget *, gpointer);
|
|
static void grad_change_callbacks(GradSelectP gsp, gint closing);
|
|
extern void import_palette_grad_update(gradient_t *); /* ALT Hmm... */
|
|
|
|
|
|
static ActionAreaItem action_items[2] =
|
|
{
|
|
{ N_("Edit"), grad_select_edit_callback, NULL, NULL },
|
|
{ N_("Close"), grad_select_close_callback, NULL, NULL }
|
|
};
|
|
|
|
void
|
|
grad_free_gradient_editor(void)
|
|
{
|
|
if (gradient_select_dialog)
|
|
session_get_window_info (gradient_select_dialog->shell, &gradient_select_session_info);
|
|
} /* grad_free_gradient_editor */
|
|
|
|
void
|
|
grad_sel_rename_all(gint n, gradient_t *grad)
|
|
{
|
|
GSList *list = active_dialogs;
|
|
GradSelectP gsp;
|
|
|
|
while(list)
|
|
{
|
|
gsp = (GradSelectP)list->data;
|
|
gtk_clist_set_text(GTK_CLIST(gsp->clist),n,1,grad->name);
|
|
list = g_slist_next(list);
|
|
}
|
|
|
|
if(gradient_select_dialog)
|
|
{
|
|
gtk_clist_set_text(GTK_CLIST(gradient_select_dialog->clist),n,1,grad->name);
|
|
}
|
|
}
|
|
|
|
void
|
|
grad_sel_new_all(gint pos, gradient_t *grad)
|
|
{
|
|
GSList *list = active_dialogs;
|
|
GradSelectP gsp;
|
|
|
|
while(list)
|
|
{
|
|
gsp = (GradSelectP)list->data;
|
|
gtk_clist_freeze(GTK_CLIST(gsp->clist));
|
|
ed_insert_in_gradients_listbox(gsp->gc,gsp->clist,grad, pos, 1);
|
|
gtk_clist_thaw(GTK_CLIST(gsp->clist));
|
|
list = g_slist_next(list);
|
|
}
|
|
|
|
if(gradient_select_dialog)
|
|
{
|
|
gtk_clist_freeze(GTK_CLIST(gradient_select_dialog->clist));
|
|
ed_insert_in_gradients_listbox(gradient_select_dialog->gc,gradient_select_dialog->clist,grad, pos, 1);
|
|
gtk_clist_thaw(GTK_CLIST(gradient_select_dialog->clist));
|
|
}
|
|
}
|
|
|
|
void
|
|
grad_sel_copy_all(gint pos, gradient_t *grad)
|
|
{
|
|
GSList *list = active_dialogs;
|
|
GradSelectP gsp;
|
|
|
|
while(list)
|
|
{
|
|
gsp = (GradSelectP)list->data;
|
|
gtk_clist_freeze(GTK_CLIST(gsp->clist));
|
|
ed_insert_in_gradients_listbox(gsp->gc,gsp->clist,grad, pos, 1);
|
|
gtk_clist_thaw(GTK_CLIST(gsp->clist));
|
|
list = g_slist_next(list);
|
|
}
|
|
|
|
if(gradient_select_dialog)
|
|
{
|
|
gtk_clist_freeze(GTK_CLIST(gradient_select_dialog->clist));
|
|
ed_insert_in_gradients_listbox(gradient_select_dialog->gc,gradient_select_dialog->clist,grad, pos, 1);
|
|
gtk_clist_thaw(GTK_CLIST(gradient_select_dialog->clist));
|
|
}
|
|
}
|
|
|
|
void
|
|
grad_sel_delete_all(gint n)
|
|
{
|
|
GSList *list = active_dialogs;
|
|
GradSelectP gsp;
|
|
|
|
while(list)
|
|
{
|
|
gsp = (GradSelectP)list->data;
|
|
gtk_clist_remove(GTK_CLIST(gsp->clist), n);
|
|
list = g_slist_next(list);
|
|
}
|
|
|
|
if(gradient_select_dialog)
|
|
{
|
|
gtk_clist_remove(GTK_CLIST(gradient_select_dialog->clist), n);
|
|
}
|
|
}
|
|
|
|
void
|
|
grad_sel_free_all()
|
|
{
|
|
GSList *list = active_dialogs;
|
|
GradSelectP gsp;
|
|
|
|
while(list)
|
|
{
|
|
gsp = (GradSelectP)list->data;
|
|
gtk_clist_freeze(GTK_CLIST(gsp->clist));
|
|
gtk_clist_clear(GTK_CLIST(gsp->clist));
|
|
gtk_clist_thaw(GTK_CLIST(gsp->clist));
|
|
list = g_slist_next(list);
|
|
}
|
|
|
|
if(gradient_select_dialog)
|
|
{
|
|
gtk_clist_freeze(GTK_CLIST(gradient_select_dialog->clist));
|
|
gtk_clist_clear(GTK_CLIST(gradient_select_dialog->clist));
|
|
gtk_clist_thaw(GTK_CLIST(gradient_select_dialog->clist));
|
|
}
|
|
}
|
|
|
|
void
|
|
grad_sel_refill_all()
|
|
{
|
|
GSList *list = active_dialogs;
|
|
GradSelectP gsp;
|
|
int select_pos = -1;
|
|
|
|
while(list)
|
|
{
|
|
gsp = (GradSelectP)list->data;
|
|
gsp->grad = curr_gradient;
|
|
select_pos = ed_set_list_of_gradients(gsp->gc,
|
|
gsp->clist,
|
|
curr_gradient);
|
|
if(select_pos != -1)
|
|
gtk_clist_moveto(GTK_CLIST(gsp->clist),select_pos,0,0.0,0.0);
|
|
|
|
list = g_slist_next(list);
|
|
}
|
|
|
|
if(gradient_select_dialog)
|
|
{
|
|
gradient_select_dialog->grad = curr_gradient;
|
|
select_pos = ed_set_list_of_gradients(gradient_select_dialog->gc,
|
|
gradient_select_dialog->clist,
|
|
curr_gradient);
|
|
if(select_pos != -1)
|
|
gtk_clist_moveto(GTK_CLIST(gradient_select_dialog->clist),select_pos,0,0.0,0.0);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
sel_update_dialogs(gint row, gradient_t *grad)
|
|
{
|
|
/* Go around each updating the names and hopefully the previews */
|
|
GSList *list = active_dialogs;
|
|
GradSelectP gsp;
|
|
|
|
while(list)
|
|
{
|
|
gsp = (GradSelectP)list->data;
|
|
gtk_clist_set_text(GTK_CLIST(gsp->clist),row,1,grad->name);
|
|
/* Are we updating one that is selected in a popup dialog? */
|
|
if(grad == gsp->grad)
|
|
grad_change_callbacks(gsp, 0);
|
|
list = g_slist_next(list);
|
|
}
|
|
|
|
if(gradient_select_dialog)
|
|
gtk_clist_set_text(GTK_CLIST(gradient_select_dialog->clist),row,1,grad->name);
|
|
|
|
import_palette_grad_update(grad);
|
|
}
|
|
|
|
static void
|
|
sel_list_item_update(GtkWidget *widget,
|
|
gint row,
|
|
gint column,
|
|
GdkEventButton *event,
|
|
gpointer data)
|
|
{
|
|
GradSelectP gsp = (GradSelectP)data;
|
|
|
|
GSList* tmp = g_slist_nth(gradients_list,row);
|
|
gsp->grad = (gradient_t *)(tmp->data);
|
|
|
|
/* If main one then make it the current selection */
|
|
if(gsp == gradient_select_dialog)
|
|
{
|
|
grad_set_grad_to_name(gsp->grad->name);
|
|
import_palette_grad_update(gsp->grad);
|
|
}
|
|
else
|
|
{
|
|
grad_change_callbacks(gsp, 0);
|
|
}
|
|
}
|
|
|
|
static void
|
|
grad_select_edit_callback (GtkWidget *w,
|
|
gpointer client_data)
|
|
{
|
|
GradSelectP gsp;
|
|
|
|
gsp = (GradSelectP) client_data;
|
|
|
|
grad_create_gradient_editor_init(TRUE);
|
|
|
|
/* Set the current gradient in this dailog to the "real current"*/
|
|
if(gsp && gsp->grad)
|
|
grad_set_grad_to_name(gsp->grad->name);
|
|
}
|
|
|
|
void
|
|
grad_select_free (GradSelectP gsp)
|
|
{
|
|
if (gsp)
|
|
{
|
|
if(gsp->callback_name)
|
|
g_free(gsp->callback_name);
|
|
|
|
/* remove from active list */
|
|
|
|
active_dialogs = g_slist_remove(active_dialogs,gsp);
|
|
|
|
g_free (gsp);
|
|
}
|
|
}
|
|
|
|
/* Close active dialogs that no longer have PDB registered for them */
|
|
|
|
void
|
|
gradients_check_dialogs()
|
|
{
|
|
GSList *list;
|
|
GradSelectP gsp;
|
|
gchar * name;
|
|
ProcRecord *prec = NULL;
|
|
|
|
list = active_dialogs;
|
|
|
|
while (list)
|
|
{
|
|
gsp = (GradSelectP) list->data;
|
|
list = list->next;
|
|
|
|
name = gsp->callback_name;
|
|
prec = procedural_db_lookup(name);
|
|
|
|
if(!prec)
|
|
{
|
|
active_dialogs = g_slist_remove(active_dialogs,gsp);
|
|
|
|
/* Can alter active_dialogs list*/
|
|
grad_select_close_callback(NULL,gsp);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
grad_change_callbacks(GradSelectP gsp, gint closing)
|
|
{
|
|
gchar * name;
|
|
ProcRecord *prec = NULL;
|
|
gradient_t *grad;
|
|
int nreturn_vals;
|
|
static int busy = 0;
|
|
gradient_t *oldgrad = curr_gradient;
|
|
|
|
/* Any procs registered to callback? */
|
|
Argument *return_vals;
|
|
|
|
if(!gsp || !gsp->callback_name || busy != 0)
|
|
return;
|
|
|
|
busy = 1;
|
|
name = gsp->callback_name;
|
|
grad = gsp->grad;
|
|
|
|
/* If its still registered run it */
|
|
prec = procedural_db_lookup(name);
|
|
|
|
if(prec && grad)
|
|
{
|
|
gdouble *values, *pv;
|
|
double pos, delta;
|
|
double r, g, b, a;
|
|
int i = gsp->sample_size;
|
|
pos = 0.0;
|
|
delta = 1.0 / (i - 1);
|
|
|
|
values = g_malloc(i * 4 * sizeof(gdouble));
|
|
pv = values;
|
|
|
|
curr_gradient = grad;
|
|
|
|
while (i--) {
|
|
grad_get_color_at(pos, &r, &g, &b, &a);
|
|
|
|
*pv++ = r;
|
|
*pv++ = g;
|
|
*pv++ = b;
|
|
*pv++ = a;
|
|
|
|
pos += delta;
|
|
} /* while */
|
|
|
|
curr_gradient = oldgrad;
|
|
|
|
return_vals = procedural_db_run_proc (name,
|
|
&nreturn_vals,
|
|
PDB_STRING,grad->name,
|
|
PDB_INT32,gsp->sample_size*4,
|
|
PDB_FLOATARRAY,values,
|
|
PDB_INT32,closing,
|
|
PDB_END);
|
|
|
|
if (!return_vals || return_vals[0].value.pdb_int != PDB_SUCCESS)
|
|
g_message (_("failed to run gradient callback function"));
|
|
else
|
|
procedural_db_destroy_args (return_vals, nreturn_vals);
|
|
}
|
|
busy = 0;
|
|
}
|
|
|
|
static void
|
|
grad_select_close_callback (GtkWidget *w,
|
|
gpointer client_data)
|
|
{
|
|
GradSelectP gsp;
|
|
|
|
gsp = (GradSelectP) client_data;
|
|
|
|
if (GTK_WIDGET_VISIBLE (gsp->shell))
|
|
gtk_widget_hide (gsp->shell);
|
|
|
|
/* Free memory if poping down dialog which is not the main one */
|
|
if(gsp != gradient_select_dialog)
|
|
{
|
|
grad_change_callbacks(gsp,1);
|
|
gtk_widget_destroy(gsp->shell);
|
|
grad_select_free(gsp);
|
|
}
|
|
}
|
|
|
|
static gint
|
|
grad_select_delete_callback (GtkWidget *w,
|
|
GdkEvent *e,
|
|
gpointer client_data)
|
|
{
|
|
grad_select_close_callback (w, client_data);
|
|
return TRUE;
|
|
}
|
|
|
|
GradSelectP
|
|
gsel_new_selection(gchar * title,
|
|
gchar * initial_gradient)
|
|
{
|
|
GradSelectP gsp;
|
|
gradient_t *grad = NULL;
|
|
GSList *list;
|
|
GtkWidget *vbox;
|
|
GtkWidget *hbox;
|
|
GtkWidget *scrolled_win;
|
|
GdkColormap *colormap;
|
|
int select_pos;
|
|
|
|
/* Load them if they are not already loaded */
|
|
if(g_editor == NULL)
|
|
{
|
|
grad_create_gradient_editor_init(FALSE);
|
|
}
|
|
|
|
gsp = g_malloc(sizeof(_GradSelect));
|
|
gsp->callback_name = NULL;
|
|
|
|
/* The shell and main vbox */
|
|
gsp->shell = gtk_dialog_new ();
|
|
|
|
gtk_window_set_wmclass (GTK_WINDOW (gsp->shell), "gradselection", "Gimp");
|
|
|
|
gtk_window_set_policy(GTK_WINDOW(gsp->shell), FALSE, TRUE, FALSE);
|
|
|
|
vbox = gtk_vbox_new (FALSE, 1);
|
|
gtk_container_border_width (GTK_CONTAINER (vbox), 1);
|
|
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (gsp->shell)->vbox), vbox, TRUE, TRUE, 0);
|
|
|
|
/* handle the wm close event */
|
|
gtk_signal_connect (GTK_OBJECT (gsp->shell), "delete_event",
|
|
GTK_SIGNAL_FUNC (grad_select_delete_callback),
|
|
gsp);
|
|
|
|
/* clist preview of gradients */
|
|
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
|
|
|
|
gsp->clist = gtk_clist_new(2);
|
|
gtk_clist_set_shadow_type(GTK_CLIST(gsp->clist), GTK_SHADOW_IN);
|
|
|
|
gtk_clist_set_row_height(GTK_CLIST(gsp->clist), 18);
|
|
|
|
gtk_clist_set_column_width(GTK_CLIST(gsp->clist), 0, 52);
|
|
gtk_clist_set_column_title(GTK_CLIST(gsp->clist), 0, _("Gradient"));
|
|
gtk_clist_set_column_title(GTK_CLIST(gsp->clist), 1, _("Name"));
|
|
gtk_clist_column_titles_show(GTK_CLIST(gsp->clist));
|
|
|
|
hbox = gtk_hbox_new(FALSE, 8);
|
|
gtk_container_border_width(GTK_CONTAINER(hbox), 0);
|
|
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
|
|
gtk_widget_show(hbox);
|
|
|
|
gtk_box_pack_start(GTK_BOX(hbox), scrolled_win, TRUE, TRUE, 0);
|
|
gtk_container_add (GTK_CONTAINER (scrolled_win), gsp->clist);
|
|
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
|
|
GTK_POLICY_AUTOMATIC,
|
|
GTK_POLICY_ALWAYS);
|
|
|
|
gtk_widget_show(scrolled_win);
|
|
gtk_widget_show(gsp->clist);
|
|
gtk_widget_set_usize (gsp->clist, 200, 250);
|
|
|
|
colormap = gtk_widget_get_colormap(gsp->clist);
|
|
gdk_color_parse("black", &gsp->black);
|
|
gdk_color_alloc(colormap, &gsp->black);
|
|
|
|
gtk_signal_connect(GTK_OBJECT(gsp->clist), "select_row",
|
|
GTK_SIGNAL_FUNC(sel_list_item_update),
|
|
(gpointer) gsp);
|
|
|
|
action_items[0].user_data = gsp;
|
|
action_items[1].user_data = gsp;
|
|
build_action_area (GTK_DIALOG (gsp->shell), action_items, 2, 1);
|
|
|
|
if(!title)
|
|
{
|
|
gtk_window_set_title (GTK_WINDOW (gsp->shell), _("Gradient Selection"));
|
|
}
|
|
else
|
|
{
|
|
gtk_window_set_title (GTK_WINDOW (gsp->shell), title);
|
|
}
|
|
if(initial_gradient && strlen(initial_gradient))
|
|
{
|
|
list = gradients_list;
|
|
while (list)
|
|
{
|
|
grad = list->data;
|
|
if (strcmp(grad->name, initial_gradient) == 0)
|
|
{
|
|
/* We found it! */
|
|
break;
|
|
}
|
|
list = g_slist_next(list);
|
|
}
|
|
}
|
|
|
|
if(grad == NULL)
|
|
grad = curr_gradient;
|
|
|
|
gsp->grad = grad;
|
|
|
|
gtk_widget_realize(gsp->shell);
|
|
gsp->gc = gdk_gc_new(gsp->shell->window);
|
|
|
|
select_pos = ed_set_list_of_gradients(gsp->gc,
|
|
gsp->clist,
|
|
grad);
|
|
|
|
/* Now show the dialog */
|
|
gtk_widget_show(vbox);
|
|
gtk_widget_show(gsp->shell);
|
|
|
|
if(select_pos != -1)
|
|
gtk_clist_moveto(GTK_CLIST(gsp->clist),select_pos,0,0.0,0.0);
|
|
|
|
return gsp;
|
|
}
|
|
|
|
void
|
|
grad_create_gradient_editor(void)
|
|
{
|
|
if(gradient_select_dialog == NULL)
|
|
{
|
|
gradient_select_dialog = gsel_new_selection(_("Gradients"),NULL);
|
|
|
|
/* register this one only */
|
|
dialog_register(gradient_select_dialog->shell);
|
|
|
|
session_set_window_geometry (gradient_select_dialog->shell, &gradient_select_session_info, TRUE);
|
|
}
|
|
else
|
|
{
|
|
if (!GTK_WIDGET_VISIBLE(gradient_select_dialog->shell))
|
|
{
|
|
gtk_widget_show(gradient_select_dialog->shell);
|
|
}
|
|
else
|
|
gdk_window_raise(gradient_select_dialog->shell->window);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/************
|
|
* PDB interfaces.
|
|
*/
|
|
|
|
|
|
static Argument *
|
|
gradients_popup_invoker (Argument *args)
|
|
{
|
|
gchar * name;
|
|
gchar * title;
|
|
gchar * initial_gradient;
|
|
ProcRecord *prec = NULL;
|
|
gint sample_sz;
|
|
GradSelectP newdialog;
|
|
|
|
success = (name = (char *) args[0].value.pdb_pointer) != NULL;
|
|
title = (char *) args[1].value.pdb_pointer;
|
|
initial_gradient = (char *) args[2].value.pdb_pointer;
|
|
sample_sz = args[3].value.pdb_int;
|
|
|
|
if(sample_sz < 0 || sample_sz > 10000)
|
|
sample_sz = G_SAMPLE;
|
|
|
|
/* Check the proc exists */
|
|
if(!success || (prec = procedural_db_lookup(name)) == NULL)
|
|
{
|
|
success = 0;
|
|
return procedural_db_return_args (&gradients_popup_proc, success);
|
|
}
|
|
|
|
if(initial_gradient && strlen(initial_gradient))
|
|
newdialog = gsel_new_selection(title,
|
|
initial_gradient);
|
|
else
|
|
newdialog = gsel_new_selection(title,NULL);
|
|
|
|
/* Add to list of proc to run when pattern changes */
|
|
newdialog->callback_name = g_strdup(name);
|
|
newdialog->sample_size = sample_sz;
|
|
|
|
/* Add to active gradient dialogs list */
|
|
active_dialogs = g_slist_append(active_dialogs,newdialog);
|
|
|
|
return procedural_db_return_args (&gradients_popup_proc, success);
|
|
}
|
|
|
|
/* The procedure definition */
|
|
ProcArg gradients_popup_in_args[] =
|
|
{
|
|
{ PDB_STRING,
|
|
"gradients_callback",
|
|
"the callback PDB proc to call when gradient selection is made"
|
|
},
|
|
{ PDB_STRING,
|
|
"popup title",
|
|
"title to give the gradient popup window",
|
|
},
|
|
{ PDB_STRING,
|
|
"initial gradient",
|
|
"The name of the pattern to set as the first selected",
|
|
},
|
|
{ PDB_INT32,
|
|
"sample size",
|
|
"size of the sample to return when the gradient is changed (< 10000)",
|
|
},
|
|
};
|
|
|
|
ProcRecord gradients_popup_proc =
|
|
{
|
|
"gimp_gradients_popup",
|
|
"Invokes the Gimp gradients selection",
|
|
"This procedure popups the gradients selection dialog",
|
|
"Andy Thomas",
|
|
"Andy Thomas",
|
|
"1998",
|
|
PDB_INTERNAL,
|
|
|
|
/* Input arguments */
|
|
sizeof(gradients_popup_in_args) / sizeof(gradients_popup_in_args[0]),
|
|
gradients_popup_in_args,
|
|
|
|
/* Output arguments */
|
|
0,
|
|
NULL,
|
|
|
|
/* Exec method */
|
|
{ { gradients_popup_invoker } },
|
|
};
|
|
|
|
static GradSelectP
|
|
gradients_get_gradientselect(gchar *name)
|
|
{
|
|
GSList *list;
|
|
GradSelectP gsp;
|
|
|
|
list = active_dialogs;
|
|
|
|
while (list)
|
|
{
|
|
gsp = (GradSelectP) list->data;
|
|
list = list->next;
|
|
|
|
if(strcmp(name,gsp->callback_name) == 0)
|
|
{
|
|
return gsp;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static Argument *
|
|
gradients_close_popup_invoker (Argument *args)
|
|
{
|
|
gchar * name;
|
|
ProcRecord *prec = NULL;
|
|
GradSelectP gsp;
|
|
|
|
success = (name = (char *) args[0].value.pdb_pointer) != NULL;
|
|
|
|
/* Check the proc exists */
|
|
if(!success || (prec = procedural_db_lookup(name)) == NULL)
|
|
{
|
|
success = 0;
|
|
return procedural_db_return_args (&gradients_close_popup_proc, success);
|
|
}
|
|
|
|
gsp = gradients_get_gradientselect(name);
|
|
|
|
if(gsp)
|
|
{
|
|
active_dialogs = g_slist_remove(active_dialogs,gsp);
|
|
|
|
if (GTK_WIDGET_VISIBLE (gsp->shell))
|
|
gtk_widget_hide (gsp->shell);
|
|
|
|
/* Free memory if poping down dialog which is not the main one */
|
|
if(gsp != gradient_select_dialog)
|
|
{
|
|
/* Send data back */
|
|
gtk_widget_destroy(gsp->shell);
|
|
grad_select_free(gsp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
success = FALSE;
|
|
}
|
|
|
|
return procedural_db_return_args (&gradients_close_popup_proc, success);
|
|
}
|
|
|
|
/* The procedure definition */
|
|
ProcArg gradients_close_popup_in_args[] =
|
|
{
|
|
{ PDB_STRING,
|
|
"callback PDB entry name",
|
|
"The name of the callback registered for this popup",
|
|
},
|
|
};
|
|
|
|
ProcRecord gradients_close_popup_proc =
|
|
{
|
|
"gimp_gradients_close_popup",
|
|
"Popdown the Gimp gradient selection",
|
|
"This procedure closes an opened gradient selection dialog",
|
|
"Andy Thomas",
|
|
"Andy Thomas",
|
|
"1998",
|
|
PDB_INTERNAL,
|
|
|
|
/* Input arguments */
|
|
sizeof(gradients_close_popup_in_args) / sizeof(gradients_close_popup_in_args[0]),
|
|
gradients_close_popup_in_args,
|
|
|
|
/* Output arguments */
|
|
0,
|
|
NULL,
|
|
|
|
/* Exec method */
|
|
{ { gradients_close_popup_invoker } },
|
|
};
|
|
|
|
static Argument *
|
|
gradients_set_popup_invoker (Argument *args)
|
|
{
|
|
gchar * pdbname;
|
|
gchar * gradient_name;
|
|
ProcRecord *prec = NULL;
|
|
GradSelectP gsp;
|
|
|
|
success = (pdbname = (char *) args[0].value.pdb_pointer) != NULL;
|
|
gradient_name = (char *) args[1].value.pdb_pointer;
|
|
|
|
/* Check the proc exists */
|
|
if(!success || (prec = procedural_db_lookup(pdbname)) == NULL)
|
|
{
|
|
success = 0;
|
|
return procedural_db_return_args (&gradients_set_popup_proc, success);
|
|
}
|
|
|
|
gsp = gradients_get_gradientselect(pdbname);
|
|
|
|
if(gsp)
|
|
{
|
|
/* Can alter active_dialogs list*/
|
|
GSList *tmp;
|
|
gradient_t *active = NULL;
|
|
int pos = 0;
|
|
|
|
tmp = gradients_list;
|
|
|
|
while (tmp) {
|
|
active = tmp->data;
|
|
|
|
if (strcmp(gradient_name, active->name) == 0)
|
|
break; /* We found the one we want */
|
|
|
|
pos++;
|
|
tmp = g_slist_next(tmp);
|
|
} /* while */
|
|
|
|
if(active)
|
|
{
|
|
gtk_clist_select_row(GTK_CLIST(gsp->clist),pos,-1);
|
|
gtk_clist_moveto(GTK_CLIST(gsp->clist),pos,0,0.0,0.0);
|
|
success = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
success = FALSE;
|
|
}
|
|
|
|
return procedural_db_return_args (&gradients_close_popup_proc, success);
|
|
}
|
|
|
|
/* The procedure definition */
|
|
ProcArg gradients_set_popup_in_args[] =
|
|
{
|
|
{ PDB_STRING,
|
|
"callback PDB entry name",
|
|
"The name of the callback registered for this popup",
|
|
},
|
|
{ PDB_STRING,
|
|
"gradient name to set",
|
|
"The name of the gradient to set as selected",
|
|
},
|
|
};
|
|
|
|
ProcRecord gradients_set_popup_proc =
|
|
{
|
|
"gimp_gradients_set_popup",
|
|
"Sets the current gradient selection in a popup",
|
|
"Sets the current gradient selection in a popup",
|
|
"Andy Thomas",
|
|
"Andy Thomas",
|
|
"1998",
|
|
PDB_INTERNAL,
|
|
|
|
/* Input arguments */
|
|
sizeof(gradients_set_popup_in_args) / sizeof(gradients_set_popup_in_args[0]),
|
|
gradients_set_popup_in_args,
|
|
|
|
/* Output arguments */
|
|
0,
|
|
NULL,
|
|
|
|
/* Exec method */
|
|
{ { gradients_set_popup_invoker } },
|
|
};
|
|
|
|
/*********************************/
|
|
/* GRADIENTS_GET_GRADIENT_DATA */
|
|
|
|
static Argument *
|
|
gradients_get_gradient_data_invoker (Argument *args)
|
|
{
|
|
gradient_t * grad = NULL;
|
|
GSList *list;
|
|
char *name;
|
|
gint sample_sz;
|
|
|
|
success = (name = (char *) args[0].value.pdb_pointer) != NULL;
|
|
sample_sz = args[1].value.pdb_int;
|
|
|
|
if(sample_sz < 0 || sample_sz > 10000)
|
|
sample_sz = G_SAMPLE;
|
|
|
|
if (!success)
|
|
{
|
|
/* No name use active pattern */
|
|
success = (grad = curr_gradient) != NULL;
|
|
}
|
|
else
|
|
{
|
|
success = FALSE;
|
|
|
|
list = gradients_list;
|
|
|
|
while (list) {
|
|
grad = list->data;
|
|
|
|
if (strcmp(grad->name, name) == 0)
|
|
{
|
|
success = TRUE;
|
|
break; /* We found it! */
|
|
}
|
|
|
|
/* Select that gradient in the listbox */
|
|
/* Only if gradient editor has been created */
|
|
|
|
list = g_slist_next(list);
|
|
} /* while */
|
|
}
|
|
|
|
return_args = procedural_db_return_args (&gradients_get_gradient_data_proc, success);
|
|
|
|
if (success)
|
|
{
|
|
gdouble *values, *pv;
|
|
double pos, delta;
|
|
double r, g, b, a;
|
|
int i = sample_sz;
|
|
gradient_t *oldgrad = curr_gradient;
|
|
pos = 0.0;
|
|
delta = 1.0 / (i - 1);
|
|
|
|
values = g_malloc(i * 4 * sizeof(gdouble));
|
|
pv = values;
|
|
|
|
curr_gradient = grad;
|
|
|
|
while (i--) {
|
|
grad_get_color_at(pos, &r, &g, &b, &a);
|
|
|
|
*pv++ = r;
|
|
*pv++ = g;
|
|
*pv++ = b;
|
|
*pv++ = a;
|
|
|
|
pos += delta;
|
|
} /* while */
|
|
|
|
curr_gradient = oldgrad;
|
|
|
|
return_args[1].value.pdb_pointer = g_strdup (grad->name);
|
|
return_args[2].value.pdb_int = sample_sz*4;
|
|
return_args[3].value.pdb_pointer = values;
|
|
}
|
|
|
|
return return_args;
|
|
}
|
|
|
|
/* The procedure definition */
|
|
|
|
ProcArg gradients_get_gradient_data_in_args[] =
|
|
{
|
|
{ PDB_STRING,
|
|
"name",
|
|
"the gradient name (\"\" means current active gradient) "
|
|
},
|
|
{ PDB_INT32,
|
|
"sample size",
|
|
"size of the sample to return when the gradient is changed (< 10000)"
|
|
},
|
|
};
|
|
|
|
ProcArg gradients_get_gradient_data_out_args[] =
|
|
{
|
|
{ PDB_STRING,
|
|
"name",
|
|
"the gradient name"
|
|
},
|
|
{ PDB_INT32,
|
|
"width",
|
|
"the gradient sample width (r,g,b,a) "
|
|
},
|
|
{ PDB_FLOATARRAY,
|
|
"grad data",
|
|
"the gradient sample data"},
|
|
};
|
|
|
|
ProcRecord gradients_get_gradient_data_proc =
|
|
{
|
|
"gimp_gradients_get_gradient_data",
|
|
"Retrieve information about the specified gradient (including data)",
|
|
"This procedure retrieves information about the gradient. This includes the gradient name, and the sample data for the gradient.",
|
|
"Andy Thomas",
|
|
"Andy Thomas",
|
|
"1998",
|
|
PDB_INTERNAL,
|
|
|
|
/* Input arguments */
|
|
sizeof(gradients_get_gradient_data_in_args) / sizeof(gradients_get_gradient_data_in_args[0]),
|
|
gradients_get_gradient_data_in_args,
|
|
|
|
/* Output arguments */
|
|
sizeof(gradients_get_gradient_data_out_args) / sizeof(gradients_get_gradient_data_out_args[0]),
|
|
gradients_get_gradient_data_out_args,
|
|
|
|
/* Exec method */
|
|
{ { gradients_get_gradient_data_invoker } },
|
|
};
|