dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/gui/color-notebook.c

464 lines
11 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* color_notebook module (C) 1998 Austin Donnelly <austin@greenend.org.uk>
*
* 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 PURPOSE. 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.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "appenv.h"
#include "actionarea.h"
#include "color_notebook.h"
#include "libgimp/color_selector.h"
#include "libgimp/gimpintl.h"
static void color_notebook_ok_callback (GtkWidget *, gpointer);
static void color_notebook_cancel_callback (GtkWidget *, gpointer);
static gint color_notebook_delete_callback (GtkWidget *, GdkEvent *, gpointer);
static void color_notebook_update_callback (void *, int, int, int);
static void color_notebook_page_switch (GtkWidget *, GtkNotebookPage *, guint);
static ActionAreaItem action_items[2] =
{
{ N_("OK"), color_notebook_ok_callback, NULL, NULL },
{ N_("Cancel"), color_notebook_cancel_callback, NULL, NULL },
};
/* information we keep on each registered colour selector */
typedef struct _ColorSelectorInfo {
char *name; /* label used in notebook tab */
GimpColorSelectorMethods m;
int refs; /* number of instances around */
gboolean active;
void (*death_callback) (void *data);
void *death_data;
struct _ColorSelectorInfo *next;
} ColorSelectorInfo;
typedef struct _ColorSelectorInstance {
_ColorNotebook *color_notebook;
ColorSelectorInfo *info;
GtkWidget *frame; /* main widget */
gpointer selector_data;
struct _ColorSelectorInstance *next;
} ColorSelectorInstance;
static void selector_death (ColorSelectorInfo *info);
/* master list of all registered colour selectors */
static ColorSelectorInfo *selector_info = NULL;
#define RED 0
#define GREEN 1
#define BLUE 2
#define NUM_COLORS 3
ColorNotebookP
color_notebook_new (int r,
int g,
int b,
ColorNotebookCallback callback,
void *client_data,
int wants_updates)
{
ColorNotebookP cnp;
GtkWidget *label;
ColorSelectorInfo *info;
ColorSelectorInstance *csel;
g_return_val_if_fail (selector_info != NULL, NULL);
cnp = g_malloc (sizeof (_ColorNotebook));
cnp->callback = callback;
cnp->client_data = client_data;
cnp->wants_updates = wants_updates;
cnp->selectors = NULL;
cnp->cur_page = NULL;
cnp->values[RED] = cnp->orig_values[RED] = r & 0xff;
cnp->values[GREEN] = cnp->orig_values[GREEN] = g & 0xff;
cnp->values[BLUE] = cnp->orig_values[BLUE] = b & 0xff;
/* window hints need to stay the same, so people's window manager
* setups still work */
cnp->shell = gtk_dialog_new ();
gtk_window_set_wmclass (GTK_WINDOW (cnp->shell), "color_selection", "Gimp");
gtk_window_set_title (GTK_WINDOW (cnp->shell), _("Color Selection"));
gtk_window_set_policy (GTK_WINDOW (cnp->shell), FALSE, FALSE, FALSE);
/* handle the wm close signal */
gtk_signal_connect (GTK_OBJECT (cnp->shell), "delete_event",
(GtkSignalFunc) color_notebook_delete_callback, cnp);
/* do we actually need a notebook? */
if (selector_info->next)
{
cnp->notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cnp->shell)->vbox),
cnp->notebook, TRUE, TRUE, 1);
gtk_widget_show (cnp->notebook);
}
else /* only one selector */
{
cnp->notebook = NULL;
}
/* create each registered colour selector */
info = selector_info;
while (info)
{
if (info->active)
{
csel = g_malloc (sizeof (ColorSelectorInstance));
csel->color_notebook = cnp;
csel->info = info;
info->refs++;
csel->frame = info->m.new (r, g, b,
color_notebook_update_callback, csel,
&csel->selector_data);
gtk_object_set_data (GTK_OBJECT (csel->frame), "gimp_color_notebook",
csel);
if (cnp->notebook)
{
label = gtk_label_new (info->name);
gtk_widget_show (label);
/* hide the frame, so it doesn't get selected by mistake */
gtk_widget_hide (csel->frame);
gtk_notebook_append_page (GTK_NOTEBOOK (cnp->notebook),
csel->frame, label);
}
else
{
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cnp->shell)->vbox),
csel->frame, TRUE, TRUE, 1);
}
gtk_widget_show (csel->frame);
if (!cnp->cur_page)
cnp->cur_page = csel;
/* link into list of all selectors hanging off the new notebook */
csel->next = cnp->selectors;
cnp->selectors = csel;
}
info = info->next;
}
/* The action area */
action_items[0].user_data = cnp;
action_items[1].user_data = cnp;
if (cnp->wants_updates)
{
action_items[0].label = _("Close");
action_items[1].label = _("Revert to Old Color");
}
else
{
action_items[0].label = _("OK");
action_items[1].label = _("Cancel");
}
build_action_area (GTK_DIALOG (cnp->shell), action_items, 2, 0);
gtk_widget_show (cnp->shell);
/* this must come after showing the widget, otherwise we get a
* switch_page signal for a non-visible color selector, which is bad
* news. */
if (cnp->notebook)
{
gtk_object_set_user_data (GTK_OBJECT (cnp->notebook), cnp);
gtk_signal_connect (GTK_OBJECT (cnp->notebook), "switch_page",
(GtkSignalFunc)color_notebook_page_switch, NULL);
}
return cnp;
}
void
color_notebook_show (ColorNotebookP cnp)
{
g_return_if_fail (cnp != NULL);
gtk_widget_show (cnp->shell);
}
void
color_notebook_hide (ColorNotebookP cnp)
{
g_return_if_fail (cnp != NULL);
gtk_widget_hide (cnp->shell);
}
void
color_notebook_free (ColorNotebookP cnp)
{
ColorSelectorInstance *csel, *next;
g_return_if_fail (cnp != NULL);
gtk_widget_destroy (cnp->shell);
/* call the free functions for all the colour selectors */
csel = cnp->selectors;
while (csel)
{
next = csel->next;
csel->info->m.free (csel->selector_data);
csel->info->refs--;
if (csel->info->refs == 0 && !csel->info->active)
selector_death (csel->info);
g_free (csel);
csel = next;
}
g_free (cnp);
}
void
color_notebook_set_color (ColorNotebookP cnp,
int r,
int g,
int b,
int set_current)
{
ColorSelectorInstance *csel;
g_return_if_fail (cnp != NULL);
cnp->orig_values[RED] = r;
cnp->orig_values[GREEN] = g;
cnp->orig_values[BLUE] = b;
if (set_current)
{
cnp->values[RED] = r;
cnp->values[GREEN] = g;
cnp->values[BLUE] = b;
}
csel = cnp->cur_page;
csel->info->m.setcolor (csel->selector_data, r, g, b, set_current);
}
/* Called by a colour selector on user selection of a colour */
static void
color_notebook_update_callback (void *data, int r, int g, int b)
{
ColorSelectorInstance *csel;
ColorNotebookP cnp;
g_return_if_fail (data != NULL);
csel = (ColorSelectorInstance *) data;
cnp = csel->color_notebook;
cnp->values[RED] = r;
cnp->values[GREEN] = g;
cnp->values[BLUE] = b;
if (cnp->wants_updates && cnp->callback)
{
(* cnp->callback) (cnp->values[RED],
cnp->values[GREEN],
cnp->values[BLUE],
COLOR_NOTEBOOK_UPDATE,
cnp->client_data);
}
}
static void
color_notebook_ok_callback (GtkWidget *w,
gpointer client_data)
{
ColorNotebookP cnp;
cnp = (ColorNotebookP) client_data;
if (cnp->callback)
(* cnp->callback) (cnp->values[RED],
cnp->values[GREEN],
cnp->values[BLUE],
COLOR_NOTEBOOK_OK,
cnp->client_data);
}
static gint
color_notebook_delete_callback (GtkWidget *w,
GdkEvent *e,
gpointer client_data)
{
color_notebook_cancel_callback (w, client_data);
return TRUE;
}
static void
color_notebook_cancel_callback (GtkWidget *w,
gpointer client_data)
{
ColorNotebookP cnp;
cnp = (ColorNotebookP) client_data;
if (cnp->callback)
(* cnp->callback) (cnp->orig_values[RED],
cnp->orig_values[GREEN],
cnp->orig_values[BLUE],
COLOR_NOTEBOOK_CANCEL,
cnp->client_data);
}
static void
color_notebook_page_switch (GtkWidget *w,
GtkNotebookPage *page,
guint page_num)
{
ColorNotebookP cnp;
ColorSelectorInstance *csel;
cnp = gtk_object_get_user_data (GTK_OBJECT (w));
csel = gtk_object_get_data (GTK_OBJECT(page->child), "gimp_color_notebook");
g_return_if_fail (cnp != NULL && csel != NULL);
cnp->cur_page = csel;
csel->info->m.setcolor (csel->selector_data,
cnp->values[RED],
cnp->values[GREEN],
cnp->values[BLUE],
TRUE);
}
/**************************************************************/
/* Registration functions */
GimpColorSelectorID
gimp_color_selector_register (const char *name,
GimpColorSelectorMethods *methods)
{
ColorSelectorInfo *info;
/* check the name is unique */
info = selector_info;
while (info)
{
if (!strcmp (info->name, name))
return NULL;
info = info->next;
}
info = g_malloc (sizeof (ColorSelectorInfo));
info->name = g_strdup (name);
info->m = *methods;
info->refs = 0;
info->active = TRUE;
info->next = selector_info;
selector_info = info;
return info;
}
gboolean
gimp_color_selector_unregister (GimpColorSelectorID id,
void (*callback)(void *data),
void *data)
{
ColorSelectorInfo *info;
info = selector_info;
while (info)
{
if (info == id)
{
info->active = FALSE;
info->death_callback = callback;
info->death_data = data;
if (info->refs == 0)
selector_death (info);
return TRUE;
}
info = info->next;
}
g_warning ("unknown color selector id %p", id);
return FALSE;
}
static void
selector_death (ColorSelectorInfo *info)
{
ColorSelectorInfo *here, *prev;
here = selector_info;
prev = NULL;
while (here)
{
if (here == info)
{
if (prev)
prev->next = info->next;
else
selector_info = info->next;
if (info->death_callback)
(*info->death_callback) (info->death_data);
g_free (info->name);
g_free (info);
return;
}
prev = here;
here = here->next;
}
g_warning ("color selector %p not found, can't happen!", info);
}
/* End of color_notebook.c */
Reference in New Issue View Git Blame Copy Permalink