mirror of https://github.com/GNOME/gimp.git
configure.in new directory containing all widgets. Some of them will go to
2001-04-11 Michael Natterer <mitch@gimp.org> * configure.in * app/widgets/*: new directory containing all widgets. Some of them will go to libgimpwidgets. * app/color_panel.[ch] * app/gimpbrushpreview.[ch] * app/gimpconstrainedhwrapbox.[ch] * app/gimpcontainergridview.[ch] * app/gimpcontainerlistview.[ch] * app/gimpcontainerview.[ch] * app/gimpdatafactoryview.[ch] * app/gimpdock.[ch] * app/gimpdockable.[ch] * app/gimpdockbook.[ch] * app/gimpdrawablelistitem.[ch] * app/gimpdrawablelistview.[ch] * app/gimpdrawablepreview.[ch] * app/gimpgradientpreview.[ch] * app/gimpimagepreview.[ch] * app/gimplayerlistitem.[ch] * app/gimplayerlistview.{ch] * app/gimplistitem.[ch] * app/gimppalettepreview.[ch] * app/gimppatternpreview.[ch] * app/gimppreview.[ch] * app/gimptoolinfopreview.[ch] * app/gtkhwrapbox.[ch] * app/gtkvwrapbox.[ch] * app/gtkwrapbox.[ch] * app/histogramwidget.[ch]: removed from here. * app/Makefile.am * app/appenums.h * app/brush_select.c * app/channels_dialog.c * app/devices.c * app/gimpdnd.c * app/gimpdrawable-preview.c * app/gimphistogram.h * app/gradient_editor.c * app/gradient_select.c * app/indicator_area.c * app/info_window.c * app/palette.c * app/palette_select.c * app/pattern_select.c * app/qmask.c * app/test_commands.c * app/toolbox.c * app/pdb/color_cmds.c * app/tools/paint_options.c * app/tools/tool_options_dialog.c * tools/pdbgen/pdb/color.pdb: changed accordingly.
This commit is contained in:
parent
e44303aeba
commit
594496b132
56
ChangeLog
56
ChangeLog
|
@ -1,3 +1,59 @@
|
|||
2001-04-11 Michael Natterer <mitch@gimp.org>
|
||||
|
||||
* configure.in
|
||||
* app/widgets/*: new directory containing all widgets. Some of them
|
||||
will go to libgimpwidgets.
|
||||
|
||||
* app/color_panel.[ch]
|
||||
* app/gimpbrushpreview.[ch]
|
||||
* app/gimpconstrainedhwrapbox.[ch]
|
||||
* app/gimpcontainergridview.[ch]
|
||||
* app/gimpcontainerlistview.[ch]
|
||||
* app/gimpcontainerview.[ch]
|
||||
* app/gimpdatafactoryview.[ch]
|
||||
* app/gimpdock.[ch]
|
||||
* app/gimpdockable.[ch]
|
||||
* app/gimpdockbook.[ch]
|
||||
* app/gimpdrawablelistitem.[ch]
|
||||
* app/gimpdrawablelistview.[ch]
|
||||
* app/gimpdrawablepreview.[ch]
|
||||
* app/gimpgradientpreview.[ch]
|
||||
* app/gimpimagepreview.[ch]
|
||||
* app/gimplayerlistitem.[ch]
|
||||
* app/gimplayerlistview.{ch]
|
||||
* app/gimplistitem.[ch]
|
||||
* app/gimppalettepreview.[ch]
|
||||
* app/gimppatternpreview.[ch]
|
||||
* app/gimppreview.[ch]
|
||||
* app/gimptoolinfopreview.[ch]
|
||||
* app/gtkhwrapbox.[ch]
|
||||
* app/gtkvwrapbox.[ch]
|
||||
* app/gtkwrapbox.[ch]
|
||||
* app/histogramwidget.[ch]: removed from here.
|
||||
|
||||
* app/Makefile.am
|
||||
* app/appenums.h
|
||||
* app/brush_select.c
|
||||
* app/channels_dialog.c
|
||||
* app/devices.c
|
||||
* app/gimpdnd.c
|
||||
* app/gimpdrawable-preview.c
|
||||
* app/gimphistogram.h
|
||||
* app/gradient_editor.c
|
||||
* app/gradient_select.c
|
||||
* app/indicator_area.c
|
||||
* app/info_window.c
|
||||
* app/palette.c
|
||||
* app/palette_select.c
|
||||
* app/pattern_select.c
|
||||
* app/qmask.c
|
||||
* app/test_commands.c
|
||||
* app/toolbox.c
|
||||
* app/pdb/color_cmds.c
|
||||
* app/tools/paint_options.c
|
||||
* app/tools/tool_options_dialog.c
|
||||
* tools/pdbgen/pdb/color.pdb: changed accordingly.
|
||||
|
||||
2001-04-10 Michael Natterer <mitch@gimp.org>
|
||||
|
||||
* app/gimpdock.c: started to add some more separator event handling.
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
## Process this file with automake to produce Makefile.in
|
||||
|
||||
SUBDIRS = paint-funcs pdb tools
|
||||
SUBDIRS = paint-funcs pdb tools widgets
|
||||
|
||||
scriptdata =
|
||||
|
||||
|
@ -51,8 +51,6 @@ gimp_SOURCES = \
|
|||
color_area.h \
|
||||
color_notebook.c \
|
||||
color_notebook.h \
|
||||
color_panel.c \
|
||||
color_panel.h \
|
||||
color_select.c \
|
||||
color_select.h \
|
||||
color_transfer.c \
|
||||
|
@ -305,57 +303,6 @@ gimp_SOURCES = \
|
|||
tile_swap.c \
|
||||
tile_swap.h \
|
||||
\
|
||||
gimpbrushpreview.c \
|
||||
gimpbrushpreview.h \
|
||||
gimpcontainergridview.h \
|
||||
gimpcontainergridview.c \
|
||||
gimpcontainerlistview.h \
|
||||
gimpcontainerlistview.c \
|
||||
gimpcontainerview.h \
|
||||
gimpcontainerview.c \
|
||||
gimpdatafactoryview.h \
|
||||
gimpdatafactoryview.c \
|
||||
gimpdock.c \
|
||||
gimpdock.h \
|
||||
gimpdockable.c \
|
||||
gimpdockable.h \
|
||||
gimpdockbook.c \
|
||||
gimpdockbook.h \
|
||||
gimpdrawablelistitem.c \
|
||||
gimpdrawablelistitem.h \
|
||||
gimpdrawablelistview.c \
|
||||
gimpdrawablelistview.h \
|
||||
gimpdrawablepreview.c \
|
||||
gimpdrawablepreview.h \
|
||||
gimpgradientpreview.h \
|
||||
gimpgradientpreview.c \
|
||||
gimpimagepreview.h \
|
||||
gimpimagepreview.c \
|
||||
gimplayerlistitem.h \
|
||||
gimplayerlistitem.c \
|
||||
gimplayerlistview.h \
|
||||
gimplayerlistview.c \
|
||||
gimplistitem.h \
|
||||
gimplistitem.c \
|
||||
gimppalettepreview.h \
|
||||
gimppalettepreview.c \
|
||||
gimppatternpreview.h \
|
||||
gimppatternpreview.c \
|
||||
gimppreview.h \
|
||||
gimppreview.c \
|
||||
gimptoolinfopreview.h \
|
||||
gimptoolinfopreview.c \
|
||||
gtkwrapbox.c \
|
||||
gtkwrapbox.h \
|
||||
gtkhwrapbox.c \
|
||||
gtkhwrapbox.h \
|
||||
gtkvwrapbox.c \
|
||||
gtkvwrapbox.h \
|
||||
gimpconstrainedhwrapbox.c \
|
||||
gimpconstrainedhwrapbox.h \
|
||||
histogramwidget.c \
|
||||
histogramwidget.h \
|
||||
\
|
||||
marching_ants.h \
|
||||
pixmaps2.h
|
||||
|
||||
|
@ -390,6 +337,7 @@ gimp_LDADD = \
|
|||
paint-funcs/libapppaint-funcs.la \
|
||||
pdb/libapppdb.la \
|
||||
tools/libapptools.la \
|
||||
widgets/libappwidgets.la \
|
||||
$(top_builddir)/libgimpcolor/libgimpcolor-$(LT_RELEASE).la \
|
||||
$(top_builddir)/libgimpmath/libgimpmath-$(LT_RELEASE).la \
|
||||
$(top_builddir)/libgimpwidgets/libgimpwidgets-$(LT_RELEASE).la \
|
||||
|
|
|
@ -29,7 +29,8 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "color_panel.h"
|
||||
#include "widgets/gimpcolorpanel.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "floating_sel.h"
|
||||
#include "gdisplay.h"
|
||||
|
|
|
@ -29,7 +29,8 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "color_panel.h"
|
||||
#include "widgets/gimpcolorpanel.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "floating_sel.h"
|
||||
#include "gdisplay.h"
|
||||
|
|
|
@ -263,6 +263,16 @@ typedef enum /*< skip >*/
|
|||
CURSOR_MODE_CROSSHAIR
|
||||
} CursorMode;
|
||||
|
||||
typedef enum /*< skip >*/
|
||||
{
|
||||
GIMP_HISTOGRAM_VALUE = 0,
|
||||
GIMP_HISTOGRAM_RED = 1,
|
||||
GIMP_HISTOGRAM_GREEN = 2,
|
||||
GIMP_HISTOGRAM_BLUE = 3,
|
||||
GIMP_HISTOGRAM_ALPHA = 4
|
||||
} GimpHistogramChannel;
|
||||
|
||||
|
||||
typedef enum /*< skip >*/
|
||||
{
|
||||
GIMP_TOOL_CURSOR_NONE,
|
||||
|
|
|
@ -22,16 +22,6 @@
|
|||
#define __GIMP_HISTOGRAM_H__
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
GIMP_HISTOGRAM_VALUE = 0,
|
||||
GIMP_HISTOGRAM_RED = 1,
|
||||
GIMP_HISTOGRAM_GREEN = 2,
|
||||
GIMP_HISTOGRAM_BLUE = 3,
|
||||
GIMP_HISTOGRAM_ALPHA = 4
|
||||
} GimpHistogramChannel;
|
||||
|
||||
|
||||
GimpHistogram * gimp_histogram_new (void);
|
||||
void gimp_histogram_free (GimpHistogram *histogram);
|
||||
void gimp_histogram_calculate (GimpHistogram *historgam,
|
||||
|
|
|
@ -26,6 +26,8 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "brush_edit.h"
|
||||
|
@ -33,7 +35,6 @@
|
|||
#include "dialog_handler.h"
|
||||
#include "gimpbrushgenerated.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdata.h"
|
||||
#include "gimpdatafactory.h"
|
||||
|
|
|
@ -29,9 +29,10 @@
|
|||
|
||||
#include "paint-funcs/paint-funcs.h"
|
||||
|
||||
#include "widgets/gimpcolorpanel.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "channels_dialog.h"
|
||||
#include "color_panel.h"
|
||||
#include "drawable.h"
|
||||
#include "gdisplay.h"
|
||||
#include "gimage.h"
|
||||
|
|
|
@ -1,220 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "color_panel.h"
|
||||
#include "color_notebook.h"
|
||||
|
||||
|
||||
struct _GimpColorPanel
|
||||
{
|
||||
GimpColorButton parent;
|
||||
|
||||
ColorNotebook *color_notebook;
|
||||
gboolean color_notebook_active;
|
||||
};
|
||||
|
||||
/* local function prototypes */
|
||||
static void gimp_color_panel_class_init (GimpColorPanelClass *klass);
|
||||
static void gimp_color_panel_init (GimpColorPanel *panel);
|
||||
static void gimp_color_panel_destroy (GtkObject *object);
|
||||
static void gimp_color_panel_color_changed (GimpColorButton *button);
|
||||
static void gimp_color_panel_clicked (GtkButton *button);
|
||||
|
||||
static void gimp_color_panel_select_callback (ColorNotebook *notebook,
|
||||
const GimpRGB *color,
|
||||
ColorNotebookState state,
|
||||
gpointer data);
|
||||
|
||||
|
||||
static GimpColorButtonClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_color_panel_get_type (void)
|
||||
{
|
||||
static guint panel_type = 0;
|
||||
|
||||
if (!panel_type)
|
||||
{
|
||||
GtkTypeInfo panel_info =
|
||||
{
|
||||
"GimpColorPanel",
|
||||
sizeof (GimpColorPanel),
|
||||
sizeof (GimpColorPanelClass),
|
||||
(GtkClassInitFunc) gimp_color_panel_class_init,
|
||||
(GtkObjectInitFunc) gimp_color_panel_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
panel_type = gtk_type_unique (GIMP_TYPE_COLOR_BUTTON, &panel_info);
|
||||
}
|
||||
|
||||
return panel_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_color_panel_class_init (GimpColorPanelClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkButtonClass *button_class;
|
||||
GimpColorButtonClass *color_button_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
button_class = (GtkButtonClass *) klass;
|
||||
color_button_class = (GimpColorButtonClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_COLOR_BUTTON);
|
||||
|
||||
object_class->destroy = gimp_color_panel_destroy;
|
||||
button_class->clicked = gimp_color_panel_clicked;
|
||||
color_button_class->color_changed = gimp_color_panel_color_changed;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_color_panel_init (GimpColorPanel *panel)
|
||||
{
|
||||
panel->color_notebook = NULL;
|
||||
panel->color_notebook_active = FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_color_panel_destroy (GtkObject *object)
|
||||
{
|
||||
GimpColorPanel *panel;
|
||||
|
||||
g_return_if_fail (object != NULL);
|
||||
g_return_if_fail (GIMP_IS_COLOR_PANEL (object));
|
||||
|
||||
panel = GIMP_COLOR_PANEL (object);
|
||||
|
||||
/* make sure we hide and free color_notebook */
|
||||
if (panel->color_notebook)
|
||||
{
|
||||
color_notebook_hide (panel->color_notebook);
|
||||
color_notebook_free (panel->color_notebook);
|
||||
}
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_color_panel_new (const gchar *title,
|
||||
const GimpRGB *color,
|
||||
GimpColorAreaType type,
|
||||
gint width,
|
||||
gint height)
|
||||
{
|
||||
GimpColorPanel *panel;
|
||||
|
||||
g_return_val_if_fail (color != NULL, NULL);
|
||||
|
||||
panel = gtk_type_new (GIMP_TYPE_COLOR_PANEL);
|
||||
|
||||
GIMP_COLOR_BUTTON (panel)->title = g_strdup (title);
|
||||
|
||||
gimp_color_button_set_type (GIMP_COLOR_BUTTON (panel), type);
|
||||
gimp_color_button_set_color (GIMP_COLOR_BUTTON (panel), color);
|
||||
gtk_widget_set_usize (GTK_WIDGET (panel), width, height);
|
||||
|
||||
return GTK_WIDGET (panel);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_color_panel_color_changed (GimpColorButton *button)
|
||||
{
|
||||
GimpColorPanel *panel;
|
||||
GimpRGB color;
|
||||
|
||||
panel = GIMP_COLOR_PANEL (button);
|
||||
|
||||
if (panel->color_notebook_active)
|
||||
{
|
||||
gimp_color_button_get_color (GIMP_COLOR_BUTTON (button), &color);
|
||||
color_notebook_set_color (panel->color_notebook, &color);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_color_panel_clicked (GtkButton *button)
|
||||
{
|
||||
GimpColorPanel *panel;
|
||||
GimpRGB color;
|
||||
|
||||
panel = GIMP_COLOR_PANEL (button);
|
||||
|
||||
gimp_color_button_get_color (GIMP_COLOR_BUTTON (button), &color);
|
||||
|
||||
if (! panel->color_notebook)
|
||||
{
|
||||
panel->color_notebook =
|
||||
color_notebook_new (GIMP_COLOR_BUTTON (button)->title,
|
||||
(const GimpRGB *) &color,
|
||||
gimp_color_panel_select_callback,
|
||||
panel,
|
||||
FALSE,
|
||||
gimp_color_button_has_alpha (GIMP_COLOR_BUTTON (button)));
|
||||
panel->color_notebook_active = TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (! panel->color_notebook_active)
|
||||
{
|
||||
color_notebook_show (panel->color_notebook);
|
||||
panel->color_notebook_active = TRUE;
|
||||
}
|
||||
color_notebook_set_color (panel->color_notebook, &color);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_color_panel_select_callback (ColorNotebook *notebook,
|
||||
const GimpRGB *color,
|
||||
ColorNotebookState state,
|
||||
gpointer data)
|
||||
{
|
||||
GimpColorPanel *panel;
|
||||
|
||||
panel = GIMP_COLOR_PANEL (data);
|
||||
|
||||
if (panel->color_notebook)
|
||||
{
|
||||
switch (state)
|
||||
{
|
||||
case COLOR_NOTEBOOK_UPDATE:
|
||||
break;
|
||||
case COLOR_NOTEBOOK_OK:
|
||||
gimp_color_button_set_color (GIMP_COLOR_BUTTON (panel), color);
|
||||
/* Fallthrough */
|
||||
case COLOR_NOTEBOOK_CANCEL:
|
||||
color_notebook_hide (panel->color_notebook);
|
||||
panel->color_notebook_active = FALSE;
|
||||
}
|
||||
}
|
||||
}
|
|
@ -1,48 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __COLOR_PANEL_H__
|
||||
#define __COLOR_PANEL_H__
|
||||
|
||||
|
||||
#include "libgimpwidgets/gimpcolorbutton.h"
|
||||
|
||||
|
||||
#define GIMP_TYPE_COLOR_PANEL (gimp_color_panel_get_type ())
|
||||
#define GIMP_COLOR_PANEL(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_COLOR_PANEL, GimpColorPanel))
|
||||
#define GIMP_COLOR_PANEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_PANEL, GimpColorPanelClass))
|
||||
#define GIMP_IS_COLOR_PANEL(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_COLOR_PANEL))
|
||||
#define GIMP_IS_COLOR_PANEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_PANEL))
|
||||
|
||||
typedef struct _GimpColorPanel GimpColorPanel;
|
||||
typedef struct _GimpColorPanelClass GimpColorPanelClass;
|
||||
|
||||
struct _GimpColorPanelClass
|
||||
{
|
||||
GimpColorButtonClass parent_class;
|
||||
};
|
||||
|
||||
GtkType gimp_color_panel_get_type (void);
|
||||
GtkWidget * gimp_color_panel_new (const gchar *title,
|
||||
const GimpRGB *color,
|
||||
GimpColorAreaType type,
|
||||
gint width,
|
||||
gint height);
|
||||
|
||||
|
||||
#endif /* __COLOR_PANEL_H__ */
|
|
@ -28,10 +28,11 @@
|
|||
|
||||
#include "paint-funcs/paint-funcs.h"
|
||||
|
||||
#include "widgets/gimpdrawablepreview.h"
|
||||
|
||||
#include "gimpchannel.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimpdrawable.h"
|
||||
#include "gimpdrawablepreview.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimppreviewcache.h"
|
||||
#include "pixel_region.h"
|
||||
|
|
|
@ -29,7 +29,8 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "color_panel.h"
|
||||
#include "widgets/gimpcolorpanel.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "floating_sel.h"
|
||||
#include "gdisplay.h"
|
||||
|
|
|
@ -29,7 +29,8 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "color_panel.h"
|
||||
#include "widgets/gimpcolorpanel.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "floating_sel.h"
|
||||
#include "gdisplay.h"
|
||||
|
|
|
@ -31,6 +31,8 @@
|
|||
#include "tools/gimptoolinfo.h"
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "devices.h"
|
||||
|
@ -41,7 +43,6 @@
|
|||
#include "gimpdnd.h"
|
||||
#include "gimpgradient.h"
|
||||
#include "gimppattern.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimplist.h"
|
||||
#include "gimprc.h"
|
||||
#include "session.h"
|
||||
|
|
|
@ -28,13 +28,14 @@
|
|||
#include "tools/gimpcolorpickertool.h"
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "context_manager.h"
|
||||
#include "colormaps.h"
|
||||
#include "gdisplay.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimppreview.h"
|
||||
#include "info_dialog.h"
|
||||
#include "info_window.h"
|
||||
|
||||
|
|
|
@ -29,7 +29,8 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "color_panel.h"
|
||||
#include "widgets/gimpcolorpanel.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "floating_sel.h"
|
||||
#include "gdisplay.h"
|
||||
|
|
|
@ -1,363 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpBrushPreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpbrush.h"
|
||||
#include "gimpbrushpipe.h"
|
||||
#include "gimpbrushpreview.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "temp_buf.h"
|
||||
|
||||
|
||||
static void gimp_brush_preview_class_init (GimpBrushPreviewClass *klass);
|
||||
static void gimp_brush_preview_init (GimpBrushPreview *preview);
|
||||
|
||||
static void gimp_brush_preview_destroy (GtkObject *object);
|
||||
static void gimp_brush_preview_render (GimpPreview *preview);
|
||||
static GtkWidget * gimp_brush_preview_create_popup (GimpPreview *preview);
|
||||
static gboolean gimp_brush_preview_needs_popup (GimpPreview *preview);
|
||||
|
||||
static gboolean gimp_brush_preview_render_timeout_func (GimpBrushPreview *preview);
|
||||
|
||||
|
||||
static GimpPreviewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_brush_preview_get_type (void)
|
||||
{
|
||||
static GtkType preview_type = 0;
|
||||
|
||||
if (! preview_type)
|
||||
{
|
||||
GtkTypeInfo preview_info =
|
||||
{
|
||||
"GimpBrushPreview",
|
||||
sizeof (GimpBrushPreview),
|
||||
sizeof (GimpBrushPreviewClass),
|
||||
(GtkClassInitFunc) gimp_brush_preview_class_init,
|
||||
(GtkObjectInitFunc) gimp_brush_preview_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
preview_type = gtk_type_unique (GIMP_TYPE_PREVIEW, &preview_info);
|
||||
}
|
||||
|
||||
return preview_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_brush_preview_class_init (GimpBrushPreviewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpPreviewClass *preview_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
preview_class = (GimpPreviewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_PREVIEW);
|
||||
|
||||
object_class->destroy = gimp_brush_preview_destroy;
|
||||
|
||||
preview_class->render = gimp_brush_preview_render;
|
||||
preview_class->create_popup = gimp_brush_preview_create_popup;
|
||||
preview_class->needs_popup = gimp_brush_preview_needs_popup;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_brush_preview_init (GimpBrushPreview *brush_preview)
|
||||
{
|
||||
brush_preview->pipe_timeout_id = 0;
|
||||
brush_preview->pipe_animation_index = 0;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_brush_preview_destroy (GtkObject *object)
|
||||
{
|
||||
GimpBrushPreview *brush_preview;
|
||||
|
||||
brush_preview = GIMP_BRUSH_PREVIEW (object);
|
||||
|
||||
if (brush_preview->pipe_timeout_id)
|
||||
{
|
||||
g_source_remove (brush_preview->pipe_timeout_id);
|
||||
|
||||
brush_preview->pipe_timeout_id = 0;
|
||||
brush_preview->pipe_animation_index = 0;
|
||||
}
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
#define indicator_width 7
|
||||
#define indicator_height 7
|
||||
|
||||
#define WHT { 255, 255, 255 }
|
||||
#define BLK { 0, 0, 0 }
|
||||
#define RED { 255, 127, 127 }
|
||||
|
||||
static void
|
||||
gimp_brush_preview_render (GimpPreview *preview)
|
||||
{
|
||||
GimpBrushPreview *brush_preview;
|
||||
GimpBrush *brush;
|
||||
TempBuf *temp_buf;
|
||||
gint width;
|
||||
gint height;
|
||||
gint brush_width;
|
||||
gint brush_height;
|
||||
guchar *buf;
|
||||
guchar *b;
|
||||
gint x, y;
|
||||
gint offset_x;
|
||||
gint offset_y;
|
||||
|
||||
brush_preview = GIMP_BRUSH_PREVIEW (preview);
|
||||
|
||||
if (brush_preview->pipe_timeout_id)
|
||||
{
|
||||
g_source_remove (brush_preview->pipe_timeout_id);
|
||||
|
||||
brush_preview->pipe_timeout_id = 0;
|
||||
}
|
||||
|
||||
brush = GIMP_BRUSH (preview->viewable);
|
||||
brush_width = brush->mask->width;
|
||||
brush_height = brush->mask->height;
|
||||
|
||||
width = preview->width;
|
||||
height = preview->height;
|
||||
|
||||
temp_buf = gimp_viewable_get_new_preview (preview->viewable,
|
||||
width,
|
||||
height);
|
||||
|
||||
if (preview->is_popup)
|
||||
{
|
||||
gimp_preview_render_and_flush (preview,
|
||||
temp_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
|
||||
if (GIMP_IS_BRUSH_PIPE (brush))
|
||||
{
|
||||
if (width != brush_width ||
|
||||
height != brush_height)
|
||||
{
|
||||
g_warning ("%s(): non-fullsize pipe popups are not supported yet.",
|
||||
G_GNUC_FUNCTION);
|
||||
return;
|
||||
}
|
||||
|
||||
brush_preview->pipe_animation_index = 0;
|
||||
brush_preview->pipe_timeout_id =
|
||||
g_timeout_add (300,
|
||||
(GSourceFunc) gimp_brush_preview_render_timeout_func,
|
||||
brush_preview);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
buf = temp_buf_data (temp_buf);
|
||||
|
||||
if (width < brush_width || height < brush_height)
|
||||
{
|
||||
static const guchar scale_indicator_bits[7][7][3] =
|
||||
{
|
||||
{ WHT, WHT, WHT, WHT, WHT, WHT, WHT },
|
||||
{ WHT, WHT, WHT, BLK, WHT, WHT, WHT },
|
||||
{ WHT, WHT, WHT, BLK, WHT, WHT, WHT },
|
||||
{ WHT, BLK, BLK, BLK, BLK, BLK, WHT },
|
||||
{ WHT, WHT, WHT, BLK, WHT, WHT, WHT },
|
||||
{ WHT, WHT, WHT, BLK, WHT, WHT, WHT },
|
||||
{ WHT, WHT, WHT, WHT, WHT, WHT, WHT }
|
||||
};
|
||||
|
||||
static const guchar scale_pipe_indicator_bits[7][7][3] =
|
||||
{
|
||||
{ WHT, WHT, WHT, WHT, WHT, WHT, WHT },
|
||||
{ WHT, WHT, WHT, BLK, WHT, WHT, RED },
|
||||
{ WHT, WHT, WHT, BLK, WHT, RED, RED },
|
||||
{ WHT, BLK, BLK, BLK, BLK, BLK, RED },
|
||||
{ WHT, WHT, WHT, BLK, RED, RED, RED },
|
||||
{ WHT, WHT, RED, BLK, RED, RED, RED },
|
||||
{ WHT, RED, RED, RED, RED, RED, RED }
|
||||
};
|
||||
|
||||
offset_x = width - indicator_width;
|
||||
offset_y = height - indicator_height;
|
||||
|
||||
b = buf + (offset_y * width + offset_x) * temp_buf->bytes;
|
||||
|
||||
for (y = 0; y < indicator_height; y++)
|
||||
{
|
||||
for (x = 0; x < indicator_height; x++)
|
||||
{
|
||||
if (GIMP_IS_BRUSH_PIPE (brush))
|
||||
{
|
||||
*b++ = scale_pipe_indicator_bits[y][x][0];
|
||||
*b++ = scale_pipe_indicator_bits[y][x][1];
|
||||
*b++ = scale_pipe_indicator_bits[y][x][2];
|
||||
}
|
||||
else
|
||||
{
|
||||
*b++ = scale_indicator_bits[y][x][0];
|
||||
*b++ = scale_indicator_bits[y][x][1];
|
||||
*b++ = scale_indicator_bits[y][x][2];
|
||||
}
|
||||
}
|
||||
|
||||
b += (width - indicator_width) * temp_buf->bytes;
|
||||
}
|
||||
}
|
||||
else if (GIMP_IS_BRUSH_PIPE (brush))
|
||||
{
|
||||
static const guchar pipe_indicator_bits[7][7][3] =
|
||||
{
|
||||
{ WHT, WHT, WHT, WHT, WHT, WHT, WHT },
|
||||
{ WHT, WHT, WHT, WHT, WHT, WHT, RED },
|
||||
{ WHT, WHT, WHT, WHT, WHT, RED, RED },
|
||||
{ WHT, WHT, WHT, WHT, RED, RED, RED },
|
||||
{ WHT, WHT, WHT, RED, RED, RED, RED },
|
||||
{ WHT, WHT, RED, RED, RED, RED, RED },
|
||||
{ WHT, RED, RED, RED, RED, RED, RED }
|
||||
};
|
||||
|
||||
offset_x = width - indicator_width;
|
||||
offset_y = height - indicator_height;
|
||||
|
||||
b = buf + (offset_y * width + offset_x) * temp_buf->bytes;
|
||||
|
||||
for (y = 0; y < indicator_height; y++)
|
||||
{
|
||||
for (x = 0; x < indicator_height; x++)
|
||||
{
|
||||
*b++ = pipe_indicator_bits[y][x][0];
|
||||
*b++ = pipe_indicator_bits[y][x][1];
|
||||
*b++ = pipe_indicator_bits[y][x][2];
|
||||
}
|
||||
|
||||
b += (width - indicator_width) * temp_buf->bytes;
|
||||
}
|
||||
}
|
||||
|
||||
#undef indicator_width
|
||||
#undef indicator_height
|
||||
|
||||
#undef WHT
|
||||
#undef BLK
|
||||
#undef RED
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
temp_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
}
|
||||
|
||||
static GtkWidget *
|
||||
gimp_brush_preview_create_popup (GimpPreview *preview)
|
||||
{
|
||||
gint popup_width;
|
||||
gint popup_height;
|
||||
|
||||
popup_width = GIMP_BRUSH (preview->viewable)->mask->width;
|
||||
popup_height = GIMP_BRUSH (preview->viewable)->mask->height;
|
||||
|
||||
return gimp_preview_new_full (preview->viewable,
|
||||
popup_width,
|
||||
popup_height,
|
||||
0,
|
||||
TRUE, FALSE, FALSE);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_brush_preview_needs_popup (GimpPreview *preview)
|
||||
{
|
||||
GimpBrush *brush;
|
||||
gint brush_width;
|
||||
gint brush_height;
|
||||
|
||||
brush = GIMP_BRUSH (preview->viewable);
|
||||
brush_width = brush->mask->width;
|
||||
brush_height = brush->mask->height;
|
||||
|
||||
if (GIMP_IS_BRUSH_PIPE (brush) ||
|
||||
brush_width > preview->width ||
|
||||
brush_height > preview->height)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_brush_preview_render_timeout_func (GimpBrushPreview *brush_preview)
|
||||
{
|
||||
GimpPreview *preview;
|
||||
GimpBrushPipe *brush_pipe;
|
||||
GimpBrush *brush;
|
||||
TempBuf *temp_buf;
|
||||
gint brush_width;
|
||||
gint brush_height;
|
||||
|
||||
preview = GIMP_PREVIEW (brush_preview);
|
||||
|
||||
if (! preview->viewable)
|
||||
{
|
||||
brush_preview->pipe_timeout_id = 0;
|
||||
brush_preview->pipe_animation_index = 0;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
brush_pipe = GIMP_BRUSH_PIPE (preview->viewable);
|
||||
brush_width = brush->mask->width;
|
||||
brush_height = brush->mask->height;
|
||||
|
||||
brush_preview->pipe_animation_index++;
|
||||
|
||||
if (brush_preview->pipe_animation_index >= brush_pipe->nbrushes)
|
||||
brush_preview->pipe_animation_index = 0;
|
||||
|
||||
brush = GIMP_BRUSH (brush_pipe->brushes[brush_preview->pipe_animation_index]);
|
||||
|
||||
temp_buf = gimp_viewable_get_new_preview (GIMP_VIEWABLE (brush),
|
||||
preview->width,
|
||||
preview->height);
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
temp_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
|
||||
return TRUE;
|
||||
}
|
|
@ -1,64 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpBrushPreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_BRUSH_PREVIEW_H__
|
||||
#define __GIMP_BRUSH_PREVIEW_H__
|
||||
|
||||
|
||||
#include "gimppreview.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_BRUSH_PREVIEW (gimp_brush_preview_get_type ())
|
||||
#define GIMP_BRUSH_PREVIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_BRUSH_PREVIEW, GimpBrushPreview))
|
||||
#define GIMP_BRUSH_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH_PREVIEW, GimpBrushPreviewClass))
|
||||
#define GIMP_IS_BRUSH_PREVIEW(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_BRUSH_PREVIEW))
|
||||
#define GIMP_IS_BRUSH_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BRUSH_PREVIEW))
|
||||
|
||||
|
||||
typedef struct _GimpBrushPreviewClass GimpBrushPreviewClass;
|
||||
|
||||
struct _GimpBrushPreview
|
||||
{
|
||||
GimpPreview parent_instance;
|
||||
|
||||
guint pipe_timeout_id;
|
||||
gint pipe_animation_index;
|
||||
};
|
||||
|
||||
struct _GimpBrushPreviewClass
|
||||
{
|
||||
GimpPreviewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_brush_preview_get_type (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __GIMP_BRUSH_PREVIEW_H__ */
|
|
@ -1,214 +0,0 @@
|
|||
/* GTK - The GIMP Toolkit
|
||||
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
||||
*
|
||||
* GtkHWrapBox: Horizontal wrapping box widget
|
||||
* Copyright (C) 1999 Tim Janik
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library 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
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "gimpconstrainedhwrapbox.h"
|
||||
|
||||
|
||||
static void gimp_constrained_hwrap_box_class_init (GimpConstrainedHWrapBoxClass *klass);
|
||||
static void gimp_constrained_hwrap_box_init (GimpConstrainedHWrapBox *hwbox);
|
||||
static void gimp_constrained_hwrap_box_size_request (GtkWidget *widget,
|
||||
GtkRequisition *requisition);
|
||||
static void gimp_constrained_hwrap_box_size_allocate (GtkWidget *widget,
|
||||
GtkAllocation *allocation);
|
||||
|
||||
|
||||
static GtkHWrapBoxClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_constrained_hwrap_box_get_type (void)
|
||||
{
|
||||
static GtkType constrained_hwrap_box_type = 0;
|
||||
|
||||
if (! constrained_hwrap_box_type)
|
||||
{
|
||||
static const GtkTypeInfo constrained_hwrap_box_info =
|
||||
{
|
||||
"GimpConstrainedHWrapBox",
|
||||
sizeof (GimpConstrainedHWrapBox),
|
||||
sizeof (GimpConstrainedHWrapBoxClass),
|
||||
(GtkClassInitFunc) gimp_constrained_hwrap_box_class_init,
|
||||
(GtkObjectInitFunc) gimp_constrained_hwrap_box_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
constrained_hwrap_box_type = gtk_type_unique (GTK_TYPE_HWRAP_BOX,
|
||||
&constrained_hwrap_box_info);
|
||||
}
|
||||
|
||||
return constrained_hwrap_box_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_constrained_hwrap_box_class_init (GimpConstrainedHWrapBoxClass *class)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkWidgetClass *widget_class;
|
||||
|
||||
object_class = GTK_OBJECT_CLASS (class);
|
||||
widget_class = GTK_WIDGET_CLASS (class);
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_HWRAP_BOX);
|
||||
|
||||
widget_class->size_request = gimp_constrained_hwrap_box_size_request;
|
||||
widget_class->size_allocate = gimp_constrained_hwrap_box_size_allocate;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_constrained_hwrap_box_init (GimpConstrainedHWrapBox *hwbox)
|
||||
{
|
||||
hwbox->rows = 1;
|
||||
hwbox->columns = 1;
|
||||
}
|
||||
|
||||
GtkWidget*
|
||||
gimp_constrained_hwrap_box_new (gboolean homogeneous)
|
||||
{
|
||||
GimpConstrainedHWrapBox *hwbox;
|
||||
|
||||
hwbox = GIMP_CONSTRAINED_HWRAP_BOX (gtk_widget_new (GIMP_TYPE_CONSTRAINED_HWRAP_BOX, NULL));
|
||||
|
||||
GTK_WRAP_BOX (hwbox)->homogeneous = homogeneous ? TRUE : FALSE;
|
||||
|
||||
return GTK_WIDGET (hwbox);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_constrained_hwrap_box_size_request (GtkWidget *widget,
|
||||
GtkRequisition *requisition)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
|
||||
g_return_if_fail (requisition != NULL);
|
||||
|
||||
if (widget->parent &&
|
||||
GTK_IS_VIEWPORT (widget->parent) &&
|
||||
widget->parent->parent &&
|
||||
GTK_IS_SCROLLED_WINDOW (widget->parent->parent) &&
|
||||
wbox->children &&
|
||||
wbox->children->widget)
|
||||
{
|
||||
GtkWidget *scrolled_win;
|
||||
gint child_width;
|
||||
gint child_height;
|
||||
gint viewport_width;
|
||||
gint columns;
|
||||
gint rows;
|
||||
|
||||
scrolled_win = widget->parent->parent;
|
||||
|
||||
child_width = wbox->children->widget->requisition.width;
|
||||
child_height = wbox->children->widget->requisition.height;
|
||||
|
||||
viewport_width =
|
||||
(scrolled_win->allocation.width -
|
||||
GTK_SCROLLED_WINDOW (scrolled_win)->vscrollbar->allocation.width -
|
||||
GTK_SCROLLED_WINDOW_CLASS (GTK_OBJECT (scrolled_win)->klass)->scrollbar_spacing -
|
||||
scrolled_win->style->klass->xthickness * 2);
|
||||
|
||||
columns =
|
||||
(viewport_width + wbox->hspacing) / (child_width + wbox->hspacing);
|
||||
|
||||
columns = MAX (1, columns);
|
||||
|
||||
requisition->width = (child_width + wbox->hspacing) * columns;
|
||||
|
||||
rows = wbox->n_children / columns;
|
||||
|
||||
if (rows * columns < wbox->n_children)
|
||||
rows++;
|
||||
|
||||
requisition->height = (child_height + wbox->vspacing) * rows;
|
||||
|
||||
GIMP_CONSTRAINED_HWRAP_BOX (wbox)->columns = columns;
|
||||
GIMP_CONSTRAINED_HWRAP_BOX (wbox)->rows = rows;
|
||||
}
|
||||
else if (GTK_WIDGET_CLASS (parent_class)->size_request)
|
||||
{
|
||||
GTK_WIDGET_CLASS (parent_class)->size_request (widget, requisition);
|
||||
|
||||
GIMP_CONSTRAINED_HWRAP_BOX (wbox)->columns = 1;
|
||||
GIMP_CONSTRAINED_HWRAP_BOX (wbox)->rows = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_constrained_hwrap_box_size_allocate (GtkWidget *widget,
|
||||
GtkAllocation *allocation)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
|
||||
g_return_if_fail (allocation != NULL);
|
||||
|
||||
if (widget->parent &&
|
||||
GTK_IS_VIEWPORT (widget->parent) &&
|
||||
widget->parent->parent &&
|
||||
GTK_IS_SCROLLED_WINDOW (widget->parent->parent) &&
|
||||
wbox->children &&
|
||||
wbox->children->widget)
|
||||
{
|
||||
GtkWidget *scrolled_win;
|
||||
gint child_width;
|
||||
gint child_height;
|
||||
gint viewport_width;
|
||||
gint columns;
|
||||
gint rows;
|
||||
|
||||
scrolled_win = widget->parent->parent;
|
||||
|
||||
child_width = wbox->children->widget->requisition.width;
|
||||
child_height = wbox->children->widget->requisition.height;
|
||||
|
||||
viewport_width =
|
||||
(scrolled_win->allocation.width -
|
||||
GTK_SCROLLED_WINDOW (scrolled_win)->vscrollbar->allocation.width -
|
||||
GTK_SCROLLED_WINDOW_CLASS (GTK_OBJECT (scrolled_win)->klass)->scrollbar_spacing -
|
||||
scrolled_win->style->klass->xthickness * 2);
|
||||
|
||||
allocation->width = viewport_width;
|
||||
|
||||
columns =
|
||||
(viewport_width + wbox->hspacing) / (child_width + wbox->hspacing);
|
||||
|
||||
columns = MAX (1, columns);
|
||||
|
||||
rows = wbox->n_children / columns;
|
||||
|
||||
if (rows * columns < wbox->n_children)
|
||||
rows++;
|
||||
|
||||
GIMP_CONSTRAINED_HWRAP_BOX (wbox)->columns = columns;
|
||||
GIMP_CONSTRAINED_HWRAP_BOX (wbox)->rows = rows;
|
||||
}
|
||||
else
|
||||
{
|
||||
GIMP_CONSTRAINED_HWRAP_BOX (wbox)->columns = 1;
|
||||
GIMP_CONSTRAINED_HWRAP_BOX (wbox)->rows = 1;
|
||||
}
|
||||
|
||||
if (GTK_WIDGET_CLASS (parent_class)->size_allocate)
|
||||
GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
|
||||
}
|
|
@ -1,68 +0,0 @@
|
|||
/* GTK - The GIMP Toolkit
|
||||
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
||||
*
|
||||
* GtkHWrapBox: Horizontal wrapping box widget
|
||||
* Copyright (C) 1999 Tim Janik
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library 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
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_CONSTRAINED_HWRAP_BOX_H__
|
||||
#define __GIMP_CONSTRAINED_HWRAP_BOX_H__
|
||||
|
||||
|
||||
#include "gtkhwrapbox.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_CONSTRAINED_HWRAP_BOX (gimp_constrained_hwrap_box_get_type ())
|
||||
#define GIMP_CONSTRAINED_HWRAP_BOX(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_CONSTRAINED_HWRAP_BOX, GimpConstrainedHWrapBox))
|
||||
#define GIMP_CONSTRAINED_HWRAP_BOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CONSTRAINED_HWRAP_BOX, GimpConstrainedHWrapBoxClass))
|
||||
#define GIMP_IS_CONSTRAINED_HWRAP_BOX(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CONSTRAINED_HWRAP_BOX))
|
||||
#define GIMP_IS_CONSTRAINED_HWRAP_BOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONSTRAINED_HWRAP_BOX))
|
||||
#define GIMP_CONSTRAINED_HWRAP_BOX_GET_CLASS(obj) (GIMP_CONSTRAINED_HWRAP_BOX_CLASS (((GtkObject *) (obj))->klass))
|
||||
|
||||
|
||||
typedef struct _GimpConstrainedHWrapBox GimpConstrainedHWrapBox;
|
||||
typedef struct _GimpConstrainedHWrapBoxClass GimpConstrainedHWrapBoxClass;
|
||||
|
||||
struct _GimpConstrainedHWrapBox
|
||||
{
|
||||
GtkHWrapBox parent_instance;
|
||||
|
||||
gint rows;
|
||||
gint columns;
|
||||
};
|
||||
|
||||
struct _GimpConstrainedHWrapBoxClass
|
||||
{
|
||||
GtkHWrapBoxClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_constrained_hwrap_box_get_type (void);
|
||||
GtkWidget * gimp_constrained_hwrap_box_new (gboolean homogeneous);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __GTK_CONSTRAINED_HWRAP_BOX_H__ */
|
|
@ -1,408 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpcolor/gimpcolor.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "colormaps.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontainergridview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimpconstrainedhwrapbox.h"
|
||||
|
||||
|
||||
static void gimp_container_grid_view_class_init (GimpContainerGridViewClass *klass);
|
||||
static void gimp_container_grid_view_init (GimpContainerGridView *panel);
|
||||
static void gimp_container_grid_view_destroy (GtkObject *object);
|
||||
|
||||
static gpointer gimp_container_grid_view_insert_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint index);
|
||||
static void gimp_container_grid_view_remove_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data);
|
||||
static void gimp_container_grid_view_reorder_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint new_index,
|
||||
gpointer insert_data);
|
||||
static void gimp_container_grid_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data);
|
||||
static void gimp_container_grid_view_clear_items (GimpContainerView *view);
|
||||
static void gimp_container_grid_view_set_preview_size (GimpContainerView *view);
|
||||
static void gimp_container_grid_view_item_selected (GtkWidget *widget,
|
||||
gpointer data);
|
||||
static void gimp_container_grid_view_item_activated (GtkWidget *widget,
|
||||
gpointer data);
|
||||
static void gimp_container_grid_view_highlight_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data);
|
||||
|
||||
|
||||
static GimpContainerViewClass *parent_class = NULL;
|
||||
|
||||
static GimpRGB white_color;
|
||||
static GimpRGB black_color;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_container_grid_view_get_type (void)
|
||||
{
|
||||
static guint grid_view_type = 0;
|
||||
|
||||
if (! grid_view_type)
|
||||
{
|
||||
GtkTypeInfo grid_view_info =
|
||||
{
|
||||
"GimpContainerGridView",
|
||||
sizeof (GimpContainerGridView),
|
||||
sizeof (GimpContainerGridViewClass),
|
||||
(GtkClassInitFunc) gimp_container_grid_view_class_init,
|
||||
(GtkObjectInitFunc) gimp_container_grid_view_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
grid_view_type = gtk_type_unique (GIMP_TYPE_CONTAINER_VIEW,
|
||||
&grid_view_info);
|
||||
}
|
||||
|
||||
return grid_view_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_class_init (GimpContainerGridViewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpContainerViewClass *container_view_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
container_view_class = (GimpContainerViewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_CONTAINER_VIEW);
|
||||
|
||||
object_class->destroy = gimp_container_grid_view_destroy;
|
||||
|
||||
container_view_class->insert_item = gimp_container_grid_view_insert_item;
|
||||
container_view_class->remove_item = gimp_container_grid_view_remove_item;
|
||||
container_view_class->reorder_item = gimp_container_grid_view_reorder_item;
|
||||
container_view_class->select_item = gimp_container_grid_view_select_item;
|
||||
container_view_class->clear_items = gimp_container_grid_view_clear_items;
|
||||
container_view_class->set_preview_size = gimp_container_grid_view_set_preview_size;
|
||||
|
||||
klass->white_style = gtk_style_copy (gtk_widget_get_default_style ());
|
||||
klass->white_style->bg[GTK_STATE_NORMAL].red = 0xffff;
|
||||
klass->white_style->bg[GTK_STATE_NORMAL].green = 0xffff;
|
||||
klass->white_style->bg[GTK_STATE_NORMAL].blue = 0xffff;
|
||||
klass->white_style->bg[GTK_STATE_NORMAL].pixel = g_white_pixel;
|
||||
|
||||
gimp_rgba_set (&white_color, 1.0, 1.0, 1.0, 1.0);
|
||||
gimp_rgba_set (&black_color, 0.0, 0.0, 0.0, 1.0);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_init (GimpContainerGridView *grid_view)
|
||||
{
|
||||
grid_view->scrolled_win = gtk_scrolled_window_new (NULL, NULL);
|
||||
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (grid_view->scrolled_win),
|
||||
GTK_POLICY_NEVER,
|
||||
GTK_POLICY_ALWAYS);
|
||||
gtk_box_pack_start (GTK_BOX (grid_view), grid_view->scrolled_win,
|
||||
TRUE, TRUE, 0);
|
||||
|
||||
grid_view->wrap_box = gimp_constrained_hwrap_box_new (FALSE);
|
||||
|
||||
gtk_wrap_box_set_aspect_ratio (GTK_WRAP_BOX (grid_view->wrap_box),
|
||||
1.0 / 256.0);
|
||||
|
||||
gtk_scrolled_window_add_with_viewport
|
||||
(GTK_SCROLLED_WINDOW (grid_view->scrolled_win),
|
||||
grid_view->wrap_box);
|
||||
|
||||
gtk_widget_set_style
|
||||
(grid_view->wrap_box->parent,
|
||||
GIMP_CONTAINER_GRID_VIEW_CLASS (GTK_OBJECT (grid_view)->klass)->white_style);
|
||||
|
||||
gtk_container_set_focus_vadjustment
|
||||
(GTK_CONTAINER (grid_view->wrap_box->parent),
|
||||
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW
|
||||
(grid_view->scrolled_win)));
|
||||
|
||||
GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW
|
||||
(grid_view->scrolled_win)->vscrollbar,
|
||||
GTK_CAN_FOCUS);
|
||||
|
||||
GTK_WIDGET_SET_FLAGS (grid_view->wrap_box->parent, GTK_CAN_FOCUS);
|
||||
|
||||
gtk_widget_show (grid_view->wrap_box);
|
||||
gtk_widget_show (grid_view->scrolled_win);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_destroy (GtkObject *object)
|
||||
{
|
||||
GimpContainerGridView *grid_view;
|
||||
|
||||
grid_view = GIMP_CONTAINER_GRID_VIEW (object);
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_container_grid_view_new (GimpContainer *container,
|
||||
GimpContext *context,
|
||||
gint preview_size,
|
||||
gint min_items_x,
|
||||
gint min_items_y)
|
||||
{
|
||||
GimpContainerGridView *grid_view;
|
||||
GimpContainerView *view;
|
||||
gint window_border;
|
||||
|
||||
g_return_val_if_fail (! container || GIMP_IS_CONTAINER (container), NULL);
|
||||
g_return_val_if_fail (! context || GIMP_IS_CONTEXT (context), NULL);
|
||||
g_return_val_if_fail (preview_size > 0 && preview_size <= 64, NULL);
|
||||
g_return_val_if_fail (min_items_x > 0 && min_items_x <= 64, NULL);
|
||||
g_return_val_if_fail (min_items_y > 0 && min_items_y <= 64, NULL);
|
||||
|
||||
grid_view = gtk_type_new (GIMP_TYPE_CONTAINER_GRID_VIEW);
|
||||
|
||||
view = GIMP_CONTAINER_VIEW (grid_view);
|
||||
|
||||
view->preview_size = preview_size;
|
||||
|
||||
window_border =
|
||||
GTK_SCROLLED_WINDOW (grid_view->scrolled_win)->vscrollbar->requisition.width +
|
||||
GTK_SCROLLED_WINDOW_CLASS (GTK_OBJECT (grid_view->scrolled_win)->klass)->scrollbar_spacing +
|
||||
grid_view->scrolled_win->style->klass->xthickness * 4;
|
||||
|
||||
gtk_widget_set_usize (grid_view->scrolled_win,
|
||||
(preview_size + 2) * min_items_x + window_border,
|
||||
(preview_size + 2) * min_items_y + window_border);
|
||||
|
||||
if (container)
|
||||
gimp_container_view_set_container (view, container);
|
||||
|
||||
gimp_container_view_set_context (view, context);
|
||||
|
||||
return GTK_WIDGET (grid_view);
|
||||
}
|
||||
|
||||
static gpointer
|
||||
gimp_container_grid_view_insert_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint index)
|
||||
{
|
||||
GimpContainerGridView *grid_view;
|
||||
GtkWidget *preview;
|
||||
|
||||
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
||||
|
||||
preview = gimp_preview_new_full (viewable,
|
||||
view->preview_size,
|
||||
view->preview_size,
|
||||
1,
|
||||
FALSE, TRUE, TRUE);
|
||||
|
||||
GIMP_PREVIEW (preview)->border_color = white_color;
|
||||
|
||||
gtk_wrap_box_pack (GTK_WRAP_BOX (grid_view->wrap_box), preview,
|
||||
FALSE, FALSE, FALSE, FALSE);
|
||||
|
||||
if (index != -1)
|
||||
gtk_wrap_box_reorder_child (GTK_WRAP_BOX (grid_view->wrap_box),
|
||||
preview, index);
|
||||
|
||||
gtk_widget_show (preview);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (preview), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_container_grid_view_item_selected),
|
||||
view);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (preview), "double_clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_container_grid_view_item_activated),
|
||||
view);
|
||||
|
||||
return (gpointer) preview;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_remove_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data)
|
||||
{
|
||||
GimpContainerGridView *grid_view;
|
||||
GtkWidget *preview;
|
||||
|
||||
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
||||
preview = GTK_WIDGET (insert_data);
|
||||
|
||||
if (preview)
|
||||
{
|
||||
if (gtk_object_get_data (GTK_OBJECT (view),
|
||||
"last_selected_item") == preview)
|
||||
{
|
||||
gtk_object_set_data (GTK_OBJECT (view), "last_selected_item", NULL);
|
||||
}
|
||||
|
||||
gtk_container_remove (GTK_CONTAINER (grid_view->wrap_box), preview);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_reorder_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint new_index,
|
||||
gpointer insert_data)
|
||||
{
|
||||
GimpContainerGridView *grid_view;
|
||||
GtkWidget *preview;
|
||||
|
||||
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
||||
preview = GTK_WIDGET (insert_data);
|
||||
|
||||
gtk_wrap_box_reorder_child (GTK_WRAP_BOX (grid_view->wrap_box),
|
||||
preview, new_index);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data)
|
||||
{
|
||||
gimp_container_grid_view_highlight_item (view, viewable, insert_data);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_clear_items (GimpContainerView *view)
|
||||
{
|
||||
GimpContainerGridView *grid_view;
|
||||
|
||||
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
||||
|
||||
gtk_object_set_data (GTK_OBJECT (view), "last_selected_item", NULL);
|
||||
|
||||
while (GTK_WRAP_BOX (grid_view->wrap_box)->children)
|
||||
gtk_container_remove (GTK_CONTAINER (grid_view->wrap_box),
|
||||
GTK_WRAP_BOX (grid_view->wrap_box)->children->widget);
|
||||
|
||||
if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->clear_items)
|
||||
GIMP_CONTAINER_VIEW_CLASS (parent_class)->clear_items (view);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_set_preview_size (GimpContainerView *view)
|
||||
{
|
||||
GimpContainerGridView *grid_view;
|
||||
GtkWrapBoxChild *child;
|
||||
|
||||
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
||||
|
||||
for (child = GTK_WRAP_BOX (grid_view->wrap_box)->children;
|
||||
child;
|
||||
child = child->next)
|
||||
{
|
||||
GimpPreview *preview;
|
||||
|
||||
preview = GIMP_PREVIEW (child->widget);
|
||||
|
||||
gimp_preview_set_size (preview, view->preview_size, preview->border_width);
|
||||
}
|
||||
|
||||
gtk_widget_queue_resize (grid_view->wrap_box);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_item_selected (GtkWidget *widget,
|
||||
gpointer data)
|
||||
{
|
||||
gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (data),
|
||||
GIMP_PREVIEW (widget)->viewable);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_item_activated (GtkWidget *widget,
|
||||
gpointer data)
|
||||
{
|
||||
gimp_container_view_item_activated (GIMP_CONTAINER_VIEW (data),
|
||||
GIMP_PREVIEW (widget)->viewable);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_grid_view_highlight_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data)
|
||||
{
|
||||
GimpContainerGridView *grid_view;
|
||||
GimpPreview *preview;
|
||||
|
||||
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
||||
|
||||
preview = gtk_object_get_data (GTK_OBJECT (view), "last_selected_item");
|
||||
|
||||
if (preview)
|
||||
gimp_preview_set_border_color (preview, &white_color);
|
||||
|
||||
if (insert_data)
|
||||
preview = GIMP_PREVIEW (insert_data);
|
||||
else
|
||||
preview = NULL;
|
||||
|
||||
if (preview)
|
||||
{
|
||||
GtkAdjustment *adj;
|
||||
gint item_height;
|
||||
gint index;
|
||||
gint row;
|
||||
|
||||
adj = gtk_scrolled_window_get_vadjustment
|
||||
(GTK_SCROLLED_WINDOW (grid_view->scrolled_win));
|
||||
|
||||
item_height = GTK_WIDGET (preview)->allocation.height;
|
||||
|
||||
index = gimp_container_get_child_index (view->container,
|
||||
GIMP_OBJECT (viewable));
|
||||
|
||||
row = index / GIMP_CONSTRAINED_HWRAP_BOX (grid_view->wrap_box)->columns;
|
||||
|
||||
if (row * item_height < adj->value)
|
||||
{
|
||||
gtk_adjustment_set_value (adj, row * item_height);
|
||||
}
|
||||
else if ((row + 1) * item_height > adj->value + adj->page_size)
|
||||
{
|
||||
gtk_adjustment_set_value (adj,
|
||||
(row + 1) * item_height - adj->page_size);
|
||||
}
|
||||
|
||||
gimp_preview_set_border_color (preview, &black_color);
|
||||
}
|
||||
|
||||
gtk_object_set_data (GTK_OBJECT (view), "last_selected_item", preview);
|
||||
}
|
|
@ -1,59 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_CONTAINER_GRID_VIEW_H__
|
||||
#define __GIMP_CONTAINER_GRID_VIEW_H__
|
||||
|
||||
|
||||
#include "gimpcontainerview.h"
|
||||
|
||||
|
||||
#define GIMP_TYPE_CONTAINER_GRID_VIEW (gimp_container_grid_view_get_type ())
|
||||
#define GIMP_CONTAINER_GRID_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_CONTAINER_GRID_VIEW, GimpContainerGridView))
|
||||
#define GIMP_CONTAINER_GRID_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CONTAINER_GRID_VIEW, GimpContainerGridViewClass))
|
||||
#define GIMP_IS_CONTAINER_GRID_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CONTAINER_GRID_VIEW))
|
||||
#define GIMP_IS_CONTAINER_GRID_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONTAINER_GRID_VIEW))
|
||||
|
||||
|
||||
typedef struct _GimpContainerGridViewClass GimpContainerGridViewClass;
|
||||
|
||||
struct _GimpContainerGridView
|
||||
{
|
||||
GimpContainerView parent_instance;
|
||||
|
||||
GtkWidget *scrolled_win;
|
||||
GtkWidget *wrap_box;
|
||||
};
|
||||
|
||||
struct _GimpContainerGridViewClass
|
||||
{
|
||||
GimpContainerViewClass parent_class;
|
||||
|
||||
GtkStyle *white_style;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_container_grid_view_get_type (void);
|
||||
GtkWidget * gimp_container_grid_view_new (GimpContainer *container,
|
||||
GimpContext *context,
|
||||
gint preview_size,
|
||||
gint min_items_x,
|
||||
gint min_items_y);
|
||||
|
||||
|
||||
#endif /* __GIMP_CONTAINER_GRID_VIEW_H__ */
|
|
@ -1,424 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontainerlistview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimplist.h"
|
||||
#include "gimplistitem.h"
|
||||
#include "gimppreview.h"
|
||||
|
||||
|
||||
static void gimp_container_list_view_class_init (GimpContainerListViewClass *klass);
|
||||
static void gimp_container_list_view_init (GimpContainerListView *panel);
|
||||
static void gimp_container_list_view_destroy (GtkObject *object);
|
||||
|
||||
static gpointer gimp_container_list_view_insert_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint index);
|
||||
static void gimp_container_list_view_remove_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data);
|
||||
static void gimp_container_list_view_reorder_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint new_index,
|
||||
gpointer insert_data);
|
||||
static void gimp_container_list_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data);
|
||||
static void gimp_container_list_view_clear_items (GimpContainerView *view);
|
||||
static void gimp_container_list_view_set_preview_size (GimpContainerView *view);
|
||||
|
||||
static void gimp_container_list_view_item_selected (GtkWidget *widget,
|
||||
GtkWidget *child,
|
||||
gpointer data);
|
||||
static gint gimp_container_list_view_item_activated (GtkWidget *widget,
|
||||
GdkEventButton *bevent,
|
||||
gpointer data);
|
||||
|
||||
|
||||
static GimpContainerViewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_container_list_view_get_type (void)
|
||||
{
|
||||
static guint list_view_type = 0;
|
||||
|
||||
if (! list_view_type)
|
||||
{
|
||||
GtkTypeInfo list_view_info =
|
||||
{
|
||||
"GimpContainerListView",
|
||||
sizeof (GimpContainerListView),
|
||||
sizeof (GimpContainerListViewClass),
|
||||
(GtkClassInitFunc) gimp_container_list_view_class_init,
|
||||
(GtkObjectInitFunc) gimp_container_list_view_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
list_view_type = gtk_type_unique (GIMP_TYPE_CONTAINER_VIEW,
|
||||
&list_view_info);
|
||||
}
|
||||
|
||||
return list_view_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_list_view_class_init (GimpContainerListViewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpContainerViewClass *container_view_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
container_view_class = (GimpContainerViewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_CONTAINER_VIEW);
|
||||
|
||||
object_class->destroy = gimp_container_list_view_destroy;
|
||||
|
||||
container_view_class->insert_item = gimp_container_list_view_insert_item;
|
||||
container_view_class->remove_item = gimp_container_list_view_remove_item;
|
||||
container_view_class->reorder_item = gimp_container_list_view_reorder_item;
|
||||
container_view_class->select_item = gimp_container_list_view_select_item;
|
||||
container_view_class->clear_items = gimp_container_list_view_clear_items;
|
||||
container_view_class->set_preview_size = gimp_container_list_view_set_preview_size;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_list_view_init (GimpContainerListView *list_view)
|
||||
{
|
||||
list_view->scrolled_win = gtk_scrolled_window_new (NULL, NULL);
|
||||
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (list_view->scrolled_win),
|
||||
GTK_POLICY_AUTOMATIC,
|
||||
GTK_POLICY_ALWAYS);
|
||||
gtk_box_pack_start (GTK_BOX (list_view), list_view->scrolled_win,
|
||||
TRUE, TRUE, 0);
|
||||
|
||||
list_view->gtk_list = gtk_list_new ();
|
||||
gtk_scrolled_window_add_with_viewport
|
||||
(GTK_SCROLLED_WINDOW (list_view->scrolled_win),
|
||||
list_view->gtk_list);
|
||||
|
||||
gtk_list_set_selection_mode (GTK_LIST (list_view->gtk_list),
|
||||
GTK_SELECTION_SINGLE);
|
||||
|
||||
gtk_container_set_focus_vadjustment
|
||||
(GTK_CONTAINER (list_view->gtk_list),
|
||||
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW
|
||||
(list_view->scrolled_win)));
|
||||
|
||||
GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW
|
||||
(list_view->scrolled_win)->vscrollbar,
|
||||
GTK_CAN_FOCUS);
|
||||
|
||||
gtk_signal_connect_while_alive
|
||||
(GTK_OBJECT (list_view->gtk_list), "select_child",
|
||||
GTK_SIGNAL_FUNC (gimp_container_list_view_item_selected),
|
||||
list_view,
|
||||
GTK_OBJECT (list_view));
|
||||
|
||||
gtk_widget_show (list_view->gtk_list);
|
||||
gtk_widget_show (list_view->scrolled_win);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_list_view_destroy (GtkObject *object)
|
||||
{
|
||||
GimpContainerListView *list_view;
|
||||
|
||||
list_view = GIMP_CONTAINER_LIST_VIEW (object);
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_container_list_view_new (GimpContainer *container,
|
||||
GimpContext *context,
|
||||
gint preview_size,
|
||||
gint min_items_x,
|
||||
gint min_items_y)
|
||||
{
|
||||
GimpContainerListView *list_view;
|
||||
GimpContainerView *view;
|
||||
gint window_border;
|
||||
|
||||
g_return_val_if_fail (! container || GIMP_IS_CONTAINER (container), NULL);
|
||||
g_return_val_if_fail (! context || GIMP_IS_CONTEXT (context), NULL);
|
||||
g_return_val_if_fail (preview_size > 0 && preview_size <= 64, NULL);
|
||||
g_return_val_if_fail (min_items_x > 0 && min_items_x <= 64, NULL);
|
||||
g_return_val_if_fail (min_items_y > 0 && min_items_y <= 64, NULL);
|
||||
|
||||
list_view = gtk_type_new (GIMP_TYPE_CONTAINER_LIST_VIEW);
|
||||
|
||||
view = GIMP_CONTAINER_VIEW (list_view);
|
||||
|
||||
view->preview_size = preview_size;
|
||||
|
||||
window_border =
|
||||
GTK_SCROLLED_WINDOW (list_view->scrolled_win)->vscrollbar->requisition.width +
|
||||
GTK_SCROLLED_WINDOW_CLASS (GTK_OBJECT (list_view->scrolled_win)->klass)->scrollbar_spacing +
|
||||
list_view->scrolled_win->style->klass->xthickness * 4;
|
||||
|
||||
gtk_widget_set_usize (list_view->gtk_list->parent,
|
||||
(preview_size + 2) * min_items_x + window_border,
|
||||
(preview_size + 6) * min_items_y + window_border);
|
||||
|
||||
if (container)
|
||||
gimp_container_view_set_container (view, container);
|
||||
|
||||
gimp_container_view_set_context (view, context);
|
||||
|
||||
return GTK_WIDGET (list_view);
|
||||
}
|
||||
|
||||
|
||||
/* GimpContainerView methods */
|
||||
|
||||
static gpointer
|
||||
gimp_container_list_view_insert_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint index)
|
||||
{
|
||||
GimpContainerListView *list_view;
|
||||
GtkWidget *list_item;
|
||||
GList *list;
|
||||
|
||||
list_view = GIMP_CONTAINER_LIST_VIEW (view);
|
||||
|
||||
list_item = gimp_list_item_new (viewable, view->preview_size);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (list_item), "button_press_event",
|
||||
GTK_SIGNAL_FUNC (gimp_container_list_view_item_activated),
|
||||
list_view);
|
||||
|
||||
gtk_widget_show (list_item);
|
||||
|
||||
list = g_list_prepend (NULL, list_item);
|
||||
|
||||
if (index == -1)
|
||||
gtk_list_append_items (GTK_LIST (list_view->gtk_list), list);
|
||||
else
|
||||
gtk_list_insert_items (GTK_LIST (list_view->gtk_list), list, index);
|
||||
|
||||
return (gpointer) list_item;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_list_view_remove_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data)
|
||||
{
|
||||
GimpContainerListView *list_view;
|
||||
GtkWidget *list_item;
|
||||
|
||||
list_view = GIMP_CONTAINER_LIST_VIEW (view);
|
||||
|
||||
if (insert_data)
|
||||
list_item = GTK_WIDGET (insert_data);
|
||||
else
|
||||
list_item = NULL;
|
||||
|
||||
if (list_item)
|
||||
{
|
||||
GList *list;
|
||||
|
||||
list = g_list_prepend (NULL, list_item);
|
||||
|
||||
gtk_list_remove_items (GTK_LIST (list_view->gtk_list), list);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_list_view_reorder_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint new_index,
|
||||
gpointer insert_data)
|
||||
{
|
||||
GimpContainerListView *list_view;
|
||||
GtkWidget *list_item;
|
||||
gboolean selected;
|
||||
|
||||
list_view = GIMP_CONTAINER_LIST_VIEW (view);
|
||||
|
||||
if (insert_data)
|
||||
list_item = GTK_WIDGET (insert_data);
|
||||
else
|
||||
list_item = NULL;
|
||||
|
||||
if (list_item)
|
||||
{
|
||||
GList *list;
|
||||
|
||||
list = g_list_prepend (NULL, list_item);
|
||||
|
||||
selected = GTK_WIDGET_STATE (list_item) == GTK_STATE_SELECTED;
|
||||
|
||||
gtk_object_ref (GTK_OBJECT (list_item));
|
||||
|
||||
gtk_list_remove_items (GTK_LIST (list_view->gtk_list), list);
|
||||
|
||||
if (new_index == -1 || new_index == view->container->num_children - 1)
|
||||
gtk_list_append_items (GTK_LIST (list_view->gtk_list), list);
|
||||
else
|
||||
gtk_list_insert_items (GTK_LIST (list_view->gtk_list), list, new_index);
|
||||
|
||||
if (selected)
|
||||
gimp_container_view_select_item (view, viewable);
|
||||
|
||||
gtk_object_unref (GTK_OBJECT (list_item));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_list_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gpointer insert_data)
|
||||
{
|
||||
GimpContainerListView *list_view;
|
||||
GtkWidget *list_item;
|
||||
|
||||
list_view = GIMP_CONTAINER_LIST_VIEW (view);
|
||||
|
||||
if (insert_data)
|
||||
list_item = GTK_WIDGET (insert_data);
|
||||
else
|
||||
list_item = NULL;
|
||||
|
||||
if (list_item)
|
||||
{
|
||||
GtkAdjustment *adj;
|
||||
gint item_height;
|
||||
gint index;
|
||||
|
||||
adj = gtk_scrolled_window_get_vadjustment
|
||||
(GTK_SCROLLED_WINDOW (list_view->scrolled_win));
|
||||
|
||||
item_height = list_item->requisition.height;
|
||||
|
||||
index = gimp_container_get_child_index (view->container,
|
||||
GIMP_OBJECT (viewable));
|
||||
|
||||
gtk_signal_handler_block_by_func (GTK_OBJECT (list_view->gtk_list),
|
||||
gimp_container_list_view_item_selected,
|
||||
list_view);
|
||||
|
||||
gtk_list_select_child (GTK_LIST (list_view->gtk_list), list_item);
|
||||
|
||||
gtk_signal_handler_unblock_by_func (GTK_OBJECT (list_view->gtk_list),
|
||||
gimp_container_list_view_item_selected,
|
||||
list_view);
|
||||
|
||||
if (index * item_height < adj->value)
|
||||
{
|
||||
gtk_adjustment_set_value (adj, index * item_height);
|
||||
}
|
||||
else if ((index + 1) * item_height > adj->value + adj->page_size)
|
||||
{
|
||||
gtk_adjustment_set_value (adj,
|
||||
(index + 1) * item_height - adj->page_size);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
gtk_list_unselect_all (GTK_LIST (list_view->gtk_list));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_list_view_clear_items (GimpContainerView *view)
|
||||
{
|
||||
GimpContainerListView *list_view;
|
||||
|
||||
list_view = GIMP_CONTAINER_LIST_VIEW (view);
|
||||
|
||||
gtk_list_clear_items (GTK_LIST (list_view->gtk_list), 0, -1);
|
||||
|
||||
if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->clear_items)
|
||||
GIMP_CONTAINER_VIEW_CLASS (parent_class)->clear_items (view);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_list_view_set_preview_size (GimpContainerView *view)
|
||||
{
|
||||
GimpContainerListView *list_view;
|
||||
GList *list;
|
||||
|
||||
list_view = GIMP_CONTAINER_LIST_VIEW (view);
|
||||
|
||||
for (list = GTK_LIST (list_view->gtk_list)->children;
|
||||
list;
|
||||
list = g_list_next (list))
|
||||
{
|
||||
GimpPreview *preview;
|
||||
|
||||
preview = GIMP_PREVIEW (GIMP_LIST_ITEM (list->data)->preview);
|
||||
|
||||
gimp_preview_set_size (preview, view->preview_size, preview->border_width);
|
||||
}
|
||||
|
||||
gtk_widget_queue_resize (list_view->gtk_list);
|
||||
}
|
||||
|
||||
|
||||
/* GtkClist callbacks */
|
||||
|
||||
static void
|
||||
gimp_container_list_view_item_selected (GtkWidget *widget,
|
||||
GtkWidget *child,
|
||||
gpointer data)
|
||||
{
|
||||
GimpViewable *viewable;
|
||||
|
||||
viewable = GIMP_PREVIEW (GIMP_LIST_ITEM (child)->preview)->viewable;
|
||||
|
||||
gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (data), viewable);
|
||||
}
|
||||
|
||||
|
||||
/* GtkListItem callbacks */
|
||||
|
||||
static gint
|
||||
gimp_container_list_view_item_activated (GtkWidget *widget,
|
||||
GdkEventButton *bevent,
|
||||
gpointer data)
|
||||
{
|
||||
if (bevent->type == GDK_2BUTTON_PRESS)
|
||||
{
|
||||
GimpViewable *viewable;
|
||||
|
||||
viewable = GIMP_PREVIEW (GIMP_LIST_ITEM (widget)->preview)->viewable;
|
||||
|
||||
gimp_container_view_item_activated (GIMP_CONTAINER_VIEW (data), viewable);
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
|
@ -1,57 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_CONTAINER_LIST_VIEW_H__
|
||||
#define __GIMP_CONTAINER_LIST_VIEW_H__
|
||||
|
||||
|
||||
#include "gimpcontainerview.h"
|
||||
|
||||
|
||||
#define GIMP_TYPE_CONTAINER_LIST_VIEW (gimp_container_list_view_get_type ())
|
||||
#define GIMP_CONTAINER_LIST_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_CONTAINER_LIST_VIEW, GimpContainerListView))
|
||||
#define GIMP_CONTAINER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CONTAINER_LIST_VIEW, GimpContainerListViewClass))
|
||||
#define GIMP_IS_CONTAINER_LIST_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CONTAINER_LIST_VIEW))
|
||||
#define GIMP_IS_CONTAINER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONTAINER_LIST_VIEW))
|
||||
|
||||
|
||||
typedef struct _GimpContainerListViewClass GimpContainerListViewClass;
|
||||
|
||||
struct _GimpContainerListView
|
||||
{
|
||||
GimpContainerView parent_instance;
|
||||
|
||||
GtkWidget *scrolled_win;
|
||||
GtkWidget *gtk_list;
|
||||
};
|
||||
|
||||
struct _GimpContainerListViewClass
|
||||
{
|
||||
GimpContainerViewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_container_list_view_get_type (void);
|
||||
GtkWidget * gimp_container_list_view_new (GimpContainer *container,
|
||||
GimpContext *context,
|
||||
gint preview_size,
|
||||
gint min_items_x,
|
||||
gint min_items_y);
|
||||
|
||||
|
||||
#endif /* __GIMP_CONTAINER_LIST_VIEW_H__ */
|
|
@ -1,580 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontainerview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimpmarshal.h"
|
||||
#include "gimpviewable.h"
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
SET_CONTAINER,
|
||||
INSERT_ITEM,
|
||||
REMOVE_ITEM,
|
||||
REORDER_ITEM,
|
||||
SELECT_ITEM,
|
||||
ACTIVATE_ITEM,
|
||||
CLEAR_ITEMS,
|
||||
SET_PREVIEW_SIZE,
|
||||
LAST_SIGNAL
|
||||
};
|
||||
|
||||
|
||||
static void gimp_container_view_class_init (GimpContainerViewClass *klass);
|
||||
static void gimp_container_view_init (GimpContainerView *panel);
|
||||
static void gimp_container_view_destroy (GtkObject *object);
|
||||
|
||||
static void gimp_container_view_real_set_container (GimpContainerView *view,
|
||||
GimpContainer *container);
|
||||
|
||||
static void gimp_container_view_clear_items (GimpContainerView *view);
|
||||
static void gimp_container_view_real_clear_items (GimpContainerView *view);
|
||||
|
||||
static void gimp_container_view_add_foreach (GimpViewable *viewable,
|
||||
GimpContainerView *view);
|
||||
static void gimp_container_view_add (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
GimpContainer *container);
|
||||
static void gimp_container_view_remove (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
GimpContainer *container);
|
||||
static void gimp_container_view_reorder (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint new_index,
|
||||
GimpContainer *container);
|
||||
|
||||
static void gimp_container_view_context_changed (GimpContext *context,
|
||||
GimpViewable *viewable,
|
||||
GimpContainerView *view);
|
||||
static void gimp_container_view_drop_viewable_callback (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data);
|
||||
|
||||
|
||||
static guint view_signals[LAST_SIGNAL] = { 0 };
|
||||
|
||||
static GtkVBoxClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_container_view_get_type (void)
|
||||
{
|
||||
static guint view_type = 0;
|
||||
|
||||
if (! view_type)
|
||||
{
|
||||
GtkTypeInfo view_info =
|
||||
{
|
||||
"GimpContainerView",
|
||||
sizeof (GimpContainerView),
|
||||
sizeof (GimpContainerViewClass),
|
||||
(GtkClassInitFunc) gimp_container_view_class_init,
|
||||
(GtkObjectInitFunc) gimp_container_view_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
view_type = gtk_type_unique (GTK_TYPE_VBOX, &view_info);
|
||||
}
|
||||
|
||||
return view_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_class_init (GimpContainerViewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_VBOX);
|
||||
|
||||
view_signals[SET_CONTAINER] =
|
||||
gtk_signal_new ("set_container",
|
||||
GTK_RUN_LAST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (GimpContainerViewClass,
|
||||
set_container),
|
||||
gtk_marshal_NONE__OBJECT,
|
||||
GTK_TYPE_NONE, 1,
|
||||
GIMP_TYPE_OBJECT);
|
||||
|
||||
view_signals[INSERT_ITEM] =
|
||||
gtk_signal_new ("insert_item",
|
||||
GTK_RUN_LAST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (GimpContainerViewClass,
|
||||
insert_item),
|
||||
gimp_marshal_POINTER__POINTER_INT,
|
||||
GTK_TYPE_POINTER, 2,
|
||||
GIMP_TYPE_OBJECT,
|
||||
GTK_TYPE_INT);
|
||||
|
||||
view_signals[REMOVE_ITEM] =
|
||||
gtk_signal_new ("remove_item",
|
||||
GTK_RUN_FIRST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (GimpContainerViewClass,
|
||||
remove_item),
|
||||
gtk_marshal_NONE__POINTER_POINTER,
|
||||
GTK_TYPE_NONE, 2,
|
||||
GIMP_TYPE_OBJECT,
|
||||
GTK_TYPE_POINTER);
|
||||
|
||||
view_signals[REORDER_ITEM] =
|
||||
gtk_signal_new ("reorder_item",
|
||||
GTK_RUN_FIRST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (GimpContainerViewClass,
|
||||
reorder_item),
|
||||
gtk_marshal_NONE__POINTER_INT_POINTER,
|
||||
GTK_TYPE_NONE, 3,
|
||||
GIMP_TYPE_OBJECT,
|
||||
GTK_TYPE_INT,
|
||||
GTK_TYPE_POINTER);
|
||||
|
||||
view_signals[SELECT_ITEM] =
|
||||
gtk_signal_new ("select_item",
|
||||
GTK_RUN_FIRST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (GimpContainerViewClass,
|
||||
select_item),
|
||||
gtk_marshal_NONE__POINTER_POINTER,
|
||||
GTK_TYPE_NONE, 2,
|
||||
GIMP_TYPE_OBJECT,
|
||||
GTK_TYPE_POINTER);
|
||||
|
||||
view_signals[ACTIVATE_ITEM] =
|
||||
gtk_signal_new ("activate_item",
|
||||
GTK_RUN_FIRST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (GimpContainerViewClass,
|
||||
activate_item),
|
||||
gtk_marshal_NONE__POINTER_POINTER,
|
||||
GTK_TYPE_NONE, 2,
|
||||
GIMP_TYPE_OBJECT,
|
||||
GTK_TYPE_POINTER);
|
||||
|
||||
view_signals[CLEAR_ITEMS] =
|
||||
gtk_signal_new ("clear_items",
|
||||
GTK_RUN_FIRST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (GimpContainerViewClass,
|
||||
clear_items),
|
||||
gtk_signal_default_marshaller,
|
||||
GTK_TYPE_NONE, 0);
|
||||
|
||||
view_signals[SET_PREVIEW_SIZE] =
|
||||
gtk_signal_new ("set_preview_size",
|
||||
GTK_RUN_FIRST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (GimpContainerViewClass,
|
||||
set_preview_size),
|
||||
gtk_signal_default_marshaller,
|
||||
GTK_TYPE_NONE, 0);
|
||||
|
||||
gtk_object_class_add_signals (object_class, view_signals, LAST_SIGNAL);
|
||||
|
||||
object_class->destroy = gimp_container_view_destroy;
|
||||
|
||||
klass->set_container = gimp_container_view_real_set_container;
|
||||
klass->insert_item = NULL;
|
||||
klass->remove_item = NULL;
|
||||
klass->reorder_item = NULL;
|
||||
klass->select_item = NULL;
|
||||
klass->activate_item = NULL;
|
||||
klass->clear_items = gimp_container_view_real_clear_items;
|
||||
klass->set_preview_size = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_init (GimpContainerView *view)
|
||||
{
|
||||
view->container = NULL;
|
||||
view->context = NULL;
|
||||
|
||||
view->hash_table = g_hash_table_new (g_direct_hash, g_direct_equal);
|
||||
|
||||
view->preview_size = 0;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_destroy (GtkObject *object)
|
||||
{
|
||||
GimpContainerView *view;
|
||||
|
||||
view = GIMP_CONTAINER_VIEW (object);
|
||||
|
||||
gimp_container_view_set_container (view, NULL);
|
||||
|
||||
gimp_container_view_set_context (view, NULL);
|
||||
|
||||
g_hash_table_destroy (view->hash_table);
|
||||
|
||||
view->hash_table = NULL;
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_container_view_set_container (GimpContainerView *view,
|
||||
GimpContainer *container)
|
||||
{
|
||||
g_return_if_fail (view != NULL);
|
||||
g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view));
|
||||
g_return_if_fail (!container || GIMP_IS_CONTAINER (container));
|
||||
|
||||
if (container == view->container)
|
||||
return;
|
||||
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[SET_CONTAINER],
|
||||
container);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_real_set_container (GimpContainerView *view,
|
||||
GimpContainer *container)
|
||||
{
|
||||
if (view->container)
|
||||
{
|
||||
gimp_container_view_select_item (view, NULL);
|
||||
|
||||
gimp_container_view_clear_items (view);
|
||||
|
||||
gtk_signal_disconnect_by_func (GTK_OBJECT (view->container),
|
||||
gimp_container_view_add,
|
||||
view);
|
||||
gtk_signal_disconnect_by_func (GTK_OBJECT (view->container),
|
||||
gimp_container_view_remove,
|
||||
view);
|
||||
gtk_signal_disconnect_by_func (GTK_OBJECT (view->container),
|
||||
gimp_container_view_reorder,
|
||||
view);
|
||||
|
||||
g_hash_table_destroy (view->hash_table);
|
||||
|
||||
view->hash_table = g_hash_table_new (g_direct_hash, g_direct_equal);
|
||||
|
||||
if (view->context)
|
||||
{
|
||||
gtk_signal_disconnect_by_func (GTK_OBJECT (view->context),
|
||||
gimp_container_view_context_changed,
|
||||
view);
|
||||
|
||||
gtk_drag_dest_unset (GTK_WIDGET (view));
|
||||
gimp_dnd_viewable_dest_unset (GTK_WIDGET (view),
|
||||
view->container->children_type);
|
||||
}
|
||||
}
|
||||
|
||||
view->container = container;
|
||||
|
||||
if (view->container)
|
||||
{
|
||||
gimp_container_foreach (view->container,
|
||||
(GFunc) gimp_container_view_add_foreach,
|
||||
view);
|
||||
|
||||
gtk_signal_connect_object (GTK_OBJECT (view->container), "add",
|
||||
GTK_SIGNAL_FUNC (gimp_container_view_add),
|
||||
GTK_OBJECT (view));
|
||||
|
||||
gtk_signal_connect_object (GTK_OBJECT (view->container), "remove",
|
||||
GTK_SIGNAL_FUNC (gimp_container_view_remove),
|
||||
GTK_OBJECT (view));
|
||||
|
||||
gtk_signal_connect_object (GTK_OBJECT (view->container), "reorder",
|
||||
GTK_SIGNAL_FUNC (gimp_container_view_reorder),
|
||||
GTK_OBJECT (view));
|
||||
|
||||
if (view->context)
|
||||
{
|
||||
GimpObject *object;
|
||||
const gchar *signal_name;
|
||||
|
||||
signal_name =
|
||||
gimp_context_type_to_signal_name (view->container->children_type);
|
||||
|
||||
gtk_signal_connect
|
||||
(GTK_OBJECT (view->context), signal_name,
|
||||
GTK_SIGNAL_FUNC (gimp_container_view_context_changed),
|
||||
view);
|
||||
|
||||
object = gimp_context_get_by_type (view->context,
|
||||
view->container->children_type);
|
||||
|
||||
gimp_container_view_select_item (view,
|
||||
object ? GIMP_VIEWABLE (object): NULL);
|
||||
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
view->container->children_type,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (view),
|
||||
view->container->children_type,
|
||||
gimp_container_view_drop_viewable_callback,
|
||||
NULL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gimp_container_view_set_context (GimpContainerView *view,
|
||||
GimpContext *context)
|
||||
{
|
||||
g_return_if_fail (view != NULL);
|
||||
g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view));
|
||||
g_return_if_fail (! context || GIMP_IS_CONTEXT (context));
|
||||
|
||||
if (context == view->context)
|
||||
return;
|
||||
|
||||
if (view->context && view->container)
|
||||
{
|
||||
gtk_signal_disconnect_by_func (GTK_OBJECT (view->context),
|
||||
gimp_container_view_context_changed,
|
||||
view);
|
||||
|
||||
gtk_drag_dest_unset (GTK_WIDGET (view));
|
||||
gimp_dnd_viewable_dest_unset (GTK_WIDGET (view),
|
||||
view->container->children_type);
|
||||
}
|
||||
|
||||
view->context = context;
|
||||
|
||||
if (view->context && view->container)
|
||||
{
|
||||
GimpObject *object;
|
||||
const gchar *signal_name;
|
||||
|
||||
signal_name =
|
||||
gimp_context_type_to_signal_name (view->container->children_type);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->context), signal_name,
|
||||
GTK_SIGNAL_FUNC (gimp_container_view_context_changed),
|
||||
view);
|
||||
|
||||
object = gimp_context_get_by_type (view->context,
|
||||
view->container->children_type);
|
||||
|
||||
gimp_container_view_select_item (view,
|
||||
object ? GIMP_VIEWABLE (object) : NULL);
|
||||
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
view->container->children_type,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (view),
|
||||
view->container->children_type,
|
||||
gimp_container_view_drop_viewable_callback,
|
||||
NULL);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gimp_container_view_set_preview_size (GimpContainerView *view,
|
||||
gint preview_size)
|
||||
{
|
||||
g_return_if_fail (view != NULL);
|
||||
g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view));
|
||||
g_return_if_fail (preview_size > 0 && preview_size <= 256 /* FIXME: 64 */);
|
||||
|
||||
view->preview_size = preview_size;
|
||||
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[SET_PREVIEW_SIZE]);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_container_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *viewable)
|
||||
{
|
||||
gpointer insert_data;
|
||||
|
||||
g_return_if_fail (view != NULL);
|
||||
g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view));
|
||||
g_return_if_fail (! viewable || GIMP_IS_VIEWABLE (viewable));
|
||||
|
||||
insert_data = g_hash_table_lookup (view->hash_table, viewable);
|
||||
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[SELECT_ITEM],
|
||||
viewable, insert_data);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_container_view_activate_item (GimpContainerView *view,
|
||||
GimpViewable *viewable)
|
||||
{
|
||||
gpointer insert_data;
|
||||
|
||||
g_return_if_fail (view != NULL);
|
||||
g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view));
|
||||
g_return_if_fail (viewable != NULL);
|
||||
g_return_if_fail (GIMP_IS_VIEWABLE (viewable));
|
||||
|
||||
insert_data = g_hash_table_lookup (view->hash_table, viewable);
|
||||
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[ACTIVATE_ITEM],
|
||||
viewable, insert_data);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_container_view_item_selected (GimpContainerView *view,
|
||||
GimpViewable *viewable)
|
||||
{
|
||||
g_return_if_fail (view != NULL);
|
||||
g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view));
|
||||
g_return_if_fail (viewable != NULL);
|
||||
g_return_if_fail (GIMP_IS_VIEWABLE (viewable));
|
||||
|
||||
if (view->container && view->context)
|
||||
{
|
||||
gimp_context_set_by_type (view->context,
|
||||
view->container->children_type,
|
||||
GIMP_OBJECT (viewable));
|
||||
}
|
||||
|
||||
gimp_container_view_select_item (view, viewable);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_container_view_item_activated (GimpContainerView *view,
|
||||
GimpViewable *viewable)
|
||||
{
|
||||
g_return_if_fail (view != NULL);
|
||||
g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view));
|
||||
g_return_if_fail (viewable != NULL);
|
||||
g_return_if_fail (GIMP_IS_VIEWABLE (viewable));
|
||||
|
||||
gimp_container_view_activate_item (view, viewable);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_clear_items (GimpContainerView *view)
|
||||
{
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[CLEAR_ITEMS]);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_real_clear_items (GimpContainerView *view)
|
||||
{
|
||||
g_hash_table_destroy (view->hash_table);
|
||||
|
||||
view->hash_table = g_hash_table_new (g_direct_hash, g_direct_equal);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_add_foreach (GimpViewable *viewable,
|
||||
GimpContainerView *view)
|
||||
{
|
||||
gpointer insert_data = NULL;
|
||||
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[INSERT_ITEM],
|
||||
viewable, -1, &insert_data);
|
||||
|
||||
g_hash_table_insert (view->hash_table, viewable, insert_data);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_add (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
GimpContainer *container)
|
||||
{
|
||||
gpointer insert_data = NULL;
|
||||
gint index;
|
||||
|
||||
index = gimp_container_get_child_index (container,
|
||||
GIMP_OBJECT (viewable));
|
||||
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[INSERT_ITEM],
|
||||
viewable, index, &insert_data);
|
||||
|
||||
g_hash_table_insert (view->hash_table, viewable, insert_data);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_remove (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
GimpContainer *container)
|
||||
{
|
||||
gpointer insert_data;
|
||||
|
||||
insert_data = g_hash_table_lookup (view->hash_table, viewable);
|
||||
|
||||
if (insert_data)
|
||||
{
|
||||
g_hash_table_remove (view->hash_table, viewable);
|
||||
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[REMOVE_ITEM],
|
||||
viewable, insert_data);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_reorder (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint new_index,
|
||||
GimpContainer *container)
|
||||
{
|
||||
gpointer insert_data;
|
||||
|
||||
insert_data = g_hash_table_lookup (view->hash_table, viewable);
|
||||
|
||||
if (insert_data)
|
||||
{
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[REORDER_ITEM],
|
||||
viewable, new_index, insert_data);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_context_changed (GimpContext *context,
|
||||
GimpViewable *viewable,
|
||||
GimpContainerView *view)
|
||||
{
|
||||
gpointer insert_data;
|
||||
|
||||
insert_data = g_hash_table_lookup (view->hash_table, viewable);
|
||||
|
||||
gtk_signal_emit (GTK_OBJECT (view), view_signals[SELECT_ITEM],
|
||||
viewable, insert_data);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_container_view_drop_viewable_callback (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpContainerView *view;
|
||||
|
||||
view = GIMP_CONTAINER_VIEW (widget);
|
||||
|
||||
gimp_context_set_by_type (view->context,
|
||||
view->container->children_type,
|
||||
GIMP_OBJECT (viewable));
|
||||
}
|
|
@ -1,96 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_CONTAINER_VIEW_H__
|
||||
#define __GIMP_CONTAINER_VIEW_H__
|
||||
|
||||
|
||||
#include <gtk/gtkvbox.h>
|
||||
|
||||
|
||||
#define GIMP_TYPE_CONTAINER_VIEW (gimp_container_view_get_type ())
|
||||
#define GIMP_CONTAINER_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_CONTAINER_VIEW, GimpContainerView))
|
||||
#define GIMP_CONTAINER_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CONTAINER_VIEW, GimpContainerViewClass))
|
||||
#define GIMP_IS_CONTAINER_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CONTAINER_VIEW))
|
||||
#define GIMP_IS_CONTAINER_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONTAINER_VIEW))
|
||||
|
||||
|
||||
typedef struct _GimpContainerViewClass GimpContainerViewClass;
|
||||
|
||||
struct _GimpContainerView
|
||||
{
|
||||
GtkVBox parent_instance;
|
||||
|
||||
GimpContainer *container;
|
||||
GimpContext *context;
|
||||
|
||||
GHashTable *hash_table;
|
||||
|
||||
gint preview_size;
|
||||
};
|
||||
|
||||
struct _GimpContainerViewClass
|
||||
{
|
||||
GtkVBoxClass parent_class;
|
||||
|
||||
void (* set_container) (GimpContainerView *view,
|
||||
GimpContainer *container);
|
||||
gpointer (* insert_item) (GimpContainerView *view,
|
||||
GimpViewable *object,
|
||||
gint index);
|
||||
void (* remove_item) (GimpContainerView *view,
|
||||
GimpViewable *object,
|
||||
gpointer insert_data);
|
||||
void (* reorder_item) (GimpContainerView *view,
|
||||
GimpViewable *object,
|
||||
gint new_index,
|
||||
gpointer insert_data);
|
||||
void (* select_item) (GimpContainerView *view,
|
||||
GimpViewable *object,
|
||||
gpointer insert_data);
|
||||
void (* activate_item) (GimpContainerView *view,
|
||||
GimpViewable *object,
|
||||
gpointer insert_data);
|
||||
void (* clear_items) (GimpContainerView *view);
|
||||
void (* set_preview_size) (GimpContainerView *view);
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_container_view_get_type (void);
|
||||
|
||||
void gimp_container_view_set_container (GimpContainerView *view,
|
||||
GimpContainer *container);
|
||||
void gimp_container_view_set_context (GimpContainerView *view,
|
||||
GimpContext *context);
|
||||
void gimp_container_view_set_preview_size (GimpContainerView *view,
|
||||
gint preview_size);
|
||||
void gimp_container_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *viewable);
|
||||
void gimp_container_view_activate_item (GimpContainerView *view,
|
||||
GimpViewable *viewable);
|
||||
|
||||
|
||||
/* private */
|
||||
|
||||
void gimp_container_view_item_selected (GimpContainerView *view,
|
||||
GimpViewable *item);
|
||||
void gimp_container_view_item_activated (GimpContainerView *view,
|
||||
GimpViewable *item);
|
||||
|
||||
|
||||
#endif /* __GIMP_CONTAINER_VIEW_H__ */
|
|
@ -1,623 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpmath/gimpmath.h"
|
||||
#include "libgimpwidgets/gimpwidgets.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontainerview.h"
|
||||
#include "gimpdata.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpcontainergridview.h"
|
||||
#include "gimpcontainerlistview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimpmarshal.h"
|
||||
#include "gimpviewable.h"
|
||||
|
||||
#include "libgimp/gimpintl.h"
|
||||
|
||||
#include "pixmaps/delete.xpm"
|
||||
#include "pixmaps/duplicate.xpm"
|
||||
#include "pixmaps/new.xpm"
|
||||
#include "pixmaps/edit.xpm"
|
||||
#include "pixmaps/refresh.xpm"
|
||||
|
||||
|
||||
static void gimp_data_factory_view_class_init (GimpDataFactoryViewClass *klass);
|
||||
static void gimp_data_factory_view_init (GimpDataFactoryView *view);
|
||||
static void gimp_data_factory_view_destroy (GtkObject *object);
|
||||
|
||||
static void gimp_data_factory_view_new_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view);
|
||||
static void gimp_data_factory_view_duplicate_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view);
|
||||
static void gimp_data_factory_view_duplicate_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data);
|
||||
static void gimp_data_factory_view_edit_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view);
|
||||
static void gimp_data_factory_view_edit_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data);
|
||||
static void gimp_data_factory_view_delete_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view);
|
||||
static void gimp_data_factory_view_delete_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data);
|
||||
static void gimp_data_factory_view_refresh_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view);
|
||||
|
||||
static void gimp_data_factory_view_data_changed (GimpContext *context,
|
||||
GimpData *data,
|
||||
GimpDataFactoryView *view);
|
||||
static void gimp_data_factory_view_data_activate (GtkWidget *context,
|
||||
GimpData *data,
|
||||
gpointer insert_data,
|
||||
GimpDataFactoryView *view);
|
||||
|
||||
|
||||
static GtkVBoxClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_data_factory_view_get_type (void)
|
||||
{
|
||||
static guint view_type = 0;
|
||||
|
||||
if (! view_type)
|
||||
{
|
||||
GtkTypeInfo view_info =
|
||||
{
|
||||
"GimpDataFactoryView",
|
||||
sizeof (GimpDataFactoryView),
|
||||
sizeof (GimpDataFactoryViewClass),
|
||||
(GtkClassInitFunc) gimp_data_factory_view_class_init,
|
||||
(GtkObjectInitFunc) gimp_data_factory_view_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
view_type = gtk_type_unique (GTK_TYPE_VBOX, &view_info);
|
||||
}
|
||||
|
||||
return view_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_class_init (GimpDataFactoryViewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_VBOX);
|
||||
|
||||
object_class->destroy = gimp_data_factory_view_destroy;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_init (GimpDataFactoryView *view)
|
||||
{
|
||||
GtkWidget *pixmap;
|
||||
|
||||
view->view = NULL;
|
||||
|
||||
gtk_box_set_spacing (GTK_BOX (view), 2);
|
||||
|
||||
view->button_box = gtk_hbox_new (TRUE, 2);
|
||||
gtk_box_pack_end (GTK_BOX (view), view->button_box, FALSE, FALSE, 0);
|
||||
gtk_widget_show (view->button_box);
|
||||
|
||||
/* new */
|
||||
|
||||
view->new_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->new_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->new_button);
|
||||
|
||||
gimp_help_set_help_data (view->new_button, _("New"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->new_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_data_factory_view_new_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (new_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->new_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
/* duplicate */
|
||||
|
||||
view->duplicate_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->duplicate_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->duplicate_button);
|
||||
|
||||
gimp_help_set_help_data (view->duplicate_button, _("Duplicate"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->duplicate_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_data_factory_view_duplicate_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (duplicate_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->duplicate_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
/* edit */
|
||||
|
||||
view->edit_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->edit_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->edit_button);
|
||||
|
||||
gimp_help_set_help_data (view->edit_button, _("Edit"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->edit_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_data_factory_view_edit_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (edit_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->edit_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
/* delete */
|
||||
|
||||
view->delete_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->delete_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->delete_button);
|
||||
|
||||
gimp_help_set_help_data (view->delete_button, _("Delete"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->delete_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_data_factory_view_delete_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (delete_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->delete_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
/* refresh */
|
||||
|
||||
view->refresh_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->refresh_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->refresh_button);
|
||||
|
||||
gimp_help_set_help_data (view->refresh_button, _("Refresh"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->refresh_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_data_factory_view_refresh_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (refresh_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->refresh_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
gtk_widget_set_sensitive (view->duplicate_button, FALSE);
|
||||
gtk_widget_set_sensitive (view->edit_button, FALSE);
|
||||
gtk_widget_set_sensitive (view->delete_button, FALSE);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_destroy (GtkObject *object)
|
||||
{
|
||||
GimpDataFactoryView *view;
|
||||
|
||||
view = GIMP_DATA_FACTORY_VIEW (object);
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_data_factory_view_new (GimpViewType view_type,
|
||||
GimpDataFactory *factory,
|
||||
GimpDataEditFunc edit_func,
|
||||
GimpContext *context,
|
||||
gint preview_size,
|
||||
gint min_items_x,
|
||||
gint min_items_y)
|
||||
{
|
||||
GimpDataFactoryView *factory_view;
|
||||
|
||||
g_return_val_if_fail (factory != NULL, NULL);
|
||||
g_return_val_if_fail (GIMP_IS_DATA_FACTORY (factory), NULL);
|
||||
g_return_val_if_fail (preview_size > 0 && preview_size <= 64, NULL);
|
||||
g_return_val_if_fail (min_items_x > 0 && min_items_x <= 64, NULL);
|
||||
g_return_val_if_fail (min_items_y > 0 && min_items_y <= 64, NULL);
|
||||
|
||||
factory_view = gtk_type_new (GIMP_TYPE_DATA_FACTORY_VIEW);
|
||||
|
||||
factory_view->factory = factory;
|
||||
factory_view->data_edit_func = edit_func;
|
||||
|
||||
switch (view_type)
|
||||
{
|
||||
case GIMP_VIEW_TYPE_GRID:
|
||||
factory_view->view =
|
||||
GIMP_CONTAINER_VIEW (gimp_container_grid_view_new (factory->container,
|
||||
context,
|
||||
preview_size,
|
||||
min_items_x,
|
||||
min_items_y));
|
||||
break;
|
||||
|
||||
case GIMP_VIEW_TYPE_LIST:
|
||||
factory_view->view =
|
||||
GIMP_CONTAINER_VIEW (gimp_container_list_view_new (factory->container,
|
||||
context,
|
||||
preview_size,
|
||||
min_items_x,
|
||||
min_items_y));
|
||||
break;
|
||||
|
||||
default:
|
||||
g_warning ("%s(): unknown GimpViewType passed", G_GNUC_FUNCTION);
|
||||
gtk_object_unref (GTK_OBJECT (factory_view));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
gtk_container_add (GTK_CONTAINER (factory_view),
|
||||
GTK_WIDGET (factory_view->view));
|
||||
gtk_widget_show (GTK_WIDGET (factory_view->view));
|
||||
|
||||
gtk_signal_connect_while_alive
|
||||
(GTK_OBJECT (context),
|
||||
gimp_context_type_to_signal_name (factory->container->children_type),
|
||||
GTK_SIGNAL_FUNC (gimp_data_factory_view_data_changed),
|
||||
factory_view,
|
||||
GTK_OBJECT (factory_view));
|
||||
|
||||
gtk_signal_connect_while_alive
|
||||
(GTK_OBJECT (factory_view->view), "activate_item",
|
||||
GTK_SIGNAL_FUNC (gimp_data_factory_view_data_activate),
|
||||
factory_view,
|
||||
GTK_OBJECT (factory_view));
|
||||
|
||||
/* drop to "duplicate" */
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (factory_view->duplicate_button),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
factory_view->factory->container->children_type,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (factory_view->duplicate_button),
|
||||
factory_view->factory->container->children_type,
|
||||
gimp_data_factory_view_duplicate_dropped,
|
||||
factory_view);
|
||||
|
||||
/* drop to "edit" */
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (factory_view->edit_button),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
factory_view->factory->container->children_type,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (factory_view->edit_button),
|
||||
factory_view->factory->container->children_type,
|
||||
gimp_data_factory_view_edit_dropped,
|
||||
factory_view);
|
||||
|
||||
/* drop to "delete" */
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (factory_view->delete_button),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
factory_view->factory->container->children_type,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (factory_view->delete_button),
|
||||
factory_view->factory->container->children_type,
|
||||
gimp_data_factory_view_delete_dropped,
|
||||
factory_view);
|
||||
|
||||
/* set button sensitivity */
|
||||
gimp_data_factory_view_data_changed
|
||||
(context,
|
||||
(GimpData *)
|
||||
gimp_context_get_by_type (context, factory->container->children_type),
|
||||
factory_view);
|
||||
|
||||
return GTK_WIDGET (factory_view);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_new_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view)
|
||||
{
|
||||
if (view->factory->data_new_func)
|
||||
{
|
||||
GimpData *data;
|
||||
|
||||
data = gimp_data_factory_data_new (view->factory, _("Untitled"));
|
||||
|
||||
if (data)
|
||||
{
|
||||
gimp_context_set_by_type (view->view->context,
|
||||
view->factory->container->children_type,
|
||||
GIMP_OBJECT (data));
|
||||
|
||||
gimp_data_factory_view_edit_clicked (NULL, view);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_duplicate_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view)
|
||||
{
|
||||
GimpData *data;
|
||||
|
||||
data = (GimpData *)
|
||||
gimp_context_get_by_type (view->view->context,
|
||||
view->factory->container->children_type);
|
||||
|
||||
if (data && gimp_container_have (view->factory->container,
|
||||
GIMP_OBJECT (data)))
|
||||
{
|
||||
GimpData *new_data;
|
||||
|
||||
new_data = gimp_data_duplicate (data);
|
||||
|
||||
if (new_data)
|
||||
{
|
||||
const gchar *name;
|
||||
gchar *ext;
|
||||
gint copy_len;
|
||||
gint number;
|
||||
gchar *new_name;
|
||||
|
||||
name = gimp_object_get_name (GIMP_OBJECT (data));
|
||||
|
||||
ext = strrchr (name, '#');
|
||||
copy_len = strlen (_("copy"));
|
||||
|
||||
if ((strlen (name) >= copy_len &&
|
||||
strcmp (&name[strlen (name) - copy_len], _("copy")) == 0) ||
|
||||
(ext && (number = atoi (ext + 1)) > 0 &&
|
||||
((gint) (log10 (number) + 1)) == strlen (ext + 1)))
|
||||
{
|
||||
/* don't have redundant "copy"s */
|
||||
new_name = g_strdup (name);
|
||||
}
|
||||
else
|
||||
{
|
||||
new_name = g_strdup_printf (_("%s copy"), name);
|
||||
}
|
||||
|
||||
gimp_object_set_name (GIMP_OBJECT (new_data), new_name);
|
||||
|
||||
g_free (new_name);
|
||||
|
||||
gimp_container_add (view->factory->container, GIMP_OBJECT (new_data));
|
||||
|
||||
gimp_context_set_by_type (view->view->context,
|
||||
view->factory->container->children_type,
|
||||
GIMP_OBJECT (new_data));
|
||||
|
||||
gimp_data_factory_view_edit_clicked (NULL, view);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_duplicate_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDataFactoryView *view;
|
||||
|
||||
view = (GimpDataFactoryView *) data;
|
||||
|
||||
if (viewable && gimp_container_have (view->factory->container,
|
||||
GIMP_OBJECT (viewable)))
|
||||
{
|
||||
gimp_context_set_by_type (view->view->context,
|
||||
view->factory->container->children_type,
|
||||
GIMP_OBJECT (viewable));
|
||||
|
||||
gimp_data_factory_view_duplicate_clicked (NULL, data);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_edit_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view)
|
||||
{
|
||||
GimpData *data;
|
||||
|
||||
data = (GimpData *)
|
||||
gimp_context_get_by_type (view->view->context,
|
||||
view->factory->container->children_type);
|
||||
|
||||
if (view->data_edit_func &&
|
||||
data &&
|
||||
gimp_container_have (view->factory->container,
|
||||
GIMP_OBJECT (data)))
|
||||
{
|
||||
view->data_edit_func (data);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_edit_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDataFactoryView *view;
|
||||
|
||||
view = (GimpDataFactoryView *) data;
|
||||
|
||||
if (viewable && gimp_container_have (view->factory->container,
|
||||
GIMP_OBJECT (viewable)))
|
||||
{
|
||||
gimp_context_set_by_type (view->view->context,
|
||||
view->factory->container->children_type,
|
||||
GIMP_OBJECT (viewable));
|
||||
|
||||
gimp_data_factory_view_edit_clicked (NULL, data);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
typedef struct _GimpDataDeleteData GimpDataDeleteData;
|
||||
|
||||
struct _GimpDataDeleteData
|
||||
{
|
||||
GimpDataFactory *factory;
|
||||
GimpData *data;
|
||||
};
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_delete_callback (GtkWidget *widget,
|
||||
gboolean delete,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDataDeleteData *delete_data;
|
||||
|
||||
delete_data = (GimpDataDeleteData *) data;
|
||||
|
||||
if (! delete)
|
||||
return;
|
||||
|
||||
if (gimp_container_have (delete_data->factory->container,
|
||||
GIMP_OBJECT (delete_data->data)))
|
||||
{
|
||||
if (delete_data->data->filename)
|
||||
gimp_data_delete_from_disk (delete_data->data);
|
||||
|
||||
gimp_container_remove (delete_data->factory->container,
|
||||
GIMP_OBJECT (delete_data->data));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_delete_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view)
|
||||
{
|
||||
GimpData *data;
|
||||
|
||||
data = (GimpData *)
|
||||
gimp_context_get_by_type (view->view->context,
|
||||
view->factory->container->children_type);
|
||||
|
||||
if (data && gimp_container_have (view->factory->container,
|
||||
GIMP_OBJECT (data)))
|
||||
{
|
||||
GimpDataDeleteData *delete_data;
|
||||
GtkWidget *dialog;
|
||||
gchar *str;
|
||||
|
||||
delete_data = g_new0 (GimpDataDeleteData, 1);
|
||||
|
||||
delete_data->factory = view->factory;
|
||||
delete_data->data = data;
|
||||
|
||||
str = g_strdup_printf (_("Are you sure you want to delete\n"
|
||||
"\"%s\" from the list and from disk?"),
|
||||
GIMP_OBJECT (data)->name);
|
||||
|
||||
dialog =
|
||||
gimp_query_boolean_box (_("Delete Data Object"),
|
||||
gimp_standard_help_func, NULL,
|
||||
FALSE,
|
||||
str,
|
||||
_("Delete"), _("Cancel"),
|
||||
GTK_OBJECT (data),
|
||||
"destroy",
|
||||
gimp_data_factory_view_delete_callback,
|
||||
delete_data);
|
||||
|
||||
gtk_signal_connect_object (GTK_OBJECT (dialog), "destroy",
|
||||
GTK_SIGNAL_FUNC (g_free),
|
||||
(GtkObject *) delete_data);
|
||||
|
||||
g_free (str);
|
||||
|
||||
gtk_widget_show (dialog);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_delete_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDataFactoryView *view;
|
||||
|
||||
view = (GimpDataFactoryView *) data;
|
||||
|
||||
if (viewable && gimp_container_have (view->factory->container,
|
||||
GIMP_OBJECT (viewable)))
|
||||
{
|
||||
gimp_context_set_by_type (view->view->context,
|
||||
view->factory->container->children_type,
|
||||
GIMP_OBJECT (viewable));
|
||||
|
||||
gimp_data_factory_view_delete_clicked (NULL, data);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_refresh_clicked (GtkWidget *widget,
|
||||
GimpDataFactoryView *view)
|
||||
{
|
||||
gimp_data_factory_data_init (view->factory, FALSE);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_data_changed (GimpContext *context,
|
||||
GimpData *data,
|
||||
GimpDataFactoryView *view)
|
||||
{
|
||||
gboolean duplicate_sensitive = FALSE;
|
||||
gboolean edit_sensitive = FALSE;
|
||||
gboolean delete_sensitive = FALSE;
|
||||
|
||||
if (data && gimp_container_have (view->factory->container,
|
||||
GIMP_OBJECT (data)))
|
||||
{
|
||||
duplicate_sensitive =
|
||||
(GIMP_DATA_CLASS (GTK_OBJECT (data)->klass)->duplicate != NULL);
|
||||
|
||||
edit_sensitive = (view->data_edit_func != NULL);
|
||||
delete_sensitive = TRUE; /* TODO: check permissions */
|
||||
}
|
||||
|
||||
gtk_widget_set_sensitive (view->duplicate_button, duplicate_sensitive);
|
||||
gtk_widget_set_sensitive (view->edit_button, edit_sensitive);
|
||||
gtk_widget_set_sensitive (view->delete_button, delete_sensitive);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_data_factory_view_data_activate (GtkWidget *widget,
|
||||
GimpData *data,
|
||||
gpointer insert_data,
|
||||
GimpDataFactoryView *view)
|
||||
{
|
||||
if (data && gimp_container_have (view->factory->container,
|
||||
GIMP_OBJECT (data)))
|
||||
{
|
||||
gimp_data_factory_view_edit_clicked (NULL, view);
|
||||
}
|
||||
}
|
|
@ -1,80 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_DATA_FACTORY_VIEW_H__
|
||||
#define __GIMP_DATA_FACTORY_VIEW_H__
|
||||
|
||||
|
||||
#include <gtk/gtkvbox.h>
|
||||
|
||||
|
||||
typedef void (* GimpDataEditFunc) (GimpData *data);
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
GIMP_VIEW_TYPE_GRID,
|
||||
GIMP_VIEW_TYPE_LIST
|
||||
} GimpViewType;
|
||||
|
||||
|
||||
#define GIMP_TYPE_DATA_FACTORY_VIEW (gimp_data_factory_view_get_type ())
|
||||
#define GIMP_DATA_FACTORY_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DATA_FACTORY_VIEW, GimpDataFactoryView))
|
||||
#define GIMP_DATA_FACTORY_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DATA_FACTORY_VIEW, GimpDataFactoryViewClass))
|
||||
#define GIMP_IS_DATA_FACTORY_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DATA_FACTORY_VIEW))
|
||||
#define GIMP_IS_DATA_FACTORY_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA_FACTORY_VIEW))
|
||||
|
||||
|
||||
typedef struct _GimpDataFactoryViewClass GimpDataFactoryViewClass;
|
||||
|
||||
struct _GimpDataFactoryView
|
||||
{
|
||||
GtkVBox parent_instance;
|
||||
|
||||
GimpDataFactory *factory;
|
||||
GimpDataEditFunc data_edit_func;
|
||||
|
||||
GimpContainerView *view;
|
||||
|
||||
GtkWidget *button_box;
|
||||
|
||||
GtkWidget *new_button;
|
||||
GtkWidget *duplicate_button;
|
||||
GtkWidget *edit_button;
|
||||
GtkWidget *delete_button;
|
||||
|
||||
GtkWidget *refresh_button;
|
||||
};
|
||||
|
||||
struct _GimpDataFactoryViewClass
|
||||
{
|
||||
GtkVBoxClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_data_factory_view_get_type (void);
|
||||
GtkWidget * gimp_data_factory_view_new (GimpViewType view_type,
|
||||
GimpDataFactory *factory,
|
||||
GimpDataEditFunc edit_func,
|
||||
GimpContext *context,
|
||||
gint preview_size,
|
||||
gint min_items_x,
|
||||
gint min_items_y);
|
||||
|
||||
|
||||
#endif /* __GIMP_DATA_FACTORY_VIEW_H__ */
|
|
@ -32,6 +32,8 @@
|
|||
#include "tools/gimptoolinfo.h"
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "context_manager.h"
|
||||
#include "file-open.h"
|
||||
#include "gimpimage.h"
|
||||
|
@ -46,7 +48,6 @@
|
|||
#include "gimplayermask.h"
|
||||
#include "gimppalette.h"
|
||||
#include "gimppattern.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimprc.h"
|
||||
#include "temp_buf.h"
|
||||
|
||||
|
|
456
app/gimpdock.c
456
app/gimpdock.c
|
@ -1,456 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimpdock.c
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpwidgets/gimpwidgets.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpdnd.h"
|
||||
#include "gimpdock.h"
|
||||
#include "gimpdockable.h"
|
||||
#include "gimpdockbook.h"
|
||||
|
||||
|
||||
static void gimp_dock_class_init (GimpDockClass *klass);
|
||||
static void gimp_dock_init (GimpDock *dock);
|
||||
|
||||
static GtkWidget * gimp_dock_separator_new (GimpDock *dock);
|
||||
|
||||
static void gimp_dock_destroy (GtkObject *object);
|
||||
|
||||
static gboolean gimp_dock_separator_button_press (GtkWidget *widget,
|
||||
GdkEventButton *bevent,
|
||||
gpointer data);
|
||||
static gboolean gimp_dock_separator_button_release (GtkWidget *widget,
|
||||
GdkEventButton *bevent,
|
||||
gpointer data);
|
||||
|
||||
/*
|
||||
static void gimp_dock_separator_drag_begin (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gpointer data);
|
||||
static void gimp_dock_separator_drag_end (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gpointer data);
|
||||
*/
|
||||
|
||||
static gboolean gimp_dock_separator_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time,
|
||||
gpointer data);
|
||||
|
||||
|
||||
static GtkWindowClass *parent_class = NULL;
|
||||
|
||||
static GtkTargetEntry dialog_target_table[] =
|
||||
{
|
||||
GIMP_TARGET_DIALOG
|
||||
};
|
||||
static guint n_dialog_targets = (sizeof (dialog_target_table) /
|
||||
sizeof (dialog_target_table[0]));
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_dock_get_type (void)
|
||||
{
|
||||
static GtkType dock_type = 0;
|
||||
|
||||
if (! dock_type)
|
||||
{
|
||||
static const GtkTypeInfo dock_info =
|
||||
{
|
||||
"GimpDock",
|
||||
sizeof (GimpDock),
|
||||
sizeof (GimpDockClass),
|
||||
(GtkClassInitFunc) gimp_dock_class_init,
|
||||
(GtkObjectInitFunc) gimp_dock_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
dock_type = gtk_type_unique (GTK_TYPE_WINDOW, &dock_info);
|
||||
}
|
||||
|
||||
return dock_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dock_class_init (GimpDockClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_WINDOW);
|
||||
|
||||
object_class->destroy = gimp_dock_destroy;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dock_init (GimpDock *dock)
|
||||
{
|
||||
GtkWidget *separator;
|
||||
|
||||
gtk_window_set_policy (GTK_WINDOW (dock), FALSE, TRUE, TRUE);
|
||||
|
||||
dock->vbox = gtk_vbox_new (FALSE, 0);
|
||||
gtk_container_add (GTK_CONTAINER (dock), dock->vbox);
|
||||
gtk_widget_show (dock->vbox);
|
||||
|
||||
separator = gimp_dock_separator_new (dock);
|
||||
gtk_box_pack_start (GTK_BOX (dock->vbox), separator, FALSE, FALSE, 0);
|
||||
gtk_widget_show (separator);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dock_destroy (GtkObject *object)
|
||||
{
|
||||
GimpDock *dock;
|
||||
|
||||
dock = GIMP_DOCK (object);
|
||||
|
||||
g_list_free (dock->dockbooks);
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class))
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_dock_new (void)
|
||||
{
|
||||
return GTK_WIDGET (gtk_type_new (GIMP_TYPE_DOCK));
|
||||
}
|
||||
|
||||
static GtkWidget *
|
||||
gimp_dock_separator_new (GimpDock *dock)
|
||||
{
|
||||
GtkWidget *event_box;
|
||||
GtkWidget *frame;
|
||||
|
||||
event_box = gtk_event_box_new ();
|
||||
gtk_widget_set_usize (event_box, -1, 8);
|
||||
|
||||
frame = gtk_frame_new (NULL);
|
||||
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
|
||||
gtk_container_add (GTK_CONTAINER (event_box), frame);
|
||||
gtk_widget_show (frame);
|
||||
|
||||
gtk_drag_dest_set (GTK_WIDGET (event_box),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
dialog_target_table, n_dialog_targets,
|
||||
GDK_ACTION_MOVE);
|
||||
gtk_signal_connect (GTK_OBJECT (event_box), "drag_drop",
|
||||
GTK_SIGNAL_FUNC (gimp_dock_separator_drag_drop),
|
||||
dock);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (event_box), "button_press_event",
|
||||
GTK_SIGNAL_FUNC (gimp_dock_separator_button_press),
|
||||
dock);
|
||||
gtk_signal_connect (GTK_OBJECT (event_box), "button_release_event",
|
||||
GTK_SIGNAL_FUNC (gimp_dock_separator_button_release),
|
||||
dock);
|
||||
|
||||
return event_box;
|
||||
}
|
||||
|
||||
void
|
||||
gimp_dock_add (GimpDock *dock,
|
||||
GimpDockable *dockable,
|
||||
gint section,
|
||||
gint position)
|
||||
{
|
||||
GimpDockbook *dockbook;
|
||||
|
||||
g_return_if_fail (dock != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCK (dock));
|
||||
|
||||
g_return_if_fail (dockable != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCKABLE (dockable));
|
||||
|
||||
g_return_if_fail (dockable->dockbook == NULL);
|
||||
|
||||
dockbook = GIMP_DOCKBOOK (dock->dockbooks->data);
|
||||
|
||||
gimp_dockbook_add (dockbook, dockable, position);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_dock_remove (GimpDock *dock,
|
||||
GimpDockable *dockable)
|
||||
{
|
||||
g_return_if_fail (dock != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCK (dock));
|
||||
|
||||
g_return_if_fail (dockable != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCKABLE (dockable));
|
||||
|
||||
g_return_if_fail (dockable->dockbook != NULL);
|
||||
g_return_if_fail (dockable->dockbook->dock != NULL);
|
||||
g_return_if_fail (dockable->dockbook->dock == dock);
|
||||
|
||||
gimp_dockbook_remove (dockable->dockbook, dockable);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_dock_add_book (GimpDock *dock,
|
||||
GimpDockbook *dockbook,
|
||||
gint index)
|
||||
{
|
||||
GtkWidget *separator;
|
||||
gint length;
|
||||
|
||||
g_return_if_fail (dock != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCK (dock));
|
||||
|
||||
g_return_if_fail (dockbook != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
|
||||
|
||||
g_return_if_fail (dockbook->dock == NULL);
|
||||
|
||||
length = g_list_length (dock->dockbooks);
|
||||
|
||||
if (index >= length || index < 0)
|
||||
index = length;
|
||||
|
||||
dockbook->dock = dock;
|
||||
dock->dockbooks = g_list_insert (dock->dockbooks, dockbook, index);
|
||||
|
||||
index *= 2;
|
||||
|
||||
gtk_box_pack_start (GTK_BOX (dock->vbox), GTK_WIDGET (dockbook),
|
||||
TRUE, TRUE, 0);
|
||||
gtk_box_reorder_child (GTK_BOX (dock->vbox), GTK_WIDGET (dockbook), index);
|
||||
gtk_widget_show (GTK_WIDGET (dockbook));
|
||||
|
||||
separator = gimp_dock_separator_new (dock);
|
||||
gtk_box_pack_start (GTK_BOX (dock->vbox), separator, FALSE, FALSE, 0);
|
||||
gtk_box_reorder_child (GTK_BOX (dock->vbox), separator, index);
|
||||
gtk_widget_show (separator);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_dock_remove_book (GimpDock *dock,
|
||||
GimpDockbook *dockbook)
|
||||
{
|
||||
GList *children;
|
||||
gint length;
|
||||
gint index;
|
||||
gint book_index;
|
||||
|
||||
g_return_if_fail (dock != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCK (dock));
|
||||
|
||||
g_return_if_fail (dockbook != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
|
||||
|
||||
g_return_if_fail (dockbook->dock == dock);
|
||||
|
||||
length = g_list_length (dock->dockbooks);
|
||||
index = g_list_index (dock->dockbooks, dockbook);
|
||||
|
||||
dockbook->dock = NULL;
|
||||
dock->dockbooks = g_list_remove (dock->dockbooks, dockbook);
|
||||
|
||||
children = gtk_container_children (GTK_CONTAINER (dock->vbox));
|
||||
book_index = g_list_index (children, dockbook);
|
||||
|
||||
if (length != 1)
|
||||
{
|
||||
GtkWidget *separator;
|
||||
|
||||
if (index == length -1)
|
||||
{
|
||||
separator = g_list_nth_data (children, book_index - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
separator = g_list_nth_data (children, book_index + 1);
|
||||
}
|
||||
|
||||
gtk_container_remove (GTK_CONTAINER (dock->vbox), separator);
|
||||
}
|
||||
|
||||
gtk_container_remove (GTK_CONTAINER (dock->vbox), GTK_WIDGET (dockbook));
|
||||
|
||||
if (length == 1)
|
||||
{
|
||||
gtk_widget_destroy (GTK_WIDGET (dock));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_dock_separator_button_press (GtkWidget *widget,
|
||||
GdkEventButton *bevent,
|
||||
gpointer data)
|
||||
{
|
||||
if (bevent->type == GDK_BUTTON_PRESS)
|
||||
{
|
||||
if (bevent->button == 1)
|
||||
{
|
||||
gtk_grab_add (widget);
|
||||
}
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_dock_separator_button_release (GtkWidget *widget,
|
||||
GdkEventButton *bevent,
|
||||
gpointer data)
|
||||
{
|
||||
if (bevent->button == 1)
|
||||
{
|
||||
gtk_grab_remove (widget);
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
static void
|
||||
gimp_dock_tab_drag_begin (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDockable *dockable;
|
||||
GtkWidget *window;
|
||||
GtkWidget *frame;
|
||||
GtkWidget *label;
|
||||
|
||||
dockable = GIMP_DOCKABLE (data);
|
||||
|
||||
window = gtk_window_new (GTK_WINDOW_POPUP);
|
||||
|
||||
frame = gtk_frame_new (NULL);
|
||||
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
|
||||
gtk_container_add (GTK_CONTAINER (window), frame);
|
||||
gtk_widget_show (frame);
|
||||
|
||||
label = gtk_label_new (dockable->name);
|
||||
gtk_misc_set_padding (GTK_MISC (label), 10, 5);
|
||||
gtk_container_add (GTK_CONTAINER (frame), label);
|
||||
gtk_widget_show (label);
|
||||
|
||||
gtk_widget_show (window);
|
||||
|
||||
gtk_object_set_data_full (GTK_OBJECT (dockable), "gimp_dock_drag_widget",
|
||||
window,
|
||||
(GtkDestroyNotify) gtk_widget_destroy);
|
||||
|
||||
gtk_drag_set_icon_widget (context, window,
|
||||
-8, -8);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dock_tab_drag_end (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDockable *dockable;
|
||||
GtkWidget *drag_widget;
|
||||
|
||||
dockable = GIMP_DOCKABLE (data);
|
||||
|
||||
drag_widget = gtk_object_get_data (GTK_OBJECT (dockable),
|
||||
"gimp_dock_drag_widget");
|
||||
|
||||
if (drag_widget)
|
||||
{
|
||||
GtkWidget *dock;
|
||||
|
||||
gtk_object_set_data (GTK_OBJECT (dockable), "gimp_dock_drag_widget", NULL);
|
||||
|
||||
dock = gimp_dock_new ();
|
||||
|
||||
gtk_window_set_position (GTK_WINDOW (dock), GTK_WIN_POS_MOUSE);
|
||||
|
||||
gtk_object_ref (GTK_OBJECT (dockable));
|
||||
|
||||
gimp_dock_remove (dockable->dock, dockable);
|
||||
gimp_dock_add (GIMP_DOCK (dock), dockable, -1, -1);
|
||||
|
||||
gtk_object_unref (GTK_OBJECT (dockable));
|
||||
|
||||
gtk_widget_show (dock);
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
static gboolean
|
||||
gimp_dock_separator_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDock *dock;
|
||||
GtkWidget *source;
|
||||
|
||||
dock = GIMP_DOCK (data);
|
||||
|
||||
source = gtk_drag_get_source_widget (context);
|
||||
|
||||
if (source)
|
||||
{
|
||||
GimpDockable *src_dockable;
|
||||
|
||||
src_dockable = (GimpDockable *) gtk_object_get_data (GTK_OBJECT (source),
|
||||
"gimp_dockable");
|
||||
|
||||
if (src_dockable)
|
||||
{
|
||||
GtkWidget *dockbook;
|
||||
GList *children;
|
||||
gint index;
|
||||
|
||||
gtk_object_set_data (GTK_OBJECT (src_dockable),
|
||||
"gimp_dock_drag_widget", NULL);
|
||||
|
||||
children = gtk_container_children (GTK_CONTAINER (widget->parent));
|
||||
index = g_list_index (children, widget) / 2;
|
||||
|
||||
dockbook = gimp_dockbook_new ();
|
||||
|
||||
gimp_dock_add_book (dock, GIMP_DOCKBOOK (dockbook), index);
|
||||
|
||||
gtk_object_ref (GTK_OBJECT (src_dockable));
|
||||
|
||||
gimp_dockbook_remove (src_dockable->dockbook, src_dockable);
|
||||
gimp_dockbook_add (GIMP_DOCKBOOK (dockbook), src_dockable, -1);
|
||||
|
||||
gtk_object_unref (GTK_OBJECT (src_dockable));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
|
@ -1,71 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimpdock.h
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_DOCK_H__
|
||||
#define __GIMP_DOCK_H__
|
||||
|
||||
|
||||
#include <gtk/gtkwindow.h>
|
||||
|
||||
|
||||
#define GIMP_TYPE_DOCK (gimp_dock_get_type ())
|
||||
#define GIMP_DOCK(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DOCK, GimpDock))
|
||||
#define GIMP_DOCK_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DOCK, GimpDockClass))
|
||||
#define GIMP_IS_DOCK(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DOCK))
|
||||
#define GIMP_IS_DOCK_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DOCK))
|
||||
|
||||
|
||||
typedef struct _GimpDockClass GimpDockClass;
|
||||
|
||||
|
||||
struct _GimpDock
|
||||
{
|
||||
GtkWindow parent_instance;
|
||||
|
||||
GtkWidget *vbox;
|
||||
|
||||
GList *dockbooks;
|
||||
};
|
||||
|
||||
struct _GimpDockClass
|
||||
{
|
||||
GtkWindowClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_dock_get_type (void);
|
||||
GtkWidget * gimp_dock_new (void);
|
||||
|
||||
void gimp_dock_add (GimpDock *dock,
|
||||
GimpDockable *dockable,
|
||||
gint book,
|
||||
gint index);
|
||||
void gimp_dock_remove (GimpDock *dock,
|
||||
GimpDockable *dockable);
|
||||
|
||||
void gimp_dock_add_book (GimpDock *dock,
|
||||
GimpDockbook *dockbook,
|
||||
gint index);
|
||||
void gimp_dock_remove_book (GimpDock *dock,
|
||||
GimpDockbook *dockbook);
|
||||
|
||||
|
||||
#endif /* __GIMP_DOCK_H__ */
|
|
@ -1,135 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimpdockable.c
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpdockable.h"
|
||||
|
||||
|
||||
static void gimp_dockable_class_init (GimpDockableClass *klass);
|
||||
static void gimp_dockable_init (GimpDockable *dockable);
|
||||
|
||||
static void gimp_dockable_destroy (GtkObject *object);
|
||||
|
||||
|
||||
static GtkVBoxClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_dockable_get_type (void)
|
||||
{
|
||||
static GtkType dockable_type = 0;
|
||||
|
||||
if (! dockable_type)
|
||||
{
|
||||
static const GtkTypeInfo dockable_info =
|
||||
{
|
||||
"GimpDockable",
|
||||
sizeof (GimpDockable),
|
||||
sizeof (GimpDockableClass),
|
||||
(GtkClassInitFunc) gimp_dockable_class_init,
|
||||
(GtkObjectInitFunc) gimp_dockable_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
dockable_type = gtk_type_unique (GTK_TYPE_VBOX, &dockable_info);
|
||||
}
|
||||
|
||||
return dockable_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dockable_class_init (GimpDockableClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_VBOX);
|
||||
|
||||
object_class->destroy = gimp_dockable_destroy;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dockable_init (GimpDockable *dockable)
|
||||
{
|
||||
dockable->name = NULL;
|
||||
dockable->short_name = NULL;
|
||||
dockable->dockbook = NULL;
|
||||
dockable->get_tab_func = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dockable_destroy (GtkObject *object)
|
||||
{
|
||||
GimpDockable *dockable;
|
||||
|
||||
dockable = GIMP_DOCKABLE (object);
|
||||
|
||||
g_free (dockable->name);
|
||||
g_free (dockable->short_name);
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class))
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_dockable_new (const gchar *name,
|
||||
const gchar *short_name,
|
||||
GimpDockableGetTabFunc get_tab_func)
|
||||
{
|
||||
GimpDockable *dockable;
|
||||
|
||||
g_return_val_if_fail (name != NULL, NULL);
|
||||
g_return_val_if_fail (short_name != NULL, NULL);
|
||||
|
||||
dockable = gtk_type_new (GIMP_TYPE_DOCKABLE);
|
||||
|
||||
dockable->name = g_strdup (name);
|
||||
dockable->short_name = g_strdup (short_name);
|
||||
|
||||
dockable->get_tab_func = get_tab_func;
|
||||
|
||||
return GTK_WIDGET (dockable);
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_dockable_get_tab_widget (GimpDockable *dockable,
|
||||
gint size)
|
||||
{
|
||||
g_return_val_if_fail (dockable != NULL, NULL);
|
||||
g_return_val_if_fail (GIMP_IS_DOCKABLE (dockable), NULL);
|
||||
|
||||
g_return_val_if_fail (size >= -1 && size < 64, NULL);
|
||||
|
||||
if (dockable->get_tab_func)
|
||||
{
|
||||
return dockable->get_tab_func (dockable, size);
|
||||
}
|
||||
|
||||
return gtk_label_new (dockable->short_name);
|
||||
}
|
|
@ -1,70 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimpdockable.h
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_DOCKABLE_H__
|
||||
#define __GIMP_DOCKABLE_H__
|
||||
|
||||
|
||||
#include <gtk/gtkvbox.h>
|
||||
|
||||
|
||||
typedef GtkWidget * (* GimpDockableGetTabFunc) (GimpDockable *dockable,
|
||||
gint size);
|
||||
|
||||
|
||||
#define GIMP_TYPE_DOCKABLE (gimp_dockable_get_type ())
|
||||
#define GIMP_DOCKABLE(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DOCKABLE, GimpDockable))
|
||||
#define GIMP_DOCKABLE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DOCKABLE, GimpDockableClass))
|
||||
#define GIMP_IS_DOCKABLE(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DOCKABLE))
|
||||
#define GIMP_IS_DOCKABLE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DOCKABLE))
|
||||
|
||||
|
||||
typedef struct _GimpDockableClass GimpDockableClass;
|
||||
|
||||
|
||||
struct _GimpDockable
|
||||
{
|
||||
GtkVBox parent_instance;
|
||||
|
||||
gchar *name;
|
||||
gchar *short_name;
|
||||
|
||||
GimpDockbook *dockbook;
|
||||
|
||||
GimpDockableGetTabFunc get_tab_func;
|
||||
};
|
||||
|
||||
struct _GimpDockableClass
|
||||
{
|
||||
GtkVBoxClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_dockable_get_type (void);
|
||||
GtkWidget * gimp_dockable_new (const gchar *name,
|
||||
const gchar *short_name,
|
||||
GimpDockableGetTabFunc get_tab_func);
|
||||
|
||||
GtkWidget * gimp_dockable_get_tab_widget (GimpDockable *dockable,
|
||||
gint size);
|
||||
|
||||
|
||||
#endif /* __GIMP_DOCKABLE_H__ */
|
|
@ -1,515 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimpdockbook.c
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpwidgets/gimpwidgets.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpdnd.h"
|
||||
#include "gimpdock.h"
|
||||
#include "gimpdockable.h"
|
||||
#include "gimpdockbook.h"
|
||||
|
||||
|
||||
static void gimp_dockbook_class_init (GimpDockbookClass *klass);
|
||||
static void gimp_dockbook_init (GimpDockbook *dockbook);
|
||||
|
||||
static void gimp_dockbook_destroy (GtkObject *object);
|
||||
static gboolean gimp_dockbook_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time);
|
||||
|
||||
static gboolean gimp_dockbook_tab_button_press (GtkWidget *widget,
|
||||
GdkEventButton *bevent,
|
||||
gpointer data);
|
||||
static void gimp_dockbook_tab_drag_begin (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gpointer data);
|
||||
static void gimp_dockbook_tab_drag_end (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gpointer data);
|
||||
static gboolean gimp_dockbook_tab_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time,
|
||||
gpointer data);
|
||||
|
||||
|
||||
static GtkNotebookClass *parent_class = NULL;
|
||||
|
||||
static GtkTargetEntry dialog_target_table[] =
|
||||
{
|
||||
GIMP_TARGET_DIALOG
|
||||
};
|
||||
static guint n_dialog_targets = (sizeof (dialog_target_table) /
|
||||
sizeof (dialog_target_table[0]));
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_dockbook_get_type (void)
|
||||
{
|
||||
static GtkType dockbook_type = 0;
|
||||
|
||||
if (! dockbook_type)
|
||||
{
|
||||
static const GtkTypeInfo dockbook_info =
|
||||
{
|
||||
"GimpDockbook",
|
||||
sizeof (GimpDockbook),
|
||||
sizeof (GimpDockbookClass),
|
||||
(GtkClassInitFunc) gimp_dockbook_class_init,
|
||||
(GtkObjectInitFunc) gimp_dockbook_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
dockbook_type = gtk_type_unique (GTK_TYPE_NOTEBOOK, &dockbook_info);
|
||||
}
|
||||
|
||||
return dockbook_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dockbook_class_init (GimpDockbookClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkWidgetClass *widget_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
widget_class = (GtkWidgetClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_NOTEBOOK);
|
||||
|
||||
object_class->destroy = gimp_dockbook_destroy;
|
||||
|
||||
widget_class->drag_drop = gimp_dockbook_drag_drop;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dockbook_init (GimpDockbook *dockbook)
|
||||
{
|
||||
dockbook->dock = NULL;
|
||||
|
||||
gtk_notebook_set_tab_border (GTK_NOTEBOOK (dockbook), 0);
|
||||
gtk_notebook_popup_enable (GTK_NOTEBOOK (dockbook));
|
||||
gtk_notebook_set_scrollable (GTK_NOTEBOOK (dockbook), TRUE);
|
||||
|
||||
gtk_drag_dest_set (GTK_WIDGET (dockbook),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
dialog_target_table, n_dialog_targets,
|
||||
GDK_ACTION_MOVE);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dockbook_destroy (GtkObject *object)
|
||||
{
|
||||
if (GTK_OBJECT_CLASS (parent_class))
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_dockbook_new (void)
|
||||
{
|
||||
return GTK_WIDGET (gtk_type_new (GIMP_TYPE_DOCKBOOK));
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_dockbook_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time)
|
||||
{
|
||||
GtkWidget *source;
|
||||
|
||||
source = gtk_drag_get_source_widget (context);
|
||||
|
||||
if (source)
|
||||
{
|
||||
GimpDockable *dockable;
|
||||
|
||||
dockable = (GimpDockable *) gtk_object_get_data (GTK_OBJECT (source),
|
||||
"gimp_dockable");
|
||||
|
||||
if (dockable)
|
||||
{
|
||||
gtk_object_set_data (GTK_OBJECT (dockable),
|
||||
"gimp_dock_drag_widget", NULL);
|
||||
|
||||
if (dockable->dockbook != GIMP_DOCKBOOK (widget))
|
||||
{
|
||||
gtk_object_ref (GTK_OBJECT (dockable));
|
||||
|
||||
gimp_dockbook_remove (dockable->dockbook, dockable);
|
||||
gimp_dockbook_add (GIMP_DOCKBOOK (widget), dockable, -1);
|
||||
|
||||
gtk_object_unref (GTK_OBJECT (dockable));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void
|
||||
gimp_dockbook_add (GimpDockbook *dockbook,
|
||||
GimpDockable *dockable,
|
||||
gint position)
|
||||
{
|
||||
GtkWidget *tab_widget;
|
||||
GtkWidget *menu_widget;
|
||||
|
||||
g_return_if_fail (dockbook != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
|
||||
|
||||
g_return_if_fail (dockable != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCKABLE (dockable));
|
||||
|
||||
g_return_if_fail (dockable->dockbook == NULL);
|
||||
|
||||
tab_widget = gimp_dockable_get_tab_widget (dockable, 24);
|
||||
|
||||
if (GTK_IS_LABEL (tab_widget))
|
||||
{
|
||||
GtkWidget *event_box;
|
||||
|
||||
event_box = gtk_event_box_new ();
|
||||
gtk_container_add (GTK_CONTAINER (event_box), tab_widget);
|
||||
gtk_widget_show (tab_widget);
|
||||
|
||||
tab_widget = event_box;
|
||||
}
|
||||
else
|
||||
{
|
||||
gimp_help_set_help_data (tab_widget, dockable->name, NULL);
|
||||
}
|
||||
|
||||
gtk_object_set_data (GTK_OBJECT (tab_widget), "gimp_dockable", dockable);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (tab_widget), "button_press_event",
|
||||
GTK_SIGNAL_FUNC (gimp_dockbook_tab_button_press),
|
||||
dockable);
|
||||
|
||||
menu_widget = gimp_dockable_get_tab_widget (dockable, 16);
|
||||
|
||||
if (! GTK_IS_LABEL (menu_widget))
|
||||
{
|
||||
GtkWidget *hbox;
|
||||
GtkWidget *label;
|
||||
|
||||
hbox = gtk_hbox_new (FALSE, 4);
|
||||
|
||||
gtk_box_pack_start (GTK_BOX (hbox), menu_widget, FALSE, FALSE, 0);
|
||||
gtk_widget_show (menu_widget);
|
||||
|
||||
label = gtk_label_new (dockable->name);
|
||||
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
|
||||
gtk_widget_show (label);
|
||||
|
||||
menu_widget = hbox;
|
||||
}
|
||||
else
|
||||
{
|
||||
gtk_widget_destroy (menu_widget);
|
||||
|
||||
menu_widget = gtk_label_new (dockable->name);
|
||||
gtk_misc_set_alignment (GTK_MISC (menu_widget), 0.0, 0.5);
|
||||
}
|
||||
|
||||
if (position == -1)
|
||||
{
|
||||
gtk_notebook_append_page_menu (GTK_NOTEBOOK (dockbook),
|
||||
GTK_WIDGET (dockable),
|
||||
tab_widget,
|
||||
menu_widget);
|
||||
}
|
||||
else
|
||||
{
|
||||
gtk_notebook_insert_page_menu (GTK_NOTEBOOK (dockbook),
|
||||
GTK_WIDGET (dockable),
|
||||
tab_widget,
|
||||
menu_widget,
|
||||
position);
|
||||
}
|
||||
|
||||
gtk_widget_show (GTK_WIDGET (dockable));
|
||||
|
||||
gtk_drag_source_set (GTK_WIDGET (tab_widget),
|
||||
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
|
||||
dialog_target_table, n_dialog_targets,
|
||||
GDK_ACTION_MOVE);
|
||||
gtk_signal_connect (GTK_OBJECT (tab_widget), "drag_begin",
|
||||
GTK_SIGNAL_FUNC (gimp_dockbook_tab_drag_begin),
|
||||
dockable);
|
||||
gtk_signal_connect (GTK_OBJECT (tab_widget), "drag_end",
|
||||
GTK_SIGNAL_FUNC (gimp_dockbook_tab_drag_end),
|
||||
dockable);
|
||||
|
||||
gtk_drag_dest_set (GTK_WIDGET (tab_widget),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
dialog_target_table, n_dialog_targets,
|
||||
GDK_ACTION_MOVE);
|
||||
gtk_signal_connect (GTK_OBJECT (tab_widget), "drag_drop",
|
||||
GTK_SIGNAL_FUNC (gimp_dockbook_tab_drag_drop),
|
||||
dockbook);
|
||||
|
||||
dockable->dockbook = dockbook;
|
||||
|
||||
if (g_list_length (gtk_container_children (GTK_CONTAINER (dockbook))) == 1)
|
||||
{
|
||||
GtkWidget *item;
|
||||
|
||||
item = gtk_menu_item_new ();
|
||||
gtk_menu_append (GTK_MENU (GTK_NOTEBOOK (dockbook)->menu), item);
|
||||
gtk_widget_set_sensitive (item, FALSE);
|
||||
gtk_widget_show (item);
|
||||
|
||||
item = gtk_menu_item_new_with_label ("Test");
|
||||
gtk_menu_append (GTK_MENU (GTK_NOTEBOOK (dockbook)->menu), item);
|
||||
gtk_widget_show (item);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gimp_dockbook_remove (GimpDockbook *dockbook,
|
||||
GimpDockable *dockable)
|
||||
{
|
||||
g_return_if_fail (dockbook != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
|
||||
|
||||
g_return_if_fail (dockable != NULL);
|
||||
g_return_if_fail (GIMP_IS_DOCKABLE (dockable));
|
||||
|
||||
g_return_if_fail (dockable->dockbook != NULL);
|
||||
g_return_if_fail (dockable->dockbook == dockbook);
|
||||
|
||||
if (g_list_length (gtk_container_children (GTK_CONTAINER (dockbook))) == 1)
|
||||
{
|
||||
while (GTK_MENU_SHELL (GTK_NOTEBOOK (dockbook)->menu)->children->next)
|
||||
gtk_widget_destroy (GTK_WIDGET (GTK_MENU_SHELL (GTK_NOTEBOOK (dockbook)->menu)->children->next->data));
|
||||
}
|
||||
|
||||
dockable->dockbook = NULL;
|
||||
|
||||
gtk_container_remove (GTK_CONTAINER (dockbook), GTK_WIDGET (dockable));
|
||||
|
||||
if (! g_list_length (gtk_container_children (GTK_CONTAINER (dockbook))))
|
||||
{
|
||||
gimp_dock_remove_book (dockbook->dock, dockbook);
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_dockbook_tab_button_press (GtkWidget *widget,
|
||||
GdkEventButton *bevent,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDockable *dockable;
|
||||
gint page_num;
|
||||
|
||||
dockable = GIMP_DOCKABLE (data);
|
||||
|
||||
switch (bevent->button)
|
||||
{
|
||||
case 3:
|
||||
gtk_menu_popup (GTK_MENU (GTK_NOTEBOOK (dockable->dockbook)->menu),
|
||||
NULL, NULL,
|
||||
NULL, NULL, 3, bevent->time);
|
||||
break;
|
||||
|
||||
default:
|
||||
page_num = gtk_notebook_page_num (GTK_NOTEBOOK (dockable->dockbook),
|
||||
GTK_WIDGET (dockable));
|
||||
|
||||
gtk_notebook_set_page (GTK_NOTEBOOK (dockable->dockbook), page_num);
|
||||
break;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dockbook_tab_drag_begin (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDockable *dockable;
|
||||
GtkWidget *window;
|
||||
GtkWidget *frame;
|
||||
GtkWidget *preview;
|
||||
|
||||
dockable = GIMP_DOCKABLE (data);
|
||||
|
||||
window = gtk_window_new (GTK_WINDOW_POPUP);
|
||||
|
||||
frame = gtk_frame_new (NULL);
|
||||
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
|
||||
gtk_container_add (GTK_CONTAINER (window), frame);
|
||||
gtk_widget_show (frame);
|
||||
|
||||
preview = gimp_dockable_get_tab_widget (dockable, 24);
|
||||
|
||||
if (! GTK_IS_LABEL (preview))
|
||||
{
|
||||
GtkWidget *hbox;
|
||||
GtkWidget *label;
|
||||
|
||||
hbox = gtk_hbox_new (FALSE, 2);
|
||||
gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
|
||||
|
||||
gtk_box_pack_start (GTK_BOX (hbox), preview, FALSE, FALSE, 0);
|
||||
gtk_widget_show (preview);
|
||||
|
||||
label = gtk_label_new (dockable->name);
|
||||
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
|
||||
gtk_widget_show (label);
|
||||
|
||||
preview = hbox;
|
||||
}
|
||||
else
|
||||
{
|
||||
gtk_widget_destroy (preview);
|
||||
|
||||
preview = gtk_label_new (dockable->name);
|
||||
gtk_misc_set_padding (GTK_MISC (preview), 10, 5);
|
||||
}
|
||||
|
||||
gtk_container_add (GTK_CONTAINER (frame), preview);
|
||||
gtk_widget_show (preview);
|
||||
|
||||
gtk_widget_show (window);
|
||||
|
||||
gtk_object_set_data_full (GTK_OBJECT (dockable), "gimp_dock_drag_widget",
|
||||
window,
|
||||
(GtkDestroyNotify) gtk_widget_destroy);
|
||||
|
||||
gtk_drag_set_icon_widget (context, window,
|
||||
-8, -8);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_dockbook_tab_drag_end (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDockable *dockable;
|
||||
GtkWidget *drag_widget;
|
||||
|
||||
dockable = GIMP_DOCKABLE (data);
|
||||
|
||||
drag_widget = gtk_object_get_data (GTK_OBJECT (dockable),
|
||||
"gimp_dock_drag_widget");
|
||||
|
||||
if (drag_widget)
|
||||
{
|
||||
GtkWidget *dock;
|
||||
GtkWidget *dockbook;
|
||||
|
||||
gtk_object_set_data (GTK_OBJECT (dockable), "gimp_dock_drag_widget", NULL);
|
||||
|
||||
dock = gimp_dock_new ();
|
||||
|
||||
gtk_window_set_position (GTK_WINDOW (dock), GTK_WIN_POS_MOUSE);
|
||||
|
||||
dockbook = gimp_dockbook_new ();
|
||||
|
||||
gimp_dock_add_book (GIMP_DOCK (dock), GIMP_DOCKBOOK (dockbook), 0);
|
||||
|
||||
gtk_object_ref (GTK_OBJECT (dockable));
|
||||
|
||||
gimp_dockbook_remove (dockable->dockbook, dockable);
|
||||
gimp_dockbook_add (GIMP_DOCKBOOK (dockbook), dockable, 0);
|
||||
|
||||
gtk_object_unref (GTK_OBJECT (dockable));
|
||||
|
||||
gtk_widget_show (dock);
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_dockbook_tab_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDockable *dest_dockable;
|
||||
GtkWidget *source;
|
||||
|
||||
dest_dockable = (GimpDockable *) gtk_object_get_data (GTK_OBJECT (widget),
|
||||
"gimp_dockable");
|
||||
|
||||
source = gtk_drag_get_source_widget (context);
|
||||
|
||||
if (source)
|
||||
{
|
||||
GimpDockable *src_dockable;
|
||||
|
||||
src_dockable = (GimpDockable *) gtk_object_get_data (GTK_OBJECT (source),
|
||||
"gimp_dockable");
|
||||
|
||||
if (src_dockable)
|
||||
{
|
||||
gint page_index;
|
||||
|
||||
page_index =
|
||||
gtk_notebook_page_num (GTK_NOTEBOOK (dest_dockable->dockbook),
|
||||
GTK_WIDGET (dest_dockable));
|
||||
|
||||
gtk_object_set_data (GTK_OBJECT (src_dockable),
|
||||
"gimp_dock_drag_widget", NULL);
|
||||
|
||||
if (src_dockable->dockbook != dest_dockable->dockbook)
|
||||
{
|
||||
gtk_object_ref (GTK_OBJECT (src_dockable));
|
||||
|
||||
gimp_dockbook_remove (src_dockable->dockbook, src_dockable);
|
||||
gimp_dockbook_add (dest_dockable->dockbook, src_dockable,
|
||||
page_index);
|
||||
|
||||
gtk_object_unref (GTK_OBJECT (src_dockable));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
else if (src_dockable != dest_dockable)
|
||||
{
|
||||
gtk_notebook_reorder_child (GTK_NOTEBOOK (src_dockable->dockbook),
|
||||
GTK_WIDGET (src_dockable),
|
||||
page_index);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
|
@ -1,61 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimpdockbook.h
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_DOCKBOOK_H__
|
||||
#define __GIMP_DOCKBOOK_H__
|
||||
|
||||
|
||||
#include <gtk/gtknotebook.h>
|
||||
|
||||
|
||||
#define GIMP_TYPE_DOCKBOOK (gimp_dockbook_get_type ())
|
||||
#define GIMP_DOCKBOOK(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DOCKBOOK, GimpDockbook))
|
||||
#define GIMP_DOCKBOOK_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DOCKBOOK, GimpDockbookClass))
|
||||
#define GIMP_IS_DOCKBOOK(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DOCKBOOK))
|
||||
#define GIMP_IS_DOCKBOOK_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DOCKBOOK))
|
||||
|
||||
|
||||
typedef struct _GimpDockbookClass GimpDockbookClass;
|
||||
|
||||
struct _GimpDockbook
|
||||
{
|
||||
GtkNotebook parent_instance;
|
||||
|
||||
GimpDock *dock;
|
||||
};
|
||||
|
||||
struct _GimpDockbookClass
|
||||
{
|
||||
GtkNotebookClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_dockbook_get_type (void);
|
||||
GtkWidget * gimp_dockbook_new (void);
|
||||
|
||||
void gimp_dockbook_add (GimpDockbook *dockbook,
|
||||
GimpDockable *dockable,
|
||||
gint position);
|
||||
void gimp_dockbook_remove (GimpDockbook *dockbook,
|
||||
GimpDockable *dockable);
|
||||
|
||||
|
||||
#endif /* __GIMP_DOCKBOOK_H__ */
|
|
@ -28,10 +28,11 @@
|
|||
|
||||
#include "paint-funcs/paint-funcs.h"
|
||||
|
||||
#include "widgets/gimpdrawablepreview.h"
|
||||
|
||||
#include "gimpchannel.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimpdrawable.h"
|
||||
#include "gimpdrawablepreview.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimppreviewcache.h"
|
||||
#include "pixel_region.h"
|
||||
|
|
|
@ -1,385 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimpdrawablelistitem.c
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpwidgets/gimpwidgets.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "gdisplay.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimpdrawablelistitem.h"
|
||||
#include "gimpdrawablelistview.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimpviewable.h"
|
||||
|
||||
#include "pixmaps/eye.xpm"
|
||||
|
||||
|
||||
static void gimp_drawable_list_item_class_init (GimpDrawableListItemClass *klass);
|
||||
static void gimp_drawable_list_item_init (GimpDrawableListItem *list_item);
|
||||
|
||||
static void gimp_drawable_list_item_set_viewable (GimpListItem *list_item,
|
||||
GimpViewable *viewable);
|
||||
|
||||
static gboolean gimp_drawable_list_item_drag_motion (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time);
|
||||
static gboolean gimp_drawable_list_item_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time);
|
||||
|
||||
static void gimp_drawable_list_item_eye_toggled (GtkWidget *widget,
|
||||
gpointer data);
|
||||
|
||||
static void gimp_drawable_list_item_visibility_changed (GimpDrawable *drawable,
|
||||
gpointer data);
|
||||
static void gimp_drawable_list_item_button_realize (GtkWidget *widget,
|
||||
gpointer data);
|
||||
static void gimp_drawable_list_item_button_state_changed (GtkWidget *widget,
|
||||
GtkStateType previous_state,
|
||||
gpointer data);
|
||||
|
||||
|
||||
static GimpListItemClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_drawable_list_item_get_type (void)
|
||||
{
|
||||
static GtkType list_item_type = 0;
|
||||
|
||||
if (! list_item_type)
|
||||
{
|
||||
static const GtkTypeInfo list_item_info =
|
||||
{
|
||||
"GimpDrawableListItem",
|
||||
sizeof (GimpDrawableListItem),
|
||||
sizeof (GimpDrawableListItemClass),
|
||||
(GtkClassInitFunc) gimp_drawable_list_item_class_init,
|
||||
(GtkObjectInitFunc) gimp_drawable_list_item_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
list_item_type = gtk_type_unique (GIMP_TYPE_LIST_ITEM, &list_item_info);
|
||||
}
|
||||
|
||||
return list_item_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_item_class_init (GimpDrawableListItemClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkWidgetClass *widget_class;
|
||||
GimpListItemClass *list_item_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
widget_class = (GtkWidgetClass *) klass;
|
||||
list_item_class = (GimpListItemClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_LIST_ITEM);
|
||||
|
||||
widget_class->drag_motion = gimp_drawable_list_item_drag_motion;
|
||||
widget_class->drag_drop = gimp_drawable_list_item_drag_drop;
|
||||
|
||||
list_item_class->set_viewable = gimp_drawable_list_item_set_viewable;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_item_init (GimpDrawableListItem *list_item)
|
||||
{
|
||||
GtkWidget *abox;
|
||||
GtkWidget *pixmap;
|
||||
|
||||
abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
|
||||
gtk_box_pack_start (GTK_BOX (GIMP_LIST_ITEM (list_item)->hbox), abox,
|
||||
FALSE, FALSE, 0);
|
||||
gtk_widget_show (abox);
|
||||
|
||||
list_item->eye_button = gtk_toggle_button_new ();
|
||||
gtk_button_set_relief (GTK_BUTTON (list_item->eye_button), GTK_RELIEF_NONE);
|
||||
gtk_container_add (GTK_CONTAINER (abox), list_item->eye_button);
|
||||
gtk_widget_show (list_item->eye_button);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (list_item->eye_button), "realize",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_item_button_realize),
|
||||
list_item);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (list_item->eye_button), "state_changed",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_item_button_state_changed),
|
||||
list_item);
|
||||
|
||||
pixmap = gimp_pixmap_new (eye_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (list_item->eye_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_item_set_viewable (GimpListItem *list_item,
|
||||
GimpViewable *viewable)
|
||||
{
|
||||
GimpDrawableListItem *drawable_item;
|
||||
GimpDrawable *drawable;
|
||||
gboolean visible;
|
||||
|
||||
if (GIMP_LIST_ITEM_CLASS (parent_class)->set_viewable)
|
||||
GIMP_LIST_ITEM_CLASS (parent_class)->set_viewable (list_item, viewable);
|
||||
|
||||
GIMP_PREVIEW (list_item->preview)->clickable = TRUE;
|
||||
|
||||
drawable_item = GIMP_DRAWABLE_LIST_ITEM (list_item);
|
||||
drawable = GIMP_DRAWABLE (GIMP_PREVIEW (list_item->preview)->viewable);
|
||||
visible = gimp_drawable_get_visible (drawable);
|
||||
|
||||
if (! visible)
|
||||
{
|
||||
GtkRequisition requisition;
|
||||
|
||||
gtk_widget_size_request (drawable_item->eye_button, &requisition);
|
||||
|
||||
gtk_widget_set_usize (drawable_item->eye_button,
|
||||
requisition.width,
|
||||
requisition.height);
|
||||
gtk_widget_hide (GTK_BIN (drawable_item->eye_button)->child);
|
||||
}
|
||||
|
||||
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (drawable_item->eye_button),
|
||||
visible);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (drawable_item->eye_button), "toggled",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_item_eye_toggled),
|
||||
list_item);
|
||||
|
||||
gtk_signal_connect_while_alive
|
||||
(GTK_OBJECT (viewable), "visibility_changed",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_item_visibility_changed),
|
||||
list_item,
|
||||
GTK_OBJECT (list_item));
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_drawable_list_item_drag_motion (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
GimpViewable *src_viewable;
|
||||
gint dest_index;
|
||||
GdkDragAction drag_action;
|
||||
GimpDropType drop_type;
|
||||
gboolean return_val;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (widget);
|
||||
|
||||
return_val = gimp_list_item_check_drag (list_item, context, x, y,
|
||||
&src_viewable,
|
||||
&dest_index,
|
||||
&drag_action,
|
||||
&drop_type);
|
||||
|
||||
gdk_drag_status (context, drag_action, time);
|
||||
|
||||
list_item->drop_type = drop_type;
|
||||
|
||||
return return_val;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_drawable_list_item_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
GimpViewable *src_viewable;
|
||||
gint dest_index;
|
||||
GdkDragAction drag_action;
|
||||
GimpDropType drop_type;
|
||||
gboolean return_val;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (widget);
|
||||
|
||||
return_val = gimp_list_item_check_drag (list_item, context, x, y,
|
||||
&src_viewable,
|
||||
&dest_index,
|
||||
&drag_action,
|
||||
&drop_type);
|
||||
|
||||
gtk_drag_finish (context, return_val, FALSE, time);
|
||||
|
||||
list_item->drop_type = GIMP_DROP_NONE;
|
||||
|
||||
if (return_val)
|
||||
{
|
||||
if (widget->parent && GIMP_IS_DRAWABLE_LIST_VIEW (widget->parent))
|
||||
{
|
||||
GimpDrawableListView *list_view;
|
||||
|
||||
list_view = GIMP_DRAWABLE_LIST_VIEW (widget->parent);
|
||||
|
||||
list_view->reorder_drawable_func (list_view->gimage,
|
||||
GIMP_DRAWABLE (src_viewable),
|
||||
dest_index,
|
||||
TRUE);
|
||||
|
||||
gdisplays_flush ();
|
||||
}
|
||||
else
|
||||
{
|
||||
g_warning ("%s(): GimpDrawableListItem is not "
|
||||
"part of a GimpDrawableListView", G_GNUC_FUNCTION);
|
||||
}
|
||||
}
|
||||
|
||||
return return_val;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_item_eye_toggled (GtkWidget *widget,
|
||||
gpointer data)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
GimpDrawable *drawable;
|
||||
gboolean visible;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (data);
|
||||
drawable = GIMP_DRAWABLE (GIMP_PREVIEW (list_item->preview)->viewable);
|
||||
visible = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
|
||||
|
||||
if (visible != gimp_drawable_get_visible (drawable))
|
||||
{
|
||||
if (! visible)
|
||||
{
|
||||
gtk_widget_set_usize (GTK_WIDGET (widget),
|
||||
GTK_WIDGET (widget)->allocation.width,
|
||||
GTK_WIDGET (widget)->allocation.height);
|
||||
gtk_widget_hide (GTK_BIN (widget)->child);
|
||||
}
|
||||
else
|
||||
{
|
||||
gtk_widget_show (GTK_BIN (widget)->child);
|
||||
gtk_widget_set_usize (GTK_WIDGET (widget), -1, -1);
|
||||
}
|
||||
|
||||
gtk_signal_handler_block_by_func (GTK_OBJECT (drawable),
|
||||
gimp_drawable_list_item_visibility_changed,
|
||||
list_item);
|
||||
|
||||
gimp_drawable_set_visible (drawable, visible);
|
||||
|
||||
gtk_signal_handler_unblock_by_func (GTK_OBJECT (drawable),
|
||||
gimp_drawable_list_item_visibility_changed,
|
||||
list_item);
|
||||
|
||||
drawable_update (drawable, 0, 0,
|
||||
drawable->width,
|
||||
drawable->height);
|
||||
|
||||
gdisplays_flush ();
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_item_visibility_changed (GimpDrawable *drawable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
GtkToggleButton *toggle;
|
||||
gboolean visible;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (data);
|
||||
toggle = GTK_TOGGLE_BUTTON (GIMP_DRAWABLE_LIST_ITEM (data)->eye_button);
|
||||
visible = gimp_drawable_get_visible (drawable);
|
||||
|
||||
if (visible != toggle->active)
|
||||
{
|
||||
if (! visible)
|
||||
{
|
||||
gtk_widget_set_usize (GTK_WIDGET (toggle),
|
||||
GTK_WIDGET (toggle)->allocation.width,
|
||||
GTK_WIDGET (toggle)->allocation.height);
|
||||
gtk_widget_hide (GTK_BIN (toggle)->child);
|
||||
}
|
||||
else
|
||||
{
|
||||
gtk_widget_show (GTK_BIN (toggle)->child);
|
||||
gtk_widget_set_usize (GTK_WIDGET (toggle), -1, -1);
|
||||
}
|
||||
|
||||
gtk_signal_handler_block_by_func (GTK_OBJECT (toggle),
|
||||
gimp_drawable_list_item_eye_toggled,
|
||||
list_item);
|
||||
|
||||
gtk_toggle_button_set_active (toggle, visible);
|
||||
|
||||
gtk_signal_handler_unblock_by_func (GTK_OBJECT (toggle),
|
||||
gimp_drawable_list_item_eye_toggled,
|
||||
list_item);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_item_button_realize (GtkWidget *widget,
|
||||
gpointer data)
|
||||
{
|
||||
gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_item_button_state_changed (GtkWidget *widget,
|
||||
GtkStateType previous_state,
|
||||
gpointer data)
|
||||
{
|
||||
GtkWidget *list_item;
|
||||
|
||||
list_item = GTK_WIDGET (data);
|
||||
|
||||
if (widget->state != list_item->state)
|
||||
{
|
||||
switch (widget->state)
|
||||
{
|
||||
case GTK_STATE_NORMAL:
|
||||
case GTK_STATE_ACTIVE:
|
||||
/* beware: recursion */
|
||||
gtk_widget_set_state (widget, list_item->state);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
|
@ -1,64 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimpdrawablelistitem.h
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_DRAWABLE_LIST_ITEM_H__
|
||||
#define __GIMP_DRAWABLE_LIST_ITEM_H__
|
||||
|
||||
|
||||
#include "gimplistitem.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_DRAWABLE_LIST_ITEM (gimp_drawable_list_item_get_type ())
|
||||
#define GIMP_DRAWABLE_LIST_ITEM(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DRAWABLE_LIST_ITEM, GimpDrawableListItem))
|
||||
#define GIMP_DRAWABLE_LIST_ITEM_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DRAWABLE_LIST_ITEM, GimpDrawableListItemClass))
|
||||
#define GIMP_IS_DRAWABLE_LIST_ITEM(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DRAWABLE_LIST_ITEM))
|
||||
#define GIMP_IS_DRAWABLE_LIST_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DRAWABLE_LIST_ITEM))
|
||||
|
||||
|
||||
typedef struct _GimpDrawableListItemClass GimpDrawableListItemClass;
|
||||
|
||||
struct _GimpDrawableListItem
|
||||
{
|
||||
GimpListItem parent_instance;
|
||||
|
||||
GtkWidget *eye_button;
|
||||
};
|
||||
|
||||
struct _GimpDrawableListItemClass
|
||||
{
|
||||
GimpListItemClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_drawable_list_item_get_type (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#endif /* __GIMP_DRAWABLE_LIST_ITEM_H__ */
|
|
@ -1,731 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpmath/gimpmath.h"
|
||||
#include "libgimpwidgets/gimpwidgets.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gdisplay.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpdrawable.h"
|
||||
#include "gimpdrawablelistview.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimplayerlistview.h"
|
||||
#include "gimplistitem.h"
|
||||
#include "gimpmarshal.h"
|
||||
#include "gimprc.h"
|
||||
#include "gimpviewable.h"
|
||||
|
||||
#include "libgimp/gimpintl.h"
|
||||
|
||||
#include "pixmaps/delete.xpm"
|
||||
#include "pixmaps/raise.xpm"
|
||||
#include "pixmaps/lower.xpm"
|
||||
#include "pixmaps/duplicate.xpm"
|
||||
#include "pixmaps/new.xpm"
|
||||
#include "pixmaps/edit.xpm"
|
||||
|
||||
|
||||
static void gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass);
|
||||
static void gimp_drawable_list_view_init (GimpDrawableListView *view);
|
||||
static void gimp_drawable_list_view_destroy (GtkObject *object);
|
||||
|
||||
static gpointer gimp_drawable_list_view_insert_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint index);
|
||||
static void gimp_drawable_list_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *item,
|
||||
gpointer insert_data);
|
||||
static void gimp_drawable_list_view_activate_item (GimpContainerView *view,
|
||||
GimpViewable *item,
|
||||
gpointer insert_data);
|
||||
|
||||
static void gimp_drawable_list_view_new_drawable (GimpDrawableListView *view,
|
||||
GimpDrawable *drawable);
|
||||
static void gimp_drawable_list_view_new_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view);
|
||||
static void gimp_drawable_list_view_new_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data);
|
||||
|
||||
static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view);
|
||||
static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view);
|
||||
|
||||
static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view,
|
||||
GimpDrawable *drawable);
|
||||
static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view);
|
||||
static void gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer drawable);
|
||||
|
||||
static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view,
|
||||
GimpDrawable *drawable);
|
||||
static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view);
|
||||
static void gimp_drawable_list_view_edit_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer drawable);
|
||||
|
||||
static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view,
|
||||
GimpDrawable *drawable);
|
||||
static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view);
|
||||
static void gimp_drawable_list_view_delete_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer drawable);
|
||||
|
||||
static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage,
|
||||
GimpDrawableListView *view);
|
||||
|
||||
|
||||
static GimpContainerListViewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_drawable_list_view_get_type (void)
|
||||
{
|
||||
static guint view_type = 0;
|
||||
|
||||
if (! view_type)
|
||||
{
|
||||
GtkTypeInfo view_info =
|
||||
{
|
||||
"GimpDrawableListView",
|
||||
sizeof (GimpDrawableListView),
|
||||
sizeof (GimpDrawableListViewClass),
|
||||
(GtkClassInitFunc) gimp_drawable_list_view_class_init,
|
||||
(GtkObjectInitFunc) gimp_drawable_list_view_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
view_type = gtk_type_unique (GIMP_TYPE_CONTAINER_LIST_VIEW, &view_info);
|
||||
}
|
||||
|
||||
return view_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpContainerViewClass *container_view_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
container_view_class = (GimpContainerViewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_CONTAINER_LIST_VIEW);
|
||||
|
||||
object_class->destroy = gimp_drawable_list_view_destroy;
|
||||
|
||||
container_view_class->insert_item = gimp_drawable_list_view_insert_item;
|
||||
container_view_class->select_item = gimp_drawable_list_view_select_item;
|
||||
container_view_class->activate_item = gimp_drawable_list_view_activate_item;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_init (GimpDrawableListView *view)
|
||||
{
|
||||
GtkWidget *pixmap;
|
||||
|
||||
view->gimage = NULL;
|
||||
view->drawable_type = GTK_TYPE_NONE;
|
||||
view->signal_name = NULL;
|
||||
|
||||
gtk_box_set_spacing (GTK_BOX (view), 2);
|
||||
|
||||
view->button_box = gtk_hbox_new (TRUE, 2);
|
||||
gtk_box_pack_end (GTK_BOX (view), view->button_box, FALSE, FALSE, 0);
|
||||
gtk_widget_show (view->button_box);
|
||||
|
||||
/* new */
|
||||
|
||||
view->new_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->new_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->new_button);
|
||||
|
||||
gimp_help_set_help_data (view->new_button, _("New"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->new_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_view_new_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (new_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->new_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
/* raise */
|
||||
|
||||
view->raise_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->raise_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->raise_button);
|
||||
|
||||
gimp_help_set_help_data (view->raise_button, _("Raise"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->raise_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_view_raise_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (raise_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->raise_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
/* lower */
|
||||
|
||||
view->lower_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->lower_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->lower_button);
|
||||
|
||||
gimp_help_set_help_data (view->lower_button, _("Lower"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->lower_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_view_lower_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (lower_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->lower_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
/* duplicate */
|
||||
|
||||
view->duplicate_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->duplicate_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->duplicate_button);
|
||||
|
||||
gimp_help_set_help_data (view->duplicate_button, _("Duplicate"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->duplicate_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_view_duplicate_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (duplicate_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->duplicate_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
/* edit */
|
||||
|
||||
view->edit_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->edit_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->edit_button);
|
||||
|
||||
gimp_help_set_help_data (view->edit_button, _("Edit"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->edit_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_view_edit_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (edit_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->edit_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
/* delete */
|
||||
|
||||
view->delete_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (view->button_box), view->delete_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (view->delete_button);
|
||||
|
||||
gimp_help_set_help_data (view->delete_button, _("Delete"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->delete_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_view_delete_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (delete_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->delete_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
gtk_widget_set_sensitive (view->new_button, FALSE);
|
||||
gtk_widget_set_sensitive (view->raise_button, FALSE);
|
||||
gtk_widget_set_sensitive (view->lower_button, FALSE);
|
||||
gtk_widget_set_sensitive (view->duplicate_button, FALSE);
|
||||
gtk_widget_set_sensitive (view->edit_button, FALSE);
|
||||
gtk_widget_set_sensitive (view->delete_button, FALSE);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_destroy (GtkObject *object)
|
||||
{
|
||||
GimpDrawableListView *view;
|
||||
|
||||
view = GIMP_DRAWABLE_LIST_VIEW (object);
|
||||
|
||||
g_free (view->signal_name);
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_drawable_list_view_new (GimpImage *gimage,
|
||||
GtkType drawable_type,
|
||||
const gchar *signal_name,
|
||||
GimpGetContainerFunc get_container_func,
|
||||
GimpGetDrawableFunc get_drawable_func,
|
||||
GimpSetDrawableFunc set_drawable_func,
|
||||
GimpReorderDrawableFunc reorder_drawable_func,
|
||||
GimpAddDrawableFunc add_drawable_func,
|
||||
GimpRemoveDrawableFunc remove_drawable_func,
|
||||
GimpCopyDrawableFunc copy_drawable_func)
|
||||
{
|
||||
GimpDrawableListView *list_view;
|
||||
GimpContainerView *view;
|
||||
|
||||
g_return_val_if_fail (! gimage || GIMP_IS_IMAGE (gimage), NULL);
|
||||
g_return_val_if_fail (signal_name != NULL, NULL);
|
||||
g_return_val_if_fail (get_container_func != NULL, NULL);
|
||||
g_return_val_if_fail (get_drawable_func != NULL, NULL);
|
||||
g_return_val_if_fail (get_drawable_func != NULL, NULL);
|
||||
g_return_val_if_fail (reorder_drawable_func != NULL, NULL);
|
||||
g_return_val_if_fail (add_drawable_func != NULL, NULL);
|
||||
g_return_val_if_fail (remove_drawable_func != NULL, NULL);
|
||||
g_return_val_if_fail (copy_drawable_func != NULL, NULL);
|
||||
|
||||
if (drawable_type == GIMP_TYPE_LAYER)
|
||||
{
|
||||
list_view = gtk_type_new (GIMP_TYPE_LAYER_LIST_VIEW);
|
||||
}
|
||||
else
|
||||
{
|
||||
list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW);
|
||||
}
|
||||
|
||||
view = GIMP_CONTAINER_VIEW (list_view);
|
||||
|
||||
view->preview_size = preview_size;
|
||||
|
||||
list_view->drawable_type = drawable_type;
|
||||
list_view->signal_name = g_strdup (signal_name);
|
||||
list_view->get_container_func = get_container_func;
|
||||
list_view->get_drawable_func = get_drawable_func;
|
||||
list_view->set_drawable_func = set_drawable_func;
|
||||
list_view->reorder_drawable_func = reorder_drawable_func;
|
||||
list_view->add_drawable_func = add_drawable_func;
|
||||
list_view->remove_drawable_func = remove_drawable_func;
|
||||
list_view->copy_drawable_func = copy_drawable_func;
|
||||
|
||||
/* drop to "new" */
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (list_view->new_button),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
drawable_type,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (list_view->new_button),
|
||||
drawable_type,
|
||||
gimp_drawable_list_view_new_dropped,
|
||||
list_view);
|
||||
|
||||
/* drop to "duplicate" */
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (list_view->duplicate_button),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
drawable_type,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (list_view->duplicate_button),
|
||||
drawable_type,
|
||||
gimp_drawable_list_view_duplicate_dropped,
|
||||
list_view);
|
||||
|
||||
/* drop to "edit" */
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (list_view->edit_button),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
drawable_type,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (list_view->edit_button),
|
||||
drawable_type,
|
||||
gimp_drawable_list_view_edit_dropped,
|
||||
list_view);
|
||||
|
||||
/* drop to "delete" */
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (list_view->delete_button),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
drawable_type,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (list_view->delete_button),
|
||||
drawable_type,
|
||||
gimp_drawable_list_view_delete_dropped,
|
||||
list_view);
|
||||
|
||||
if (gimage)
|
||||
gimp_drawable_list_view_set_image (list_view, gimage);
|
||||
|
||||
return GTK_WIDGET (list_view);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_drawable_list_view_set_image (GimpDrawableListView *view,
|
||||
GimpImage *gimage)
|
||||
{
|
||||
g_return_if_fail (view != NULL);
|
||||
g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (view));
|
||||
g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage));
|
||||
|
||||
if (view->gimage == gimage)
|
||||
return;
|
||||
|
||||
if (view->gimage)
|
||||
{
|
||||
gtk_signal_disconnect_by_func (GTK_OBJECT (view->gimage),
|
||||
gimp_drawable_list_view_drawable_changed,
|
||||
view);
|
||||
|
||||
gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), NULL);
|
||||
}
|
||||
|
||||
view->gimage = gimage;
|
||||
|
||||
if (view->gimage)
|
||||
{
|
||||
GimpContainer *container;
|
||||
|
||||
container = view->get_container_func (view->gimage);
|
||||
|
||||
gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), container);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->gimage), view->signal_name,
|
||||
GTK_SIGNAL_FUNC (gimp_drawable_list_view_drawable_changed),
|
||||
view);
|
||||
|
||||
gimp_drawable_list_view_drawable_changed (view->gimage, view);
|
||||
}
|
||||
|
||||
gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL));
|
||||
}
|
||||
|
||||
|
||||
/* GimpContainerView methods */
|
||||
|
||||
static gpointer
|
||||
gimp_drawable_list_view_insert_item (GimpContainerView *view,
|
||||
GimpViewable *viewable,
|
||||
gint index)
|
||||
{
|
||||
gpointer list_item = NULL;
|
||||
|
||||
if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item)
|
||||
list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view,
|
||||
viewable,
|
||||
index);
|
||||
|
||||
if (list_item)
|
||||
gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item),
|
||||
TRUE, view->container);
|
||||
|
||||
return list_item;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *item,
|
||||
gpointer insert_data)
|
||||
{
|
||||
GimpDrawableListView *list_view;
|
||||
gboolean raise_sensitive = FALSE;
|
||||
gboolean lower_sensitive = FALSE;
|
||||
gboolean duplicate_sensitive = FALSE;
|
||||
gboolean edit_sensitive = FALSE;
|
||||
gboolean delete_sensitive = FALSE;
|
||||
|
||||
list_view = GIMP_DRAWABLE_LIST_VIEW (view);
|
||||
|
||||
if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item)
|
||||
GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view,
|
||||
item,
|
||||
insert_data);
|
||||
|
||||
if (item)
|
||||
{
|
||||
GimpDrawable *drawable;
|
||||
gint index;
|
||||
|
||||
drawable = list_view->get_drawable_func (list_view->gimage);
|
||||
|
||||
if (drawable != GIMP_DRAWABLE (item))
|
||||
{
|
||||
list_view->set_drawable_func (list_view->gimage,
|
||||
GIMP_DRAWABLE (item));
|
||||
|
||||
gdisplays_flush ();
|
||||
}
|
||||
|
||||
index = gimp_container_get_child_index (view->container,
|
||||
GIMP_OBJECT (item));
|
||||
|
||||
if (view->container->num_children > 1)
|
||||
{
|
||||
if (index > 0)
|
||||
raise_sensitive = TRUE;
|
||||
|
||||
if (index < (view->container->num_children - 1))
|
||||
lower_sensitive = TRUE;
|
||||
}
|
||||
|
||||
duplicate_sensitive = TRUE;
|
||||
edit_sensitive = TRUE;
|
||||
delete_sensitive = TRUE;
|
||||
}
|
||||
|
||||
gtk_widget_set_sensitive (list_view->raise_button, raise_sensitive);
|
||||
gtk_widget_set_sensitive (list_view->lower_button, lower_sensitive);
|
||||
gtk_widget_set_sensitive (list_view->duplicate_button, duplicate_sensitive);
|
||||
gtk_widget_set_sensitive (list_view->edit_button, edit_sensitive);
|
||||
gtk_widget_set_sensitive (list_view->delete_button, delete_sensitive);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_activate_item (GimpContainerView *view,
|
||||
GimpViewable *item,
|
||||
gpointer insert_data)
|
||||
{
|
||||
if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item)
|
||||
GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item (view,
|
||||
item,
|
||||
insert_data);
|
||||
|
||||
gimp_drawable_list_view_edit_drawable (GIMP_DRAWABLE_LIST_VIEW (view),
|
||||
GIMP_DRAWABLE (item));
|
||||
}
|
||||
|
||||
|
||||
/* "New" functions */
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_new_drawable (GimpDrawableListView *view,
|
||||
GimpDrawable *drawable)
|
||||
{
|
||||
if (drawable)
|
||||
g_print ("new with \"%s\"'s properties\n", GIMP_OBJECT (drawable)->name);
|
||||
else
|
||||
g_print ("new default\n");
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_new_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view)
|
||||
{
|
||||
gimp_drawable_list_view_new_drawable (view, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_new_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDrawableListView *view;
|
||||
|
||||
view = (GimpDrawableListView *) data;
|
||||
|
||||
if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container,
|
||||
GIMP_OBJECT (viewable)))
|
||||
{
|
||||
gimp_drawable_list_view_new_drawable (view, GIMP_DRAWABLE (viewable));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* "Duplicate" functions */
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view,
|
||||
GimpDrawable *drawable)
|
||||
{
|
||||
GimpDrawable *new_drawable;
|
||||
|
||||
new_drawable = view->copy_drawable_func (drawable, TRUE);
|
||||
view->add_drawable_func (view->gimage, new_drawable, -1);
|
||||
|
||||
gdisplays_flush ();
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view)
|
||||
{
|
||||
GimpDrawable *drawable;
|
||||
|
||||
drawable = view->get_drawable_func (view->gimage);
|
||||
|
||||
gimp_drawable_list_view_duplicate_drawable (view, drawable);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDrawableListView *view;
|
||||
|
||||
view = (GimpDrawableListView *) data;
|
||||
|
||||
if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container,
|
||||
GIMP_OBJECT (viewable)))
|
||||
{
|
||||
gimp_drawable_list_view_duplicate_drawable (view,
|
||||
GIMP_DRAWABLE (viewable));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* "Raise/Lower" functions */
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_raise_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view)
|
||||
{
|
||||
GimpContainer *container;
|
||||
GimpDrawable *drawable;
|
||||
gint index;
|
||||
|
||||
container = GIMP_CONTAINER_VIEW (view)->container;
|
||||
drawable = view->get_drawable_func (view->gimage);
|
||||
|
||||
index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable));
|
||||
|
||||
if (index > 0)
|
||||
{
|
||||
view->reorder_drawable_func (view->gimage, drawable, index - 1, TRUE);
|
||||
|
||||
gdisplays_flush ();
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_lower_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view)
|
||||
{
|
||||
GimpContainer *container;
|
||||
GimpDrawable *drawable;
|
||||
gint index;
|
||||
|
||||
container = GIMP_CONTAINER_VIEW (view)->container;
|
||||
drawable = view->get_drawable_func (view->gimage);
|
||||
|
||||
index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable));
|
||||
|
||||
if (index < container->num_children - 1)
|
||||
{
|
||||
view->reorder_drawable_func (view->gimage, drawable, index + 1, TRUE);
|
||||
|
||||
gdisplays_flush ();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* "Edit" functions */
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view,
|
||||
GimpDrawable *drawable)
|
||||
{
|
||||
g_print ("edit \"%s\"\n", GIMP_OBJECT (drawable)->name);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_edit_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view)
|
||||
{
|
||||
GimpDrawable *drawable;
|
||||
|
||||
drawable = view->get_drawable_func (view->gimage);
|
||||
|
||||
gimp_drawable_list_view_edit_drawable (view, drawable);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_edit_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDrawableListView *view;
|
||||
|
||||
view = (GimpDrawableListView *) data;
|
||||
|
||||
if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container,
|
||||
GIMP_OBJECT (viewable)))
|
||||
{
|
||||
gimp_drawable_list_view_edit_drawable (view, GIMP_DRAWABLE (viewable));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* "Delete" functions */
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view,
|
||||
GimpDrawable *drawable)
|
||||
{
|
||||
view->remove_drawable_func (view->gimage, drawable);
|
||||
|
||||
gdisplays_flush ();
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_delete_clicked (GtkWidget *widget,
|
||||
GimpDrawableListView *view)
|
||||
{
|
||||
GimpDrawable *drawable;
|
||||
|
||||
drawable = view->get_drawable_func (view->gimage);
|
||||
|
||||
gimp_drawable_list_view_delete_drawable (view, drawable);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_delete_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpDrawableListView *view;
|
||||
|
||||
view = (GimpDrawableListView *) data;
|
||||
|
||||
if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container,
|
||||
GIMP_OBJECT (viewable)))
|
||||
{
|
||||
gimp_drawable_list_view_delete_drawable (view, GIMP_DRAWABLE (viewable));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* GimpImage callbacks */
|
||||
|
||||
static void
|
||||
gimp_drawable_list_view_drawable_changed (GimpImage *gimage,
|
||||
GimpDrawableListView *view)
|
||||
{
|
||||
GimpDrawable *drawable;
|
||||
|
||||
drawable = view->get_drawable_func (gimage);
|
||||
|
||||
gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view),
|
||||
(GimpViewable *) drawable);
|
||||
}
|
|
@ -1,102 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_DRAWABLE_LIST_VIEW_H__
|
||||
#define __GIMP_DRAWABLE_LIST_VIEW_H__
|
||||
|
||||
|
||||
#include "gimpcontainerlistview.h"
|
||||
|
||||
|
||||
typedef GimpContainer * (* GimpGetContainerFunc) (const GimpImage *gimage);
|
||||
typedef GimpDrawable * (* GimpGetDrawableFunc) (const GimpImage *gimage);
|
||||
typedef void (* GimpSetDrawableFunc) (GimpImage *gimage,
|
||||
GimpDrawable *drawable);
|
||||
typedef void (* GimpReorderDrawableFunc) (GimpImage *gimage,
|
||||
GimpDrawable *drawable,
|
||||
gint new_index,
|
||||
gboolean push_undo);
|
||||
typedef void (* GimpAddDrawableFunc) (GimpImage *gimage,
|
||||
GimpDrawable *drawable,
|
||||
gint index);
|
||||
typedef void (* GimpRemoveDrawableFunc) (GimpImage *gimage,
|
||||
GimpDrawable *drawable);
|
||||
typedef GimpDrawable * (* GimpCopyDrawableFunc) (GimpDrawable *drawable,
|
||||
gboolean add_alpha);
|
||||
|
||||
|
||||
#define GIMP_TYPE_DRAWABLE_LIST_VIEW (gimp_drawable_list_view_get_type ())
|
||||
#define GIMP_DRAWABLE_LIST_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DRAWABLE_LIST_VIEW, GimpDrawableListView))
|
||||
#define GIMP_DRAWABLE_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DRAWABLE_LIST_VIEW, GimpDrawableListViewClass))
|
||||
#define GIMP_IS_DRAWABLE_LIST_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DRAWABLE_LIST_VIEW))
|
||||
#define GIMP_IS_DRAWABLE_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DRAWABLE_LIST_VIEW))
|
||||
|
||||
|
||||
typedef struct _GimpDrawableListViewClass GimpDrawableListViewClass;
|
||||
|
||||
struct _GimpDrawableListView
|
||||
{
|
||||
GimpContainerListView parent_instance;
|
||||
|
||||
GimpImage *gimage;
|
||||
|
||||
GtkType drawable_type;
|
||||
gchar *signal_name;
|
||||
|
||||
GimpGetContainerFunc get_container_func;
|
||||
GimpGetDrawableFunc get_drawable_func;
|
||||
GimpSetDrawableFunc set_drawable_func;
|
||||
GimpReorderDrawableFunc reorder_drawable_func;
|
||||
GimpAddDrawableFunc add_drawable_func;
|
||||
GimpRemoveDrawableFunc remove_drawable_func;
|
||||
GimpCopyDrawableFunc copy_drawable_func;
|
||||
|
||||
GtkWidget *button_box;
|
||||
|
||||
GtkWidget *new_button;
|
||||
GtkWidget *raise_button;
|
||||
GtkWidget *lower_button;
|
||||
GtkWidget *duplicate_button;
|
||||
GtkWidget *edit_button;
|
||||
GtkWidget *delete_button;
|
||||
};
|
||||
|
||||
struct _GimpDrawableListViewClass
|
||||
{
|
||||
GimpContainerListViewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_drawable_list_view_get_type (void);
|
||||
|
||||
GtkWidget * gimp_drawable_list_view_new (GimpImage *gimage,
|
||||
GtkType drawable_type,
|
||||
const gchar *signal_name,
|
||||
GimpGetContainerFunc get_container_func,
|
||||
GimpGetDrawableFunc get_drawable_func,
|
||||
GimpSetDrawableFunc set_drawable_func,
|
||||
GimpReorderDrawableFunc reorder_drawable_func,
|
||||
GimpAddDrawableFunc add_drawable_func,
|
||||
GimpRemoveDrawableFunc remove_drawable_func,
|
||||
GimpCopyDrawableFunc copy_drawable_func);
|
||||
|
||||
void gimp_drawable_list_view_set_image (GimpDrawableListView *view,
|
||||
GimpImage *gimage);
|
||||
|
||||
|
||||
#endif /* __GIMP_DRAWABLE_LIST_VIEW_H__ */
|
|
@ -1,321 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpDrawablePreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpmath/gimpmath.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpdrawable.h"
|
||||
#include "gimpdrawablepreview.h"
|
||||
#include "gimpimage.h"
|
||||
#include "temp_buf.h"
|
||||
|
||||
|
||||
static void gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass);
|
||||
static void gimp_drawable_preview_init (GimpDrawablePreview *preview);
|
||||
|
||||
static void gimp_drawable_preview_render (GimpPreview *preview);
|
||||
static void gimp_drawable_preview_get_size (GimpPreview *preview,
|
||||
gint size,
|
||||
gint *width,
|
||||
gint *height);
|
||||
static GtkWidget * gimp_drawable_preview_create_popup (GimpPreview *preview);
|
||||
static void gimp_drawable_preview_calc_size (gint drawable_width,
|
||||
gint drawable_height,
|
||||
gint width,
|
||||
gint height,
|
||||
gint *return_width,
|
||||
gint *return_height,
|
||||
gboolean *scaling_up);
|
||||
|
||||
|
||||
static GimpPreviewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_drawable_preview_get_type (void)
|
||||
{
|
||||
static GtkType preview_type = 0;
|
||||
|
||||
if (! preview_type)
|
||||
{
|
||||
GtkTypeInfo preview_info =
|
||||
{
|
||||
"GimpDrawablePreview",
|
||||
sizeof (GimpDrawablePreview),
|
||||
sizeof (GimpDrawablePreviewClass),
|
||||
(GtkClassInitFunc) gimp_drawable_preview_class_init,
|
||||
(GtkObjectInitFunc) gimp_drawable_preview_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
preview_type = gtk_type_unique (GIMP_TYPE_PREVIEW, &preview_info);
|
||||
}
|
||||
|
||||
return preview_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpPreviewClass *preview_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
preview_class = (GimpPreviewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_PREVIEW);
|
||||
|
||||
preview_class->render = gimp_drawable_preview_render;
|
||||
preview_class->get_size = gimp_drawable_preview_get_size;
|
||||
preview_class->create_popup = gimp_drawable_preview_create_popup;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_preview_init (GimpDrawablePreview *preview)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_preview_get_size (GimpPreview *preview,
|
||||
gint size,
|
||||
gint *width,
|
||||
gint *height)
|
||||
{
|
||||
GimpDrawable *drawable;
|
||||
GimpImage *gimage;
|
||||
gboolean scaling_up;
|
||||
|
||||
drawable = GIMP_DRAWABLE (preview->viewable);
|
||||
gimage = drawable->gimage;
|
||||
|
||||
if (gimage)
|
||||
{
|
||||
gimp_drawable_preview_calc_size (gimage->width,
|
||||
gimage->height,
|
||||
size,
|
||||
size,
|
||||
width,
|
||||
height,
|
||||
&scaling_up);
|
||||
}
|
||||
else
|
||||
{
|
||||
gimp_drawable_preview_calc_size (drawable->width,
|
||||
drawable->height,
|
||||
size,
|
||||
size,
|
||||
width,
|
||||
height,
|
||||
&scaling_up);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_preview_render (GimpPreview *preview)
|
||||
{
|
||||
GimpDrawable *drawable;
|
||||
GimpImage *gimage;
|
||||
gint width;
|
||||
gint height;
|
||||
gint preview_width;
|
||||
gint preview_height;
|
||||
gboolean scaling_up;
|
||||
TempBuf *render_buf;
|
||||
|
||||
drawable = GIMP_DRAWABLE (preview->viewable);
|
||||
gimage = drawable->gimage;
|
||||
|
||||
width = preview->width;
|
||||
height = preview->height;
|
||||
|
||||
if (gimage && ! preview->is_popup)
|
||||
{
|
||||
width = MAX (1, ROUND ((((gdouble) width / (gdouble) gimage->width) *
|
||||
(gdouble) drawable->width)));
|
||||
height = MAX (1, ROUND ((((gdouble) height / (gdouble) gimage->height) *
|
||||
(gdouble) drawable->height)));
|
||||
|
||||
gimp_drawable_preview_calc_size (drawable->width,
|
||||
drawable->height,
|
||||
width,
|
||||
height,
|
||||
&preview_width,
|
||||
&preview_height,
|
||||
&scaling_up);
|
||||
}
|
||||
else
|
||||
{
|
||||
gimp_drawable_preview_calc_size (drawable->width,
|
||||
drawable->height,
|
||||
width,
|
||||
height,
|
||||
&preview_width,
|
||||
&preview_height,
|
||||
&scaling_up);
|
||||
}
|
||||
|
||||
if (scaling_up)
|
||||
{
|
||||
TempBuf *temp_buf;
|
||||
|
||||
temp_buf = gimp_viewable_get_new_preview (preview->viewable,
|
||||
drawable->width,
|
||||
drawable->height);
|
||||
render_buf = temp_buf_scale (temp_buf, preview_width, preview_height);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
}
|
||||
else
|
||||
{
|
||||
render_buf = gimp_viewable_get_new_preview (preview->viewable,
|
||||
preview_width,
|
||||
preview_height);
|
||||
}
|
||||
|
||||
if (gimage && ! preview->is_popup)
|
||||
{
|
||||
if (preview_width < preview->width)
|
||||
render_buf->x =
|
||||
ROUND ((((gdouble) preview->width / (gdouble) gimage->width) *
|
||||
(gdouble) drawable->offset_x));
|
||||
|
||||
if (preview_height < preview->height)
|
||||
render_buf->y =
|
||||
ROUND ((((gdouble) preview->height / (gdouble) gimage->height) *
|
||||
(gdouble) drawable->offset_y));
|
||||
}
|
||||
else
|
||||
{
|
||||
if (preview_width < width)
|
||||
render_buf->x = (width - preview_width) / 2;
|
||||
|
||||
if (preview_height < height)
|
||||
render_buf->y = (height - preview_height) / 2;
|
||||
}
|
||||
|
||||
if (! gimage && (render_buf->x || render_buf->y))
|
||||
{
|
||||
TempBuf *temp_buf;
|
||||
guchar white[4] = { 0, 0, 0, 0 };
|
||||
|
||||
temp_buf = temp_buf_new (width, height,
|
||||
render_buf->bytes,
|
||||
0, 0,
|
||||
white);
|
||||
|
||||
temp_buf_copy_area (render_buf, temp_buf,
|
||||
0, 0,
|
||||
render_buf->width,
|
||||
render_buf->height,
|
||||
render_buf->x,
|
||||
render_buf->y);
|
||||
|
||||
temp_buf_free (render_buf);
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
temp_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
render_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (render_buf);
|
||||
}
|
||||
|
||||
static GtkWidget *
|
||||
gimp_drawable_preview_create_popup (GimpPreview *preview)
|
||||
{
|
||||
GimpDrawable *drawable;
|
||||
gint popup_width;
|
||||
gint popup_height;
|
||||
gboolean scaling_up;
|
||||
|
||||
drawable = GIMP_DRAWABLE (preview->viewable);
|
||||
|
||||
gimp_drawable_preview_calc_size (drawable->width,
|
||||
drawable->height,
|
||||
MIN (preview->width * 2, 256),
|
||||
MIN (preview->height * 2, 256),
|
||||
&popup_width,
|
||||
&popup_height,
|
||||
&scaling_up);
|
||||
|
||||
if (scaling_up)
|
||||
{
|
||||
return gimp_preview_new_full (preview->viewable,
|
||||
drawable->width,
|
||||
drawable->height,
|
||||
0,
|
||||
TRUE, FALSE, FALSE);
|
||||
}
|
||||
else
|
||||
{
|
||||
return gimp_preview_new_full (preview->viewable,
|
||||
popup_width,
|
||||
popup_height,
|
||||
0,
|
||||
TRUE, FALSE, FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_drawable_preview_calc_size (gint drawable_width,
|
||||
gint drawable_height,
|
||||
gint width,
|
||||
gint height,
|
||||
gint *return_width,
|
||||
gint *return_height,
|
||||
gboolean *scaling_up)
|
||||
{
|
||||
gdouble ratio;
|
||||
|
||||
if (drawable_width > drawable_height)
|
||||
{
|
||||
ratio = (gdouble) width / (gdouble) drawable_width;
|
||||
}
|
||||
else
|
||||
{
|
||||
ratio = (gdouble) height / (gdouble) drawable_height;
|
||||
}
|
||||
|
||||
width = RINT (ratio * (gdouble) drawable_width);
|
||||
height = RINT (ratio * (gdouble) drawable_height);
|
||||
|
||||
if (width < 1) width = 1;
|
||||
if (height < 1) height = 1;
|
||||
|
||||
*return_width = width;
|
||||
*return_height = height;
|
||||
*scaling_up = (ratio > 1.0);
|
||||
}
|
|
@ -1,61 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpDrawablePreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_DRAWABLE_PREVIEW_H__
|
||||
#define __GIMP_DRAWABLE_PREVIEW_H__
|
||||
|
||||
|
||||
#include "gimppreview.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_DRAWABLE_PREVIEW (gimp_drawable_preview_get_type ())
|
||||
#define GIMP_DRAWABLE_PREVIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DRAWABLE_PREVIEW, GimpDrawablePreview))
|
||||
#define GIMP_DRAWABLE_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DRAWABLE_PREVIEW, GimpDrawablePreviewClass))
|
||||
#define GIMP_IS_DRAWABLE_PREVIEW(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_DRAWABLE_PREVIEW))
|
||||
#define GIMP_IS_DRAWABLE_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DRAWABLE_PREVIEW))
|
||||
|
||||
|
||||
typedef struct _GimpDrawablePreviewClass GimpDrawablePreviewClass;
|
||||
|
||||
struct _GimpDrawablePreview
|
||||
{
|
||||
GimpPreview parent_instance;
|
||||
};
|
||||
|
||||
struct _GimpDrawablePreviewClass
|
||||
{
|
||||
GimpPreviewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_drawable_preview_get_type (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __GIMP_DRAWABLE_PREVIEW_H__ */
|
|
@ -1,164 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpGradientPreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpgradient.h"
|
||||
#include "gimpgradientpreview.h"
|
||||
#include "temp_buf.h"
|
||||
|
||||
|
||||
static void gimp_gradient_preview_class_init (GimpGradientPreviewClass *klass);
|
||||
static void gimp_gradient_preview_init (GimpGradientPreview *preview);
|
||||
|
||||
static void gimp_gradient_preview_render (GimpPreview *preview);
|
||||
static void gimp_gradient_preview_get_size (GimpPreview *preview,
|
||||
gint size,
|
||||
gint *width,
|
||||
gint *height);
|
||||
static gboolean gimp_gradient_preview_needs_popup (GimpPreview *preview);
|
||||
static GtkWidget * gimp_gradient_preview_create_popup (GimpPreview *preview);
|
||||
|
||||
|
||||
static GimpPreviewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_gradient_preview_get_type (void)
|
||||
{
|
||||
static GtkType preview_type = 0;
|
||||
|
||||
if (! preview_type)
|
||||
{
|
||||
GtkTypeInfo preview_info =
|
||||
{
|
||||
"GimpGradientPreview",
|
||||
sizeof (GimpGradientPreview),
|
||||
sizeof (GimpGradientPreviewClass),
|
||||
(GtkClassInitFunc) gimp_gradient_preview_class_init,
|
||||
(GtkObjectInitFunc) gimp_gradient_preview_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
preview_type = gtk_type_unique (GIMP_TYPE_PREVIEW, &preview_info);
|
||||
}
|
||||
|
||||
return preview_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_gradient_preview_class_init (GimpGradientPreviewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpPreviewClass *preview_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
preview_class = (GimpPreviewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_PREVIEW);
|
||||
|
||||
preview_class->get_size = gimp_gradient_preview_get_size;
|
||||
preview_class->render = gimp_gradient_preview_render;
|
||||
preview_class->needs_popup = gimp_gradient_preview_needs_popup;
|
||||
preview_class->create_popup = gimp_gradient_preview_create_popup;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_gradient_preview_init (GimpGradientPreview *gradient_preview)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_gradient_preview_get_size (GimpPreview *preview,
|
||||
gint size,
|
||||
gint *width,
|
||||
gint *height)
|
||||
{
|
||||
*width = size * 3;
|
||||
*height = size;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_gradient_preview_render (GimpPreview *preview)
|
||||
{
|
||||
GimpGradient *gradient;
|
||||
TempBuf *temp_buf;
|
||||
gint width;
|
||||
gint height;
|
||||
|
||||
gradient = GIMP_GRADIENT (preview->viewable);
|
||||
|
||||
width = preview->width;
|
||||
height = preview->height;
|
||||
|
||||
temp_buf = gimp_viewable_get_new_preview (preview->viewable,
|
||||
width, height);
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
temp_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_gradient_preview_needs_popup (GimpPreview *preview)
|
||||
{
|
||||
GimpGradient *gradient;
|
||||
gint popup_width;
|
||||
gint popup_height;
|
||||
|
||||
gradient = GIMP_GRADIENT (preview->viewable);
|
||||
|
||||
popup_width = 48;
|
||||
popup_height = 24;
|
||||
|
||||
if (popup_width > preview->width ||
|
||||
popup_height > preview->height)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static GtkWidget *
|
||||
gimp_gradient_preview_create_popup (GimpPreview *preview)
|
||||
{
|
||||
GimpGradient *gradient;
|
||||
gint popup_width;
|
||||
gint popup_height;
|
||||
|
||||
gradient = GIMP_GRADIENT (preview->viewable);
|
||||
|
||||
popup_width = 128;
|
||||
popup_height = 32;
|
||||
|
||||
return gimp_preview_new_full (preview->viewable,
|
||||
popup_width,
|
||||
popup_height,
|
||||
0,
|
||||
TRUE, FALSE, FALSE);
|
||||
}
|
|
@ -1,61 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpGradientPreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_GRADIENT_PREVIEW_H__
|
||||
#define __GIMP_GRADIENT_PREVIEW_H__
|
||||
|
||||
|
||||
#include "gimppreview.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_GRADIENT_PREVIEW (gimp_gradient_preview_get_type ())
|
||||
#define GIMP_GRADIENT_PREVIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_GRADIENT_PREVIEW, GimpGradientPreview))
|
||||
#define GIMP_GRADIENT_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_GRADIENT_PREVIEW, GimpGradientPreviewClass))
|
||||
#define GIMP_IS_GRADIENT_PREVIEW(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_GRADIENT_PREVIEW))
|
||||
#define GIMP_IS_GRADIENT_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_GRADIENT_PREVIEW))
|
||||
|
||||
|
||||
typedef struct _GimpGradientPreviewClass GimpGradientPreviewClass;
|
||||
|
||||
struct _GimpGradientPreview
|
||||
{
|
||||
GimpPreview parent_instance;
|
||||
};
|
||||
|
||||
struct _GimpGradientPreviewClass
|
||||
{
|
||||
GimpPreviewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_gradient_preview_get_type (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __GIMP_GRADIENT_PREVIEW_H__ */
|
|
@ -22,16 +22,6 @@
|
|||
#define __GIMP_HISTOGRAM_H__
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
GIMP_HISTOGRAM_VALUE = 0,
|
||||
GIMP_HISTOGRAM_RED = 1,
|
||||
GIMP_HISTOGRAM_GREEN = 2,
|
||||
GIMP_HISTOGRAM_BLUE = 3,
|
||||
GIMP_HISTOGRAM_ALPHA = 4
|
||||
} GimpHistogramChannel;
|
||||
|
||||
|
||||
GimpHistogram * gimp_histogram_new (void);
|
||||
void gimp_histogram_free (GimpHistogram *histogram);
|
||||
void gimp_histogram_calculate (GimpHistogram *historgam,
|
||||
|
|
|
@ -1,239 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpImagePreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpmath/gimpmath.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpimage.h"
|
||||
#include "gimpimagepreview.h"
|
||||
#include "gimpviewable.h"
|
||||
#include "temp_buf.h"
|
||||
|
||||
|
||||
static void gimp_image_preview_class_init (GimpImagePreviewClass *klass);
|
||||
static void gimp_image_preview_init (GimpImagePreview *preview);
|
||||
|
||||
static void gimp_image_preview_render (GimpPreview *preview);
|
||||
static GtkWidget * gimp_image_preview_create_popup (GimpPreview *preview);
|
||||
static void gimp_image_preview_calc_size (GimpImage *gimage,
|
||||
gint width,
|
||||
gint height,
|
||||
gint *return_width,
|
||||
gint *return_height,
|
||||
gboolean *scaling_up);
|
||||
|
||||
|
||||
static GimpPreviewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_image_preview_get_type (void)
|
||||
{
|
||||
static GtkType preview_type = 0;
|
||||
|
||||
if (! preview_type)
|
||||
{
|
||||
GtkTypeInfo preview_info =
|
||||
{
|
||||
"GimpImagePreview",
|
||||
sizeof (GimpImagePreview),
|
||||
sizeof (GimpImagePreviewClass),
|
||||
(GtkClassInitFunc) gimp_image_preview_class_init,
|
||||
(GtkObjectInitFunc) gimp_image_preview_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
preview_type = gtk_type_unique (GIMP_TYPE_PREVIEW, &preview_info);
|
||||
}
|
||||
|
||||
return preview_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_image_preview_class_init (GimpImagePreviewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpPreviewClass *preview_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
preview_class = (GimpPreviewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_PREVIEW);
|
||||
|
||||
preview_class->render = gimp_image_preview_render;
|
||||
preview_class->create_popup = gimp_image_preview_create_popup;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_image_preview_init (GimpImagePreview *preview)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_image_preview_render (GimpPreview *preview)
|
||||
{
|
||||
GimpImage *gimage;
|
||||
gint width;
|
||||
gint height;
|
||||
gint preview_width;
|
||||
gint preview_height;
|
||||
gboolean scaling_up;
|
||||
TempBuf *render_buf;
|
||||
|
||||
gimage = GIMP_IMAGE (preview->viewable);
|
||||
|
||||
width = preview->width;
|
||||
height = preview->height;
|
||||
|
||||
gimp_image_preview_calc_size (gimage,
|
||||
width,
|
||||
height,
|
||||
&preview_width,
|
||||
&preview_height,
|
||||
&scaling_up);
|
||||
|
||||
if (scaling_up)
|
||||
{
|
||||
TempBuf *temp_buf;
|
||||
|
||||
temp_buf = gimp_viewable_get_new_preview (preview->viewable,
|
||||
gimage->width,
|
||||
gimage->height);
|
||||
render_buf = temp_buf_scale (temp_buf, preview_width, preview_height);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
}
|
||||
else
|
||||
{
|
||||
render_buf = gimp_viewable_get_new_preview (preview->viewable,
|
||||
preview_width,
|
||||
preview_height);
|
||||
}
|
||||
|
||||
if (preview_width < width) render_buf->x = (width - preview_width) / 2;
|
||||
if (preview_height < height) render_buf->y = (height - preview_height) / 2;
|
||||
|
||||
if (render_buf->x || render_buf->y)
|
||||
{
|
||||
TempBuf *temp_buf;
|
||||
guchar white[4] = { 255, 255, 255, 255 };
|
||||
|
||||
temp_buf = temp_buf_new (width, height,
|
||||
render_buf->bytes,
|
||||
0, 0,
|
||||
white);
|
||||
|
||||
temp_buf_copy_area (render_buf, temp_buf,
|
||||
0, 0,
|
||||
render_buf->width,
|
||||
render_buf->height,
|
||||
render_buf->x,
|
||||
render_buf->y);
|
||||
|
||||
temp_buf_free (render_buf);
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
temp_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
render_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (render_buf);
|
||||
}
|
||||
|
||||
static GtkWidget *
|
||||
gimp_image_preview_create_popup (GimpPreview *preview)
|
||||
{
|
||||
GimpImage *gimage;
|
||||
gint popup_width;
|
||||
gint popup_height;
|
||||
gboolean scaling_up;
|
||||
|
||||
gimage = GIMP_IMAGE (preview->viewable);
|
||||
|
||||
gimp_image_preview_calc_size (gimage,
|
||||
MIN (preview->width * 2, 256),
|
||||
MIN (preview->height * 2, 256),
|
||||
&popup_width,
|
||||
&popup_height,
|
||||
&scaling_up);
|
||||
|
||||
if (scaling_up)
|
||||
{
|
||||
return gimp_preview_new_full (preview->viewable,
|
||||
gimage->width,
|
||||
gimage->height,
|
||||
0,
|
||||
TRUE, FALSE, FALSE);
|
||||
}
|
||||
else
|
||||
{
|
||||
return gimp_preview_new_full (preview->viewable,
|
||||
popup_width,
|
||||
popup_height,
|
||||
0,
|
||||
TRUE, FALSE, FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_image_preview_calc_size (GimpImage *gimage,
|
||||
gint width,
|
||||
gint height,
|
||||
gint *return_width,
|
||||
gint *return_height,
|
||||
gboolean *scaling_up)
|
||||
{
|
||||
gdouble ratio;
|
||||
|
||||
if (gimage->width > gimage->height)
|
||||
{
|
||||
ratio = (gdouble) width / (gdouble) gimage->width;
|
||||
}
|
||||
else
|
||||
{
|
||||
ratio = (gdouble) height / (gdouble) gimage->height;
|
||||
}
|
||||
|
||||
width = RINT (ratio * (gdouble) gimage->width);
|
||||
height = RINT (ratio * (gdouble) gimage->height);
|
||||
|
||||
if (width < 1) width = 1;
|
||||
if (height < 1) height = 1;
|
||||
|
||||
*return_width = width;
|
||||
*return_height = height;
|
||||
*scaling_up = (ratio > 1.0);
|
||||
}
|
|
@ -1,61 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpImagePreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_IMAGE_PREVIEW_H__
|
||||
#define __GIMP_IMAGE_PREVIEW_H__
|
||||
|
||||
|
||||
#include "gimppreview.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_IMAGE_PREVIEW (gimp_image_preview_get_type ())
|
||||
#define GIMP_IMAGE_PREVIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_IMAGE_PREVIEW, GimpImagePreview))
|
||||
#define GIMP_IMAGE_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_IMAGE_PREVIEW, GimpImagePreviewClass))
|
||||
#define GIMP_IS_IMAGE_PREVIEW(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE_PREVIEW))
|
||||
#define GIMP_IS_IMAGE_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE_PREVIEW))
|
||||
|
||||
|
||||
typedef struct _GimpImagePreviewClass GimpImagePreviewClass;
|
||||
|
||||
struct _GimpImagePreview
|
||||
{
|
||||
GimpPreview parent_instance;
|
||||
};
|
||||
|
||||
struct _GimpImagePreviewClass
|
||||
{
|
||||
GimpPreviewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_image_preview_get_type (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __GIMP_IMAGE_PREVIEW_H__ */
|
|
@ -1,392 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimplayerlistitem.c
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpcolor/gimpcolor.h"
|
||||
#include "libgimpwidgets/gimpwidgets.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "gdisplay.h"
|
||||
#include "gimpchannel.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimplayerlistitem.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimplayermask.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimpviewable.h"
|
||||
|
||||
|
||||
static void gimp_layer_list_item_class_init (GimpLayerListItemClass *klass);
|
||||
static void gimp_layer_list_item_init (GimpLayerListItem *list_item);
|
||||
|
||||
static void gimp_layer_list_item_set_viewable (GimpListItem *list_item,
|
||||
GimpViewable *viewable);
|
||||
|
||||
static gboolean gimp_layer_list_item_drag_motion (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time);
|
||||
static gboolean gimp_layer_list_item_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time);
|
||||
static void gimp_layer_list_item_state_changed (GtkWidget *widget,
|
||||
GtkStateType old_state);
|
||||
|
||||
static void gimp_layer_list_item_mask_changed (GimpLayer *layer,
|
||||
GimpLayerListItem *layer_item);
|
||||
static void gimp_layer_list_item_update_state (GtkWidget *widget);
|
||||
|
||||
static void gimp_layer_list_item_layer_clicked (GtkWidget *widget,
|
||||
GimpLayer *layer);
|
||||
static void gimp_layer_list_item_mask_clicked (GtkWidget *widget,
|
||||
GimpLayerMask *mask);
|
||||
|
||||
|
||||
static GimpDrawableListItemClass *parent_class = NULL;
|
||||
|
||||
static GimpRGB black_color;
|
||||
static GimpRGB white_color;
|
||||
static GimpRGB green_color;
|
||||
static GimpRGB red_color;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_layer_list_item_get_type (void)
|
||||
{
|
||||
static GtkType list_item_type = 0;
|
||||
|
||||
if (! list_item_type)
|
||||
{
|
||||
static const GtkTypeInfo list_item_info =
|
||||
{
|
||||
"GimpLayerListItem",
|
||||
sizeof (GimpLayerListItem),
|
||||
sizeof (GimpLayerListItemClass),
|
||||
(GtkClassInitFunc) gimp_layer_list_item_class_init,
|
||||
(GtkObjectInitFunc) gimp_layer_list_item_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
list_item_type = gtk_type_unique (GIMP_TYPE_DRAWABLE_LIST_ITEM,
|
||||
&list_item_info);
|
||||
}
|
||||
|
||||
return list_item_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_item_class_init (GimpLayerListItemClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkWidgetClass *widget_class;
|
||||
GimpListItemClass *list_item_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
widget_class = (GtkWidgetClass *) klass;
|
||||
list_item_class = (GimpListItemClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE_LIST_ITEM);
|
||||
|
||||
widget_class->drag_motion = gimp_layer_list_item_drag_motion;
|
||||
widget_class->drag_drop = gimp_layer_list_item_drag_drop;
|
||||
widget_class->state_changed = gimp_layer_list_item_state_changed;
|
||||
|
||||
list_item_class->set_viewable = gimp_layer_list_item_set_viewable;
|
||||
|
||||
gimp_rgba_set (&black_color, 0.0, 0.0, 0.0, 1.0);
|
||||
gimp_rgba_set (&white_color, 1.0, 1.0, 1.0, 1.0);
|
||||
gimp_rgba_set (&green_color, 0.0, 1.0, 0.0, 1.0);
|
||||
gimp_rgba_set (&red_color, 1.0, 0.0, 0.0, 1.0);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_item_init (GimpLayerListItem *list_item)
|
||||
{
|
||||
list_item->mask_preview = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_item_set_viewable (GimpListItem *list_item,
|
||||
GimpViewable *viewable)
|
||||
{
|
||||
GimpLayerListItem *layer_item;
|
||||
GimpLayer *layer;
|
||||
|
||||
if (GIMP_LIST_ITEM_CLASS (parent_class)->set_viewable)
|
||||
GIMP_LIST_ITEM_CLASS (parent_class)->set_viewable (list_item, viewable);
|
||||
|
||||
gimp_preview_set_size (GIMP_PREVIEW (list_item->preview),
|
||||
list_item->preview_size, 2);
|
||||
|
||||
layer_item = GIMP_LAYER_LIST_ITEM (list_item);
|
||||
layer = GIMP_LAYER (GIMP_PREVIEW (list_item->preview)->viewable);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (list_item->preview), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_layer_list_item_layer_clicked),
|
||||
layer);
|
||||
|
||||
if (gimp_layer_get_mask (layer))
|
||||
{
|
||||
gimp_layer_list_item_mask_changed (layer, layer_item);
|
||||
}
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (layer), "mask_changed",
|
||||
GTK_SIGNAL_FUNC (gimp_layer_list_item_mask_changed),
|
||||
list_item);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_layer_list_item_drag_motion (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
GimpLayer *layer;
|
||||
GimpViewable *src_viewable;
|
||||
gint dest_index;
|
||||
GdkDragAction drag_action;
|
||||
GimpDropType drop_type;
|
||||
gboolean return_val;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (widget);
|
||||
layer = GIMP_LAYER (GIMP_PREVIEW (list_item->preview)->viewable);
|
||||
|
||||
return_val = gimp_list_item_check_drag (list_item, context, x, y,
|
||||
&src_viewable,
|
||||
&dest_index,
|
||||
&drag_action,
|
||||
&drop_type);
|
||||
|
||||
if (! src_viewable ||
|
||||
! gimp_drawable_has_alpha (GIMP_DRAWABLE (src_viewable)) ||
|
||||
! layer ||
|
||||
! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
|
||||
{
|
||||
drag_action = GDK_ACTION_DEFAULT;
|
||||
drop_type = GIMP_DROP_NONE;
|
||||
return_val = FALSE;
|
||||
}
|
||||
|
||||
gdk_drag_status (context, drag_action, time);
|
||||
|
||||
list_item->drop_type = drop_type;
|
||||
|
||||
return return_val;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_layer_list_item_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
GimpLayer *layer;
|
||||
GimpViewable *src_viewable;
|
||||
gint dest_index;
|
||||
GdkDragAction drag_action;
|
||||
GimpDropType drop_type;
|
||||
gboolean return_val;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (widget);
|
||||
layer = GIMP_LAYER (GIMP_PREVIEW (list_item->preview)->viewable);
|
||||
|
||||
return_val = gimp_list_item_check_drag (list_item, context, x, y,
|
||||
&src_viewable,
|
||||
&dest_index,
|
||||
&drag_action,
|
||||
&drop_type);
|
||||
|
||||
if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (src_viewable)) ||
|
||||
! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
|
||||
{
|
||||
drag_action = GDK_ACTION_DEFAULT;
|
||||
drop_type = GIMP_DROP_NONE;
|
||||
return_val = FALSE;
|
||||
}
|
||||
|
||||
gtk_drag_finish (context, return_val, FALSE, time);
|
||||
|
||||
list_item->drop_type = GIMP_DROP_NONE;
|
||||
|
||||
if (return_val)
|
||||
{
|
||||
gimp_image_position_layer (gimp_drawable_gimage (GIMP_DRAWABLE (src_viewable)),
|
||||
GIMP_LAYER (src_viewable),
|
||||
dest_index,
|
||||
TRUE);
|
||||
gdisplays_flush ();
|
||||
}
|
||||
|
||||
return return_val;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_item_state_changed (GtkWidget *widget,
|
||||
GtkStateType old_state)
|
||||
{
|
||||
if (GTK_WIDGET_CLASS (parent_class)->state_changed)
|
||||
GTK_WIDGET_CLASS (parent_class)->state_changed (widget, old_state);
|
||||
|
||||
gimp_layer_list_item_update_state (widget);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_item_mask_changed (GimpLayer *layer,
|
||||
GimpLayerListItem *layer_item)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
GimpLayerMask *mask;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (layer_item);
|
||||
mask = gimp_layer_get_mask (layer);
|
||||
|
||||
if (mask && ! layer_item->mask_preview)
|
||||
{
|
||||
layer_item->mask_preview = gimp_preview_new (GIMP_VIEWABLE (mask),
|
||||
list_item->preview_size,
|
||||
2, FALSE);
|
||||
|
||||
GIMP_PREVIEW (layer_item->mask_preview)->clickable = TRUE;
|
||||
|
||||
gtk_box_pack_start (GTK_BOX (list_item->hbox), layer_item->mask_preview,
|
||||
FALSE, FALSE, 0);
|
||||
gtk_box_reorder_child (GTK_BOX (list_item->hbox),
|
||||
layer_item->mask_preview, 2);
|
||||
gtk_widget_show (layer_item->mask_preview);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (layer_item->mask_preview), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_layer_list_item_mask_clicked),
|
||||
mask);
|
||||
|
||||
gtk_signal_connect_object
|
||||
(GTK_OBJECT (mask), "apply_changed",
|
||||
GTK_SIGNAL_FUNC (gimp_layer_list_item_update_state),
|
||||
GTK_OBJECT (layer_item));
|
||||
|
||||
gtk_signal_connect_object_while_alive
|
||||
(GTK_OBJECT (mask), "edit_changed",
|
||||
GTK_SIGNAL_FUNC (gimp_layer_list_item_update_state),
|
||||
GTK_OBJECT (layer_item));
|
||||
|
||||
gtk_signal_connect_object_while_alive
|
||||
(GTK_OBJECT (mask), "show_changed",
|
||||
GTK_SIGNAL_FUNC (gimp_layer_list_item_update_state),
|
||||
GTK_OBJECT (layer_item));
|
||||
}
|
||||
else if (! mask && layer_item->mask_preview)
|
||||
{
|
||||
gtk_widget_destroy (layer_item->mask_preview);
|
||||
layer_item->mask_preview = NULL;
|
||||
}
|
||||
|
||||
gimp_layer_list_item_update_state (GTK_WIDGET (layer_item));
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_item_update_state (GtkWidget *widget)
|
||||
{
|
||||
GimpLayerListItem *layer_item;
|
||||
GimpListItem *list_item;
|
||||
GimpLayer *layer;
|
||||
GimpLayerMask *mask;
|
||||
GimpPreview *preview;
|
||||
GimpRGB *layer_color = &black_color;
|
||||
GimpRGB *mask_color = &black_color;
|
||||
|
||||
layer_item = GIMP_LAYER_LIST_ITEM (widget);
|
||||
list_item = GIMP_LIST_ITEM (widget);
|
||||
layer = GIMP_LAYER (GIMP_PREVIEW (list_item->preview)->viewable);
|
||||
mask = gimp_layer_get_mask (layer);
|
||||
|
||||
switch (widget->state)
|
||||
{
|
||||
case GTK_STATE_NORMAL:
|
||||
break;
|
||||
|
||||
case GTK_STATE_SELECTED:
|
||||
if (! mask || (mask && ! gimp_layer_mask_get_edit (mask)))
|
||||
{
|
||||
layer_color = &white_color;
|
||||
}
|
||||
else
|
||||
{
|
||||
mask_color = &white_color;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
g_print ("%s(): unhandled state\n", G_GNUC_FUNCTION);
|
||||
}
|
||||
|
||||
preview = GIMP_PREVIEW (list_item->preview);
|
||||
|
||||
gimp_preview_set_border_color (preview, layer_color);
|
||||
|
||||
if (mask)
|
||||
{
|
||||
preview = GIMP_PREVIEW (layer_item->mask_preview);
|
||||
|
||||
gimp_preview_set_border_color (preview, mask_color);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_item_layer_clicked (GtkWidget *widget,
|
||||
GimpLayer *layer)
|
||||
{
|
||||
GimpLayerMask *mask;
|
||||
|
||||
g_print ("layer clicked\n");
|
||||
|
||||
mask = gimp_layer_get_mask (layer);
|
||||
|
||||
if (mask)
|
||||
{
|
||||
if (gimp_layer_mask_get_edit (mask))
|
||||
gimp_layer_mask_set_edit (mask, FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_item_mask_clicked (GtkWidget *widget,
|
||||
GimpLayerMask *mask)
|
||||
{
|
||||
g_print ("mask clicked\n");
|
||||
|
||||
if (! gimp_layer_mask_get_edit (mask))
|
||||
gimp_layer_mask_set_edit (mask, TRUE);
|
||||
}
|
|
@ -1,64 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimplayerlistitem.h
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_LAYER_LIST_ITEM_H__
|
||||
#define __GIMP_LAYER_LIST_ITEM_H__
|
||||
|
||||
|
||||
#include "gimpdrawablelistitem.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_LAYER_LIST_ITEM (gimp_layer_list_item_get_type ())
|
||||
#define GIMP_LAYER_LIST_ITEM(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_LIST_ITEM, GimpLayerListItem))
|
||||
#define GIMP_LAYER_LIST_ITEM_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_LIST_ITEM, GimpLayerListItemClass))
|
||||
#define GIMP_IS_LAYER_LIST_ITEM(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_LIST_ITEM))
|
||||
#define GIMP_IS_LAYER_LIST_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_LIST_ITEM))
|
||||
|
||||
|
||||
typedef struct _GimpLayerListItemClass GimpLayerListItemClass;
|
||||
|
||||
struct _GimpLayerListItem
|
||||
{
|
||||
GimpDrawableListItem parent_instance;
|
||||
|
||||
GtkWidget *mask_preview;
|
||||
};
|
||||
|
||||
struct _GimpLayerListItemClass
|
||||
{
|
||||
GimpDrawableListItemClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_layer_list_item_get_type (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#endif /* __GIMP_LAYER_LIST_ITEM_H__ */
|
|
@ -1,528 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpmath/gimpmath.h"
|
||||
#include "libgimpwidgets/gimpwidgets.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "gdisplay.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimplayerlistview.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimplistitem.h"
|
||||
#include "gimpmarshal.h"
|
||||
#include "gimprc.h"
|
||||
#include "gimpviewable.h"
|
||||
|
||||
#include "tools/paint_options.h"
|
||||
|
||||
#include "libgimp/gimpintl.h"
|
||||
|
||||
#include "pixmaps/anchor.xpm"
|
||||
|
||||
|
||||
static void gimp_layer_list_view_class_init (GimpLayerListViewClass *klass);
|
||||
static void gimp_layer_list_view_init (GimpLayerListView *view);
|
||||
|
||||
static void gimp_layer_list_view_destroy (GtkObject *object);
|
||||
|
||||
static void gimp_layer_list_view_set_container (GimpContainerView *view,
|
||||
GimpContainer *container);
|
||||
static void gimp_layer_list_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *item,
|
||||
gpointer insert_data);
|
||||
|
||||
static void gimp_layer_list_view_anchor_layer (GimpLayerListView *view,
|
||||
GimpLayer *layer);
|
||||
static void gimp_layer_list_view_anchor_clicked (GtkWidget *widget,
|
||||
GimpLayerListView *view);
|
||||
static void gimp_layer_list_view_anchor_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data);
|
||||
|
||||
static void gimp_layer_list_view_paint_mode_menu_callback
|
||||
(GtkWidget *widget,
|
||||
GimpLayerListView *view);
|
||||
static void gimp_layer_list_view_preserve_button_toggled
|
||||
(GtkWidget *widget,
|
||||
GimpLayerListView *view);
|
||||
static void gimp_layer_list_view_opacity_scale_changed
|
||||
(GtkAdjustment *adjustment,
|
||||
GimpLayerListView *view);
|
||||
|
||||
static void gimp_layer_list_view_layer_signal_handler
|
||||
(GimpLayer *layer,
|
||||
GimpLayerListView *view);
|
||||
static void gimp_layer_list_view_update_options (GimpLayerListView *view,
|
||||
GimpLayer *layer);
|
||||
|
||||
|
||||
static GimpDrawableListViewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_layer_list_view_get_type (void)
|
||||
{
|
||||
static guint view_type = 0;
|
||||
|
||||
if (! view_type)
|
||||
{
|
||||
GtkTypeInfo view_info =
|
||||
{
|
||||
"GimpLayerListView",
|
||||
sizeof (GimpLayerListView),
|
||||
sizeof (GimpLayerListViewClass),
|
||||
(GtkClassInitFunc) gimp_layer_list_view_class_init,
|
||||
(GtkObjectInitFunc) gimp_layer_list_view_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
view_type = gtk_type_unique (GIMP_TYPE_DRAWABLE_LIST_VIEW, &view_info);
|
||||
}
|
||||
|
||||
return view_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_class_init (GimpLayerListViewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpContainerViewClass *container_view_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
container_view_class = (GimpContainerViewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE_LIST_VIEW);
|
||||
|
||||
object_class->destroy = gimp_layer_list_view_destroy;
|
||||
|
||||
container_view_class->set_container = gimp_layer_list_view_set_container;
|
||||
container_view_class->select_item = gimp_layer_list_view_select_item;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_init (GimpLayerListView *view)
|
||||
{
|
||||
GimpDrawableListView *drawable_view;
|
||||
GtkWidget *hbox;
|
||||
GtkWidget *label;
|
||||
GtkWidget *slider;
|
||||
GtkWidget *pixmap;
|
||||
|
||||
drawable_view = GIMP_DRAWABLE_LIST_VIEW (view);
|
||||
|
||||
view->options_box = gtk_vbox_new (FALSE, 2);
|
||||
gtk_box_pack_start (GTK_BOX (view), view->options_box, FALSE, FALSE, 0);
|
||||
gtk_box_reorder_child (GTK_BOX (view), view->options_box, 0);
|
||||
gtk_widget_show (view->options_box);
|
||||
|
||||
hbox = gtk_hbox_new (FALSE, 2);
|
||||
gtk_box_pack_start (GTK_BOX (view->options_box), hbox, FALSE, FALSE, 0);
|
||||
gtk_widget_show (hbox);
|
||||
|
||||
/* Paint mode menu */
|
||||
|
||||
label = gtk_label_new (_("Mode:"));
|
||||
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
|
||||
gtk_widget_show (label);
|
||||
|
||||
view->paint_mode_menu =
|
||||
paint_mode_menu_new (gimp_layer_list_view_paint_mode_menu_callback, view,
|
||||
FALSE, NORMAL_MODE);
|
||||
gtk_box_pack_start (GTK_BOX (hbox), view->paint_mode_menu, FALSE, FALSE, 2);
|
||||
gtk_widget_show (view->paint_mode_menu);
|
||||
|
||||
gimp_help_set_help_data (view->paint_mode_menu,
|
||||
NULL, "#paint_mode_menu");
|
||||
|
||||
/* Preserve transparency toggle */
|
||||
|
||||
view->preserve_trans_toggle =
|
||||
gtk_check_button_new_with_label (_("Keep Trans."));
|
||||
gtk_box_pack_start (GTK_BOX (hbox), view->preserve_trans_toggle,
|
||||
FALSE, FALSE, 2);
|
||||
gtk_widget_show (view->preserve_trans_toggle);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->preserve_trans_toggle), "toggled",
|
||||
GTK_SIGNAL_FUNC (gimp_layer_list_view_preserve_button_toggled),
|
||||
view);
|
||||
|
||||
gimp_help_set_help_data (view->preserve_trans_toggle,
|
||||
_("Keep Transparency"), "#keep_trans_button");
|
||||
|
||||
hbox = gtk_hbox_new (FALSE, 2);
|
||||
gtk_box_pack_start (GTK_BOX (view->options_box), hbox, FALSE, FALSE, 0);
|
||||
gtk_widget_show (hbox);
|
||||
|
||||
/* Opacity scale */
|
||||
|
||||
label = gtk_label_new (_("Opacity:"));
|
||||
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
|
||||
gtk_widget_show (label);
|
||||
|
||||
view->opacity_adjustment =
|
||||
GTK_ADJUSTMENT (gtk_adjustment_new (100.0, 0.0, 100.0, 1.0, 1.0, 0.0));
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->opacity_adjustment), "value_changed",
|
||||
GTK_SIGNAL_FUNC (gimp_layer_list_view_opacity_scale_changed),
|
||||
view);
|
||||
|
||||
slider = gtk_hscale_new (view->opacity_adjustment);
|
||||
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_RIGHT);
|
||||
gtk_box_pack_start (GTK_BOX (hbox), slider, TRUE, TRUE, 0);
|
||||
gtk_widget_show (slider);
|
||||
|
||||
gimp_help_set_help_data (slider, NULL, "#opacity_scale");
|
||||
|
||||
/* Anchor button */
|
||||
|
||||
view->anchor_button = gtk_button_new ();
|
||||
gtk_box_pack_start (GTK_BOX (drawable_view->button_box), view->anchor_button,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_box_reorder_child (GTK_BOX (drawable_view->button_box),
|
||||
view->anchor_button, 5);
|
||||
gtk_widget_show (view->anchor_button);
|
||||
|
||||
gimp_help_set_help_data (view->anchor_button, _("Anchor"), NULL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (view->anchor_button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gimp_layer_list_view_anchor_clicked),
|
||||
view);
|
||||
|
||||
pixmap = gimp_pixmap_new (anchor_xpm);
|
||||
gtk_container_add (GTK_CONTAINER (view->anchor_button), pixmap);
|
||||
gtk_widget_show (pixmap);
|
||||
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view->anchor_button),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
GIMP_TYPE_LAYER,
|
||||
GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_dest_set (GTK_WIDGET (view->anchor_button),
|
||||
GIMP_TYPE_LAYER,
|
||||
gimp_layer_list_view_anchor_dropped,
|
||||
view);
|
||||
|
||||
gtk_widget_set_sensitive (view->options_box, FALSE);
|
||||
gtk_widget_set_sensitive (view->anchor_button, FALSE);
|
||||
|
||||
view->mode_changed_handler_id = 0;
|
||||
view->opacity_changed_handler_id = 0;
|
||||
view->preserve_trans_changed_handler_id = 0;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_destroy (GtkObject *object)
|
||||
{
|
||||
GimpLayerListView *view;
|
||||
|
||||
view = GIMP_LAYER_LIST_VIEW (object);
|
||||
|
||||
if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
||||
GTK_OBJECT_CLASS (parent_class)->destroy (object);
|
||||
}
|
||||
|
||||
|
||||
/* GimpContainerView methods */
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_set_container (GimpContainerView *view,
|
||||
GimpContainer *container)
|
||||
{
|
||||
GimpLayerListView *layer_view;
|
||||
|
||||
layer_view = GIMP_LAYER_LIST_VIEW (view);
|
||||
|
||||
if (view->container)
|
||||
{
|
||||
gimp_container_remove_handler (view->container,
|
||||
layer_view->mode_changed_handler_id);
|
||||
gimp_container_remove_handler (view->container,
|
||||
layer_view->opacity_changed_handler_id);
|
||||
gimp_container_remove_handler (view->container,
|
||||
layer_view->preserve_trans_changed_handler_id);
|
||||
}
|
||||
|
||||
if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container)
|
||||
GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container (view, container);
|
||||
|
||||
if (view->container)
|
||||
{
|
||||
layer_view->mode_changed_handler_id =
|
||||
gimp_container_add_handler (view->container, "mode_changed",
|
||||
gimp_layer_list_view_layer_signal_handler,
|
||||
view);
|
||||
layer_view->opacity_changed_handler_id =
|
||||
gimp_container_add_handler (view->container, "opacity_changed",
|
||||
gimp_layer_list_view_layer_signal_handler,
|
||||
view);
|
||||
layer_view->preserve_trans_changed_handler_id =
|
||||
gimp_container_add_handler (view->container, "preserve_trans_changed",
|
||||
gimp_layer_list_view_layer_signal_handler,
|
||||
view);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_select_item (GimpContainerView *view,
|
||||
GimpViewable *item,
|
||||
gpointer insert_data)
|
||||
{
|
||||
GimpLayerListView *list_view;
|
||||
gboolean options_sensitive = FALSE;
|
||||
gboolean anchor_sensitive = FALSE;
|
||||
|
||||
list_view = GIMP_LAYER_LIST_VIEW (view);
|
||||
|
||||
if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item)
|
||||
GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view,
|
||||
item,
|
||||
insert_data);
|
||||
|
||||
if (item)
|
||||
{
|
||||
gimp_layer_list_view_update_options (list_view, GIMP_LAYER (item));
|
||||
|
||||
options_sensitive = TRUE;
|
||||
|
||||
if (gimp_layer_is_floating_sel (GIMP_LAYER (item)))
|
||||
{
|
||||
anchor_sensitive = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
gtk_widget_set_sensitive (list_view->options_box, options_sensitive);
|
||||
gtk_widget_set_sensitive (list_view->anchor_button, anchor_sensitive);
|
||||
}
|
||||
|
||||
|
||||
/* "Anchor" functions */
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_anchor_layer (GimpLayerListView *view,
|
||||
GimpLayer *layer)
|
||||
{
|
||||
if (layer)
|
||||
g_print ("anchor \"%s\"\n", GIMP_OBJECT (layer)->name);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_anchor_clicked (GtkWidget *widget,
|
||||
GimpLayerListView *view)
|
||||
{
|
||||
GimpDrawableListView *drawable_view;
|
||||
GimpDrawable *drawable;
|
||||
|
||||
drawable_view = GIMP_DRAWABLE_LIST_VIEW (view);
|
||||
|
||||
drawable = drawable_view->get_drawable_func (drawable_view->gimage);
|
||||
|
||||
if (drawable)
|
||||
gimp_layer_list_view_anchor_layer (view, GIMP_LAYER (drawable));
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_anchor_dropped (GtkWidget *widget,
|
||||
GimpViewable *viewable,
|
||||
gpointer data)
|
||||
{
|
||||
GimpLayerListView *view;
|
||||
|
||||
view = (GimpLayerListView *) data;
|
||||
|
||||
if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container,
|
||||
GIMP_OBJECT (viewable)))
|
||||
{
|
||||
gimp_layer_list_view_anchor_layer (view, GIMP_LAYER (viewable));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Paint Mode, Opacity and Preservce trans. callbacks */
|
||||
|
||||
#define BLOCK() \
|
||||
gtk_signal_handler_block_by_func (GTK_OBJECT (layer), \
|
||||
gimp_layer_list_view_layer_signal_handler, view)
|
||||
|
||||
#define UNBLOCK() \
|
||||
gtk_signal_handler_unblock_by_func (GTK_OBJECT (layer), \
|
||||
gimp_layer_list_view_layer_signal_handler, view)
|
||||
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_paint_mode_menu_callback (GtkWidget *widget,
|
||||
GimpLayerListView *view)
|
||||
{
|
||||
GimpDrawableListView *drawable_view;
|
||||
GimpLayer *layer;
|
||||
|
||||
drawable_view = GIMP_DRAWABLE_LIST_VIEW (view);
|
||||
|
||||
layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage);
|
||||
|
||||
if (layer)
|
||||
{
|
||||
LayerModeEffects mode;
|
||||
|
||||
mode = (LayerModeEffects)
|
||||
GPOINTER_TO_INT (gtk_object_get_user_data (GTK_OBJECT (widget)));
|
||||
|
||||
if (gimp_layer_get_mode (layer) != mode)
|
||||
{
|
||||
BLOCK();
|
||||
gimp_layer_set_mode (layer, mode);
|
||||
UNBLOCK();
|
||||
|
||||
drawable_update (GIMP_DRAWABLE (layer), 0, 0,
|
||||
GIMP_DRAWABLE (layer)->width,
|
||||
GIMP_DRAWABLE (layer)->height);
|
||||
|
||||
gdisplays_flush ();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_preserve_button_toggled (GtkWidget *widget,
|
||||
GimpLayerListView *view)
|
||||
{
|
||||
GimpDrawableListView *drawable_view;
|
||||
GimpLayer *layer;
|
||||
|
||||
drawable_view = GIMP_DRAWABLE_LIST_VIEW (view);
|
||||
|
||||
layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage);
|
||||
|
||||
if (layer)
|
||||
{
|
||||
gboolean preserve_trans;
|
||||
|
||||
preserve_trans = GTK_TOGGLE_BUTTON (widget)->active;
|
||||
|
||||
if (gimp_layer_get_preserve_trans (layer) != preserve_trans)
|
||||
{
|
||||
BLOCK();
|
||||
gimp_layer_set_preserve_trans (layer, preserve_trans);
|
||||
UNBLOCK();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_opacity_scale_changed (GtkAdjustment *adjustment,
|
||||
GimpLayerListView *view)
|
||||
{
|
||||
GimpDrawableListView *drawable_view;
|
||||
GimpLayer *layer;
|
||||
|
||||
drawable_view = GIMP_DRAWABLE_LIST_VIEW (view);
|
||||
|
||||
layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage);
|
||||
|
||||
if (layer)
|
||||
{
|
||||
gdouble opacity;
|
||||
|
||||
opacity = adjustment->value / 100.0;
|
||||
|
||||
if (gimp_layer_get_opacity (layer) != opacity)
|
||||
{
|
||||
BLOCK();
|
||||
gimp_layer_set_opacity (layer, opacity);
|
||||
UNBLOCK();
|
||||
|
||||
drawable_update (GIMP_DRAWABLE (layer), 0, 0,
|
||||
GIMP_DRAWABLE (layer)->width,
|
||||
GIMP_DRAWABLE (layer)->height);
|
||||
|
||||
gdisplays_flush ();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#undef BLOCK
|
||||
#undef UNBLOCK
|
||||
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_layer_signal_handler (GimpLayer *layer,
|
||||
GimpLayerListView *view)
|
||||
{
|
||||
GimpDrawableListView *drawable_view;
|
||||
|
||||
drawable_view = GIMP_DRAWABLE_LIST_VIEW (view);
|
||||
|
||||
if (drawable_view->get_drawable_func (drawable_view->gimage) ==
|
||||
(GimpDrawable *) layer)
|
||||
{
|
||||
gimp_layer_list_view_update_options (view, layer);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#define BLOCK(object,function) \
|
||||
gtk_signal_handler_block_by_func (GTK_OBJECT (object), \
|
||||
(function), view)
|
||||
|
||||
#define UNBLOCK(object,function) \
|
||||
gtk_signal_handler_unblock_by_func (GTK_OBJECT (object), \
|
||||
(function), view)
|
||||
|
||||
static void
|
||||
gimp_layer_list_view_update_options (GimpLayerListView *view,
|
||||
GimpLayer *layer)
|
||||
{
|
||||
gimp_option_menu_set_history (GTK_OPTION_MENU (view->paint_mode_menu),
|
||||
GINT_TO_POINTER (layer->mode));
|
||||
|
||||
if (layer->preserve_trans !=
|
||||
GTK_TOGGLE_BUTTON (view->preserve_trans_toggle)->active)
|
||||
{
|
||||
BLOCK (view->preserve_trans_toggle,
|
||||
gimp_layer_list_view_preserve_button_toggled);
|
||||
|
||||
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view->preserve_trans_toggle),
|
||||
layer->preserve_trans);
|
||||
|
||||
UNBLOCK (view->preserve_trans_toggle,
|
||||
gimp_layer_list_view_preserve_button_toggled);
|
||||
}
|
||||
|
||||
if ((gdouble) layer->opacity / 2.55 != view->opacity_adjustment->value)
|
||||
{
|
||||
BLOCK (view->opacity_adjustment,
|
||||
gimp_layer_list_view_opacity_scale_changed);
|
||||
|
||||
gtk_adjustment_set_value (view->opacity_adjustment, layer->opacity / 2.55);
|
||||
|
||||
UNBLOCK (view->opacity_adjustment,
|
||||
gimp_layer_list_view_opacity_scale_changed);
|
||||
}
|
||||
}
|
||||
|
||||
#undef BLOCK
|
||||
#undef UNBLOCK
|
|
@ -1,62 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_LAYER_LIST_VIEW_H__
|
||||
#define __GIMP_LAYER_LIST_VIEW_H__
|
||||
|
||||
|
||||
#include "gimpdrawablelistview.h"
|
||||
|
||||
|
||||
#define GIMP_TYPE_LAYER_LIST_VIEW (gimp_layer_list_view_get_type ())
|
||||
#define GIMP_LAYER_LIST_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_LIST_VIEW, GimpLayerListView))
|
||||
#define GIMP_LAYER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_LIST_VIEW, GimpLayerListViewClass))
|
||||
#define GIMP_IS_LAYER_LIST_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_LIST_VIEW))
|
||||
#define GIMP_IS_LAYER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_LIST_VIEW))
|
||||
|
||||
|
||||
typedef struct _GimpLayerListViewClass GimpLayerListViewClass;
|
||||
|
||||
struct _GimpLayerListView
|
||||
{
|
||||
GimpDrawableListView parent_instance;
|
||||
|
||||
GtkWidget *options_box;
|
||||
|
||||
GtkWidget *paint_mode_menu;
|
||||
GtkWidget *preserve_trans_toggle;
|
||||
GtkAdjustment *opacity_adjustment;
|
||||
|
||||
GtkWidget *anchor_button;
|
||||
|
||||
/*< private >*/
|
||||
GQuark mode_changed_handler_id;
|
||||
GQuark opacity_changed_handler_id;
|
||||
GQuark preserve_trans_changed_handler_id;
|
||||
};
|
||||
|
||||
struct _GimpLayerListViewClass
|
||||
{
|
||||
GimpDrawableListViewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_layer_list_view_get_type (void);
|
||||
|
||||
|
||||
#endif /* __GIMP_LAYER_LIST_VIEW_H__ */
|
|
@ -1,452 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimplistitem.c
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimpdrawable.h"
|
||||
#include "gimpdrawablelistitem.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimplayerlistitem.h"
|
||||
#include "gimplistitem.h"
|
||||
#include "gimpmarshal.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimpviewable.h"
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
SET_VIEWABLE,
|
||||
LAST_SIGNAL
|
||||
};
|
||||
|
||||
|
||||
static void gimp_list_item_class_init (GimpListItemClass *klass);
|
||||
static void gimp_list_item_init (GimpListItem *list_item);
|
||||
|
||||
static void gimp_list_item_set_viewable (GimpListItem *list_item,
|
||||
GimpViewable *viewable);
|
||||
|
||||
static void gimp_list_item_real_set_viewable (GimpListItem *list_item,
|
||||
GimpViewable *viewable);
|
||||
|
||||
static void gimp_list_item_draw (GtkWidget *widget,
|
||||
GdkRectangle *area);
|
||||
static void gimp_list_item_drag_leave (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
guint time);
|
||||
static gboolean gimp_list_item_drag_motion (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time);
|
||||
static gboolean gimp_list_item_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time);
|
||||
|
||||
static void gimp_list_item_name_changed (GimpViewable *viewable,
|
||||
GtkLabel *label);
|
||||
static GimpViewable * gimp_list_item_drag_viewable (GtkWidget *widget,
|
||||
gpointer data);
|
||||
|
||||
|
||||
static guint list_item_signals[LAST_SIGNAL] = { 0 };
|
||||
|
||||
static GtkListItemClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_list_item_get_type (void)
|
||||
{
|
||||
static GtkType list_item_type = 0;
|
||||
|
||||
if (!list_item_type)
|
||||
{
|
||||
static const GtkTypeInfo list_item_info =
|
||||
{
|
||||
"GimpListItem",
|
||||
sizeof (GimpListItem),
|
||||
sizeof (GimpListItemClass),
|
||||
(GtkClassInitFunc) gimp_list_item_class_init,
|
||||
(GtkObjectInitFunc) gimp_list_item_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
list_item_type = gtk_type_unique (GTK_TYPE_LIST_ITEM, &list_item_info);
|
||||
}
|
||||
|
||||
return list_item_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_list_item_class_init (GimpListItemClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkWidgetClass *widget_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
widget_class = (GtkWidgetClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_LIST_ITEM);
|
||||
|
||||
list_item_signals[SET_VIEWABLE] =
|
||||
gtk_signal_new ("set_viewable",
|
||||
GTK_RUN_FIRST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (GimpListItemClass,
|
||||
set_viewable),
|
||||
gtk_marshal_NONE__OBJECT,
|
||||
GTK_TYPE_NONE, 1,
|
||||
GIMP_TYPE_VIEWABLE);
|
||||
|
||||
widget_class->draw = gimp_list_item_draw;
|
||||
widget_class->drag_leave = gimp_list_item_drag_leave;
|
||||
widget_class->drag_motion = gimp_list_item_drag_motion;
|
||||
widget_class->drag_drop = gimp_list_item_drag_drop;
|
||||
|
||||
klass->set_viewable = gimp_list_item_real_set_viewable;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_list_item_init (GimpListItem *list_item)
|
||||
{
|
||||
list_item->hbox = gtk_hbox_new (FALSE, 6);
|
||||
gtk_container_set_border_width (GTK_CONTAINER (list_item->hbox), 2);
|
||||
gtk_container_add (GTK_CONTAINER (list_item), list_item->hbox);
|
||||
gtk_widget_show (list_item->hbox);
|
||||
|
||||
list_item->preview = NULL;
|
||||
list_item->name_label = NULL;
|
||||
|
||||
list_item->preview_size = 0;
|
||||
|
||||
list_item->reorderable = FALSE;
|
||||
list_item->drop_type = GIMP_DROP_NONE;
|
||||
list_item->container = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_list_item_draw (GtkWidget *widget,
|
||||
GdkRectangle *area)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (widget);
|
||||
|
||||
if (GTK_WIDGET_CLASS (parent_class)->draw)
|
||||
GTK_WIDGET_CLASS (parent_class)->draw (widget, area);
|
||||
|
||||
if (list_item->drop_type != GIMP_DROP_NONE)
|
||||
{
|
||||
gint x, y;
|
||||
|
||||
x = list_item->name_label->allocation.x;
|
||||
|
||||
y = ((list_item->drop_type == GIMP_DROP_ABOVE) ?
|
||||
3 : widget->allocation.height - 4);
|
||||
|
||||
gdk_gc_set_line_attributes (widget->style->black_gc, 5, GDK_LINE_SOLID,
|
||||
GDK_CAP_BUTT, GDK_JOIN_MITER);
|
||||
|
||||
gdk_draw_line (widget->window, widget->style->black_gc,
|
||||
x, y,
|
||||
widget->allocation.width - 3, y);
|
||||
|
||||
gdk_gc_set_line_attributes (widget->style->black_gc, 0, GDK_LINE_SOLID,
|
||||
GDK_CAP_BUTT, GDK_JOIN_MITER);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_list_item_drag_leave (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
guint time)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (widget);
|
||||
|
||||
list_item->drop_type = GIMP_DROP_NONE;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_list_item_drag_motion (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
GimpViewable *src_viewable;
|
||||
gint dest_index;
|
||||
GdkDragAction drag_action;
|
||||
GimpDropType drop_type;
|
||||
gboolean return_val;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (widget);
|
||||
|
||||
return_val = gimp_list_item_check_drag (list_item, context, x, y,
|
||||
&src_viewable,
|
||||
&dest_index,
|
||||
&drag_action,
|
||||
&drop_type);
|
||||
|
||||
gdk_drag_status (context, drag_action, time);
|
||||
|
||||
list_item->drop_type = drop_type;
|
||||
|
||||
return return_val;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_list_item_drag_drop (GtkWidget *widget,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
guint time)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
GimpViewable *src_viewable;
|
||||
gint dest_index;
|
||||
GdkDragAction drag_action;
|
||||
GimpDropType drop_type;
|
||||
gboolean return_val;
|
||||
|
||||
list_item = GIMP_LIST_ITEM (widget);
|
||||
|
||||
return_val = gimp_list_item_check_drag (list_item, context, x, y,
|
||||
&src_viewable,
|
||||
&dest_index,
|
||||
&drag_action,
|
||||
&drop_type);
|
||||
|
||||
gtk_drag_finish (context, return_val, FALSE, time);
|
||||
|
||||
list_item->drop_type = GIMP_DROP_NONE;
|
||||
|
||||
if (return_val)
|
||||
{
|
||||
gimp_container_reorder (list_item->container, GIMP_OBJECT (src_viewable),
|
||||
dest_index);
|
||||
}
|
||||
|
||||
return return_val;
|
||||
}
|
||||
|
||||
GtkWidget *
|
||||
gimp_list_item_new (GimpViewable *viewable,
|
||||
gint preview_size)
|
||||
{
|
||||
GimpListItem *list_item;
|
||||
|
||||
g_return_val_if_fail (viewable != NULL, NULL);
|
||||
g_return_val_if_fail (GIMP_IS_VIEWABLE (viewable), NULL);
|
||||
g_return_val_if_fail (preview_size > 0 && preview_size <= 256, NULL);
|
||||
|
||||
if (GIMP_IS_LAYER (viewable))
|
||||
{
|
||||
list_item = gtk_type_new (GIMP_TYPE_LAYER_LIST_ITEM);
|
||||
}
|
||||
else if (GIMP_IS_DRAWABLE (viewable))
|
||||
{
|
||||
list_item = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_ITEM);
|
||||
}
|
||||
else
|
||||
{
|
||||
list_item = gtk_type_new (GIMP_TYPE_LIST_ITEM);
|
||||
}
|
||||
|
||||
list_item->preview_size = preview_size;
|
||||
|
||||
gimp_list_item_set_viewable (list_item, viewable);
|
||||
|
||||
return GTK_WIDGET (list_item);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_list_item_set_viewable (GimpListItem *list_item,
|
||||
GimpViewable *viewable)
|
||||
{
|
||||
gtk_signal_emit (GTK_OBJECT (list_item), list_item_signals[SET_VIEWABLE],
|
||||
viewable);
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_list_item_real_set_viewable (GimpListItem *list_item,
|
||||
GimpViewable *viewable)
|
||||
{
|
||||
list_item->preview = gimp_preview_new (viewable, list_item->preview_size,
|
||||
1, FALSE);
|
||||
gtk_box_pack_start (GTK_BOX (list_item->hbox), list_item->preview,
|
||||
FALSE, FALSE, 0);
|
||||
gtk_widget_show (list_item->preview);
|
||||
|
||||
list_item->name_label =
|
||||
gtk_label_new (gimp_object_get_name (GIMP_OBJECT (viewable)));
|
||||
gtk_box_pack_start (GTK_BOX (list_item->hbox), list_item->name_label,
|
||||
FALSE, FALSE, 0);
|
||||
gtk_widget_show (list_item->name_label);
|
||||
|
||||
gtk_signal_connect_while_alive (GTK_OBJECT (viewable), "name_changed",
|
||||
GTK_SIGNAL_FUNC (gimp_list_item_name_changed),
|
||||
list_item->name_label,
|
||||
GTK_OBJECT (list_item->name_label));
|
||||
|
||||
gimp_gtk_drag_source_set_by_type (GTK_WIDGET (list_item),
|
||||
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
|
||||
GTK_OBJECT (viewable)->klass->type,
|
||||
GDK_ACTION_MOVE | GDK_ACTION_COPY);
|
||||
gimp_dnd_viewable_source_set (GTK_WIDGET (list_item),
|
||||
GTK_OBJECT (viewable)->klass->type,
|
||||
gimp_list_item_drag_viewable,
|
||||
NULL);
|
||||
}
|
||||
|
||||
void
|
||||
gimp_list_item_set_reorderable (GimpListItem *list_item,
|
||||
gboolean reorderable,
|
||||
GimpContainer *container)
|
||||
{
|
||||
g_return_if_fail (list_item != NULL);
|
||||
g_return_if_fail (GIMP_IS_LIST_ITEM (list_item));
|
||||
|
||||
g_return_if_fail (! reorderable || container != NULL);
|
||||
g_return_if_fail (! container || GIMP_IS_CONTAINER (container));
|
||||
|
||||
list_item->reorderable = reorderable;
|
||||
|
||||
if (reorderable)
|
||||
{
|
||||
list_item->container = container;
|
||||
|
||||
gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (list_item),
|
||||
GTK_DEST_DEFAULT_ALL,
|
||||
container->children_type,
|
||||
GDK_ACTION_MOVE | GDK_ACTION_COPY);
|
||||
}
|
||||
else
|
||||
{
|
||||
list_item->container = NULL;
|
||||
|
||||
gtk_drag_dest_unset (GTK_WIDGET (list_item));
|
||||
}
|
||||
}
|
||||
|
||||
gboolean
|
||||
gimp_list_item_check_drag (GimpListItem *list_item,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
GimpViewable **src_viewable,
|
||||
gint *dest_index,
|
||||
GdkDragAction *drag_action,
|
||||
GimpDropType *drop_type)
|
||||
{
|
||||
GtkWidget *src_widget;
|
||||
GimpViewable *my_src_viewable = NULL;
|
||||
GimpViewable *my_dest_viewable = NULL;
|
||||
gint my_src_index = -1;
|
||||
gint my_dest_index = -1;
|
||||
GdkDragAction my_drag_action = GDK_ACTION_DEFAULT;
|
||||
GimpDropType my_drop_type = GIMP_DROP_NONE;
|
||||
gboolean return_val = FALSE;
|
||||
|
||||
if (list_item->reorderable &&
|
||||
list_item->container &&
|
||||
(src_widget = gtk_drag_get_source_widget (context)) &&
|
||||
src_widget != GTK_WIDGET (list_item))
|
||||
{
|
||||
my_src_viewable = gimp_dnd_get_drag_data (src_widget);
|
||||
my_dest_viewable = GIMP_PREVIEW (list_item->preview)->viewable;
|
||||
|
||||
if (my_src_viewable && my_dest_viewable)
|
||||
{
|
||||
my_src_index =
|
||||
gimp_container_get_child_index (list_item->container,
|
||||
GIMP_OBJECT (my_src_viewable));
|
||||
my_dest_index =
|
||||
gimp_container_get_child_index (list_item->container,
|
||||
GIMP_OBJECT (my_dest_viewable));
|
||||
|
||||
if (my_src_viewable && my_src_index != -1 &&
|
||||
my_dest_viewable && my_dest_index != -1)
|
||||
{
|
||||
gint difference;
|
||||
|
||||
difference = my_dest_index - my_src_index;
|
||||
|
||||
if (y < GTK_WIDGET (list_item)->allocation.height / 2)
|
||||
my_drop_type = GIMP_DROP_ABOVE;
|
||||
else
|
||||
my_drop_type = GIMP_DROP_BELOW;
|
||||
|
||||
if (difference < 0 && my_drop_type == GIMP_DROP_BELOW)
|
||||
{
|
||||
my_dest_index++;
|
||||
}
|
||||
else if (difference > 0 && my_drop_type == GIMP_DROP_ABOVE)
|
||||
{
|
||||
my_dest_index--;
|
||||
}
|
||||
|
||||
if (my_src_index != my_dest_index)
|
||||
{
|
||||
my_drag_action = GDK_ACTION_MOVE;
|
||||
return_val = TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
my_drop_type = GIMP_DROP_NONE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*src_viewable = my_src_viewable;
|
||||
*dest_index = my_dest_index;
|
||||
*drag_action = my_drag_action;
|
||||
*drop_type = my_drop_type;
|
||||
|
||||
return return_val;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_list_item_name_changed (GimpViewable *viewable,
|
||||
GtkLabel *label)
|
||||
{
|
||||
gtk_label_set_text (label, gimp_object_get_name (GIMP_OBJECT (viewable)));
|
||||
}
|
||||
|
||||
static GimpViewable *
|
||||
gimp_list_item_drag_viewable (GtkWidget *widget,
|
||||
gpointer data)
|
||||
{
|
||||
return GIMP_PREVIEW (GIMP_LIST_ITEM (widget)->preview)->viewable;
|
||||
}
|
|
@ -1,96 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* gimplistitem.h
|
||||
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_LIST_ITEM_H__
|
||||
#define __GIMP_LIST_ITEM_H__
|
||||
|
||||
|
||||
#include <gtk/gtklistitem.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_LIST_ITEM (gimp_list_item_get_type ())
|
||||
#define GIMP_LIST_ITEM(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LIST_ITEM, GimpListItem))
|
||||
#define GIMP_LIST_ITEM_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LIST_ITEM, GimpListItemClass))
|
||||
#define GIMP_IS_LIST_ITEM(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LIST_ITEM))
|
||||
#define GIMP_IS_LIST_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LIST_ITEM))
|
||||
|
||||
|
||||
typedef struct _GimpListItemClass GimpListItemClass;
|
||||
|
||||
struct _GimpListItem
|
||||
{
|
||||
GtkListItem parent_instance;
|
||||
|
||||
GtkWidget *hbox;
|
||||
|
||||
GtkWidget *preview;
|
||||
GtkWidget *name_label;
|
||||
|
||||
/*< protected >*/
|
||||
gint preview_size;
|
||||
|
||||
/*< private >*/
|
||||
gboolean reorderable;
|
||||
GimpContainer *container;
|
||||
GimpDropType drop_type;
|
||||
};
|
||||
|
||||
struct _GimpListItemClass
|
||||
{
|
||||
GtkListItemClass parent_class;
|
||||
|
||||
void (* set_viewable) (GimpListItem *list_item,
|
||||
GimpViewable *viewable);
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_list_item_get_type (void);
|
||||
GtkWidget * gimp_list_item_new (GimpViewable *viewable,
|
||||
gint preview_size);
|
||||
|
||||
void gimp_list_item_set_reorderable (GimpListItem *list_item,
|
||||
gboolean reorderable,
|
||||
GimpContainer *container);
|
||||
|
||||
|
||||
/* protected */
|
||||
|
||||
gboolean gimp_list_item_check_drag (GimpListItem *list_item,
|
||||
GdkDragContext *context,
|
||||
gint x,
|
||||
gint y,
|
||||
GimpViewable **src_viewable,
|
||||
gint *dest_index,
|
||||
GdkDragAction *drag_action,
|
||||
GimpDropType *drop_type);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#endif /* __GIMP_LIST_ITEM_H__ */
|
|
@ -1,175 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpPalettePreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimppalette.h"
|
||||
#include "gimppalettepreview.h"
|
||||
#include "temp_buf.h"
|
||||
|
||||
|
||||
static void gimp_palette_preview_class_init (GimpPalettePreviewClass *klass);
|
||||
static void gimp_palette_preview_init (GimpPalettePreview *preview);
|
||||
|
||||
static void gimp_palette_preview_get_size (GimpPreview *preview,
|
||||
gint size,
|
||||
gint *width,
|
||||
gint *height);
|
||||
static void gimp_palette_preview_render (GimpPreview *preview);
|
||||
static GtkWidget * gimp_palette_preview_create_popup (GimpPreview *preview);
|
||||
static gboolean gimp_palette_preview_needs_popup (GimpPreview *preview);
|
||||
|
||||
|
||||
static GimpPreviewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_palette_preview_get_type (void)
|
||||
{
|
||||
static GtkType preview_type = 0;
|
||||
|
||||
if (! preview_type)
|
||||
{
|
||||
GtkTypeInfo preview_info =
|
||||
{
|
||||
"GimpPalettePreview",
|
||||
sizeof (GimpPalettePreview),
|
||||
sizeof (GimpPalettePreviewClass),
|
||||
(GtkClassInitFunc) gimp_palette_preview_class_init,
|
||||
(GtkObjectInitFunc) gimp_palette_preview_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
preview_type = gtk_type_unique (GIMP_TYPE_PREVIEW, &preview_info);
|
||||
}
|
||||
|
||||
return preview_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_palette_preview_class_init (GimpPalettePreviewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpPreviewClass *preview_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
preview_class = (GimpPreviewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_PREVIEW);
|
||||
|
||||
preview_class->get_size = gimp_palette_preview_get_size;
|
||||
preview_class->render = gimp_palette_preview_render;
|
||||
preview_class->create_popup = gimp_palette_preview_create_popup;
|
||||
preview_class->needs_popup = gimp_palette_preview_needs_popup;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_palette_preview_init (GimpPalettePreview *palette_preview)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_palette_preview_get_size (GimpPreview *preview,
|
||||
gint size,
|
||||
gint *width,
|
||||
gint *height)
|
||||
{
|
||||
*width = size * 3;
|
||||
*height = size;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_palette_preview_render (GimpPreview *preview)
|
||||
{
|
||||
GimpPalette *palette;
|
||||
TempBuf *temp_buf;
|
||||
gint width;
|
||||
gint height;
|
||||
|
||||
palette = GIMP_PALETTE (preview->viewable);
|
||||
|
||||
width = preview->width;
|
||||
height = preview->height;
|
||||
|
||||
temp_buf = gimp_viewable_get_new_preview (preview->viewable,
|
||||
width, height);
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
temp_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
}
|
||||
|
||||
static GtkWidget *
|
||||
gimp_palette_preview_create_popup (GimpPreview *preview)
|
||||
{
|
||||
GimpPalette *palette;
|
||||
gint popup_width;
|
||||
gint popup_height;
|
||||
|
||||
palette = GIMP_PALETTE (preview->viewable);
|
||||
|
||||
if (palette->n_columns)
|
||||
popup_width = palette->n_columns;
|
||||
else
|
||||
popup_width = MIN (palette->n_colors, 16);
|
||||
|
||||
popup_height = MAX (1, palette->n_colors / popup_width);
|
||||
|
||||
return gimp_preview_new_full (preview->viewable,
|
||||
popup_width * 4,
|
||||
popup_height * 4,
|
||||
0,
|
||||
TRUE, FALSE, FALSE);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_palette_preview_needs_popup (GimpPreview *preview)
|
||||
{
|
||||
GimpPalette *palette;
|
||||
gint popup_width;
|
||||
gint popup_height;
|
||||
|
||||
palette = GIMP_PALETTE (preview->viewable);
|
||||
|
||||
if (! palette->n_colors)
|
||||
return FALSE;
|
||||
|
||||
if (palette->n_columns)
|
||||
popup_width = palette->n_columns;
|
||||
else
|
||||
popup_width = MIN (palette->n_colors, 16);
|
||||
|
||||
popup_height = MAX (1, palette->n_colors / popup_width);
|
||||
|
||||
if (popup_width * 4 > preview->width ||
|
||||
popup_height * 4 > preview->height)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
|
@ -1,61 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpPalettePreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_PALETTE_PREVIEW_H__
|
||||
#define __GIMP_PALETTE_PREVIEW_H__
|
||||
|
||||
|
||||
#include "gimppreview.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_PALETTE_PREVIEW (gimp_palette_preview_get_type ())
|
||||
#define GIMP_PALETTE_PREVIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_PALETTE_PREVIEW, GimpPalettePreview))
|
||||
#define GIMP_PALETTE_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PALETTE_PREVIEW, GimpPalettePreviewClass))
|
||||
#define GIMP_IS_PALETTE_PREVIEW(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_PALETTE_PREVIEW))
|
||||
#define GIMP_IS_PALETTE_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PALETTE_PREVIEW))
|
||||
|
||||
|
||||
typedef struct _GimpPalettePreviewClass GimpPalettePreviewClass;
|
||||
|
||||
struct _GimpPalettePreview
|
||||
{
|
||||
GimpPreview parent_instance;
|
||||
};
|
||||
|
||||
struct _GimpPalettePreviewClass
|
||||
{
|
||||
GimpPreviewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_palette_preview_get_type (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __GIMP_PALETTE_PREVIEW_H__ */
|
|
@ -1,167 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpPatternPreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimppattern.h"
|
||||
#include "gimppatternpreview.h"
|
||||
#include "temp_buf.h"
|
||||
|
||||
|
||||
static void gimp_pattern_preview_class_init (GimpPatternPreviewClass *klass);
|
||||
static void gimp_pattern_preview_init (GimpPatternPreview *preview);
|
||||
|
||||
static void gimp_pattern_preview_render (GimpPreview *preview);
|
||||
static GtkWidget * gimp_pattern_preview_create_popup (GimpPreview *preview);
|
||||
static gboolean gimp_pattern_preview_needs_popup (GimpPreview *preview);
|
||||
|
||||
|
||||
static GimpPreviewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_pattern_preview_get_type (void)
|
||||
{
|
||||
static GtkType preview_type = 0;
|
||||
|
||||
if (! preview_type)
|
||||
{
|
||||
GtkTypeInfo preview_info =
|
||||
{
|
||||
"GimpPatternPreview",
|
||||
sizeof (GimpPatternPreview),
|
||||
sizeof (GimpPatternPreviewClass),
|
||||
(GtkClassInitFunc) gimp_pattern_preview_class_init,
|
||||
(GtkObjectInitFunc) gimp_pattern_preview_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
preview_type = gtk_type_unique (GIMP_TYPE_PREVIEW, &preview_info);
|
||||
}
|
||||
|
||||
return preview_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_pattern_preview_class_init (GimpPatternPreviewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GimpPreviewClass *preview_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
preview_class = (GimpPreviewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_PREVIEW);
|
||||
|
||||
preview_class->render = gimp_pattern_preview_render;
|
||||
preview_class->create_popup = gimp_pattern_preview_create_popup;
|
||||
preview_class->needs_popup = gimp_pattern_preview_needs_popup;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_pattern_preview_init (GimpPatternPreview *pattern_preview)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_pattern_preview_render (GimpPreview *preview)
|
||||
{
|
||||
GimpPattern *pattern;
|
||||
TempBuf *temp_buf;
|
||||
gint width;
|
||||
gint height;
|
||||
gint pattern_width;
|
||||
gint pattern_height;
|
||||
|
||||
pattern = GIMP_PATTERN (preview->viewable);
|
||||
pattern_width = pattern->mask->width;
|
||||
pattern_height = pattern->mask->height;
|
||||
|
||||
width = preview->width;
|
||||
height = preview->height;
|
||||
|
||||
if (width == pattern_width &&
|
||||
height == pattern_height)
|
||||
{
|
||||
gimp_preview_render_and_flush (preview,
|
||||
pattern->mask,
|
||||
-1);
|
||||
|
||||
return;
|
||||
}
|
||||
else if (width <= pattern_width &&
|
||||
height <= pattern_height)
|
||||
{
|
||||
gimp_preview_render_and_flush (preview,
|
||||
pattern->mask,
|
||||
-1);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
temp_buf = gimp_viewable_get_new_preview (preview->viewable,
|
||||
width, height);
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
temp_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (temp_buf);
|
||||
}
|
||||
|
||||
static GtkWidget *
|
||||
gimp_pattern_preview_create_popup (GimpPreview *preview)
|
||||
{
|
||||
gint popup_width;
|
||||
gint popup_height;
|
||||
|
||||
popup_width = GIMP_PATTERN (preview->viewable)->mask->width;
|
||||
popup_height = GIMP_PATTERN (preview->viewable)->mask->height;
|
||||
|
||||
return gimp_preview_new_full (preview->viewable,
|
||||
popup_width,
|
||||
popup_height,
|
||||
0,
|
||||
TRUE, FALSE, FALSE);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_pattern_preview_needs_popup (GimpPreview *preview)
|
||||
{
|
||||
GimpPattern *pattern;
|
||||
gint pattern_width;
|
||||
gint pattern_height;
|
||||
|
||||
pattern = GIMP_PATTERN (preview->viewable);
|
||||
pattern_width = pattern->mask->width;
|
||||
pattern_height = pattern->mask->height;
|
||||
|
||||
if (pattern_width > preview->width || pattern_height > preview->height)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
|
@ -1,61 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpPatternPreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_PATTERN_PREVIEW_H__
|
||||
#define __GIMP_PATTERN_PREVIEW_H__
|
||||
|
||||
|
||||
#include "gimppreview.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_PATTERN_PREVIEW (gimp_pattern_preview_get_type ())
|
||||
#define GIMP_PATTERN_PREVIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_PATTERN_PREVIEW, GimpPatternPreview))
|
||||
#define GIMP_PATTERN_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PATTERN_PREVIEW, GimpPatternPreviewClass))
|
||||
#define GIMP_IS_PATTERN_PREVIEW(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_PATTERN_PREVIEW))
|
||||
#define GIMP_IS_PATTERN_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PATTERN_PREVIEW))
|
||||
|
||||
|
||||
typedef struct _GimpPatternPreviewClass GimpPatternPreviewClass;
|
||||
|
||||
struct _GimpPatternPreview
|
||||
{
|
||||
GimpPreview parent_instance;
|
||||
};
|
||||
|
||||
struct _GimpPatternPreviewClass
|
||||
{
|
||||
GimpPreviewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_pattern_preview_get_type (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __GIMP_PATTERN_PREVIEW_H__ */
|
1111
app/gimppreview.c
1111
app/gimppreview.c
File diff suppressed because it is too large
Load Diff
|
@ -1,125 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpPreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_PREVIEW_H__
|
||||
#define __GIMP_PREVIEW_H__
|
||||
|
||||
|
||||
#include <gtk/gtkpreview.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_PREVIEW (gimp_preview_get_type ())
|
||||
#define GIMP_PREVIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_PREVIEW, GimpPreview))
|
||||
#define GIMP_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW, GimpPreviewClass))
|
||||
#define GIMP_IS_PREVIEW(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_PREVIEW))
|
||||
#define GIMP_IS_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW))
|
||||
|
||||
|
||||
typedef struct _GimpPreviewClass GimpPreviewClass;
|
||||
|
||||
struct _GimpPreview
|
||||
{
|
||||
GtkPreview parent_instance;
|
||||
|
||||
GimpViewable *viewable;
|
||||
|
||||
gint width;
|
||||
gint height;
|
||||
gint border_width;
|
||||
|
||||
GimpRGB border_color;
|
||||
|
||||
gboolean is_popup;
|
||||
gboolean clickable;
|
||||
gboolean show_popup;
|
||||
|
||||
/*< private >*/
|
||||
gboolean in_button;
|
||||
guint idle_id;
|
||||
guint popup_id;
|
||||
gint popup_x;
|
||||
gint popup_y;
|
||||
};
|
||||
|
||||
struct _GimpPreviewClass
|
||||
{
|
||||
GtkPreviewClass parent_class;
|
||||
|
||||
void (* clicked) (GimpPreview *preview);
|
||||
void (* double_clicked) (GimpPreview *preview);
|
||||
void (* render) (GimpPreview *preview);
|
||||
void (* get_size) (GimpPreview *preview,
|
||||
gint size,
|
||||
gint *width,
|
||||
gint *height);
|
||||
gboolean (* needs_popup) (GimpPreview *preview);
|
||||
GtkWidget * (* create_popup) (GimpPreview *preview);
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_preview_get_type (void);
|
||||
|
||||
GtkWidget * gimp_preview_new (GimpViewable *viewable,
|
||||
gint size,
|
||||
gint border_width,
|
||||
gboolean is_popup);
|
||||
GtkWidget * gimp_preview_new_full (GimpViewable *viewable,
|
||||
gint width,
|
||||
gint height,
|
||||
gint border_width,
|
||||
gboolean is_popup,
|
||||
gboolean clickable,
|
||||
gboolean show_popup);
|
||||
|
||||
void gimp_preview_set_viewable (GimpPreview *preview,
|
||||
GimpViewable *viewable);
|
||||
|
||||
void gimp_preview_set_size (GimpPreview *preview,
|
||||
gint size,
|
||||
gint border_width);
|
||||
void gimp_preview_set_size_full (GimpPreview *preview,
|
||||
gint width,
|
||||
gint height,
|
||||
gint border_width);
|
||||
|
||||
void gimp_preview_set_border_color (GimpPreview *preview,
|
||||
const GimpRGB *border_color);
|
||||
|
||||
void gimp_preview_render (GimpPreview *preview);
|
||||
|
||||
|
||||
/* protected */
|
||||
|
||||
void gimp_preview_render_and_flush (GimpPreview *preview,
|
||||
TempBuf *temp_buf,
|
||||
gint channel);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __GIMP_PREVIEW_H__ */
|
|
@ -1,218 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpToolInfoPreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "tools/gimptoolinfo.h"
|
||||
|
||||
#include "gimptoolinfopreview.h"
|
||||
#include "temp_buf.h"
|
||||
|
||||
|
||||
/* FIXME: make tool icons nicer */
|
||||
#define TOOL_INFO_WIDTH 22
|
||||
#define TOOL_INFO_HEIGHT 22
|
||||
|
||||
|
||||
static void gimp_tool_info_preview_class_init (GimpToolInfoPreviewClass *klass);
|
||||
static void gimp_tool_info_preview_init (GimpToolInfoPreview *preview);
|
||||
|
||||
static void gimp_tool_info_preview_state_changed (GtkWidget *widget,
|
||||
GtkStateType previous_state);
|
||||
static void gimp_tool_info_preview_render (GimpPreview *preview);
|
||||
static GtkWidget * gimp_tool_info_preview_create_popup (GimpPreview *preview);
|
||||
static gboolean gimp_tool_info_preview_needs_popup (GimpPreview *preview);
|
||||
|
||||
|
||||
static GimpPreviewClass *parent_class = NULL;
|
||||
|
||||
|
||||
GtkType
|
||||
gimp_tool_info_preview_get_type (void)
|
||||
{
|
||||
static GtkType preview_type = 0;
|
||||
|
||||
if (! preview_type)
|
||||
{
|
||||
GtkTypeInfo preview_info =
|
||||
{
|
||||
"GimpToolInfoPreview",
|
||||
sizeof (GimpToolInfoPreview),
|
||||
sizeof (GimpToolInfoPreviewClass),
|
||||
(GtkClassInitFunc) gimp_tool_info_preview_class_init,
|
||||
(GtkObjectInitFunc) gimp_tool_info_preview_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL
|
||||
};
|
||||
|
||||
preview_type = gtk_type_unique (GIMP_TYPE_PREVIEW, &preview_info);
|
||||
}
|
||||
|
||||
return preview_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_tool_info_preview_class_init (GimpToolInfoPreviewClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkWidgetClass *widget_class;
|
||||
GimpPreviewClass *preview_class;
|
||||
|
||||
object_class = (GtkObjectClass *) klass;
|
||||
widget_class = (GtkWidgetClass *) klass;
|
||||
preview_class = (GimpPreviewClass *) klass;
|
||||
|
||||
parent_class = gtk_type_class (GIMP_TYPE_PREVIEW);
|
||||
|
||||
widget_class->state_changed = gimp_tool_info_preview_state_changed;
|
||||
|
||||
preview_class->render = gimp_tool_info_preview_render;
|
||||
preview_class->create_popup = gimp_tool_info_preview_create_popup;
|
||||
preview_class->needs_popup = gimp_tool_info_preview_needs_popup;
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_tool_info_preview_init (GimpToolInfoPreview *tool_info_preview)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_tool_info_preview_state_changed (GtkWidget *widget,
|
||||
GtkStateType previous_state)
|
||||
{
|
||||
gimp_preview_render (GIMP_PREVIEW (widget));
|
||||
}
|
||||
|
||||
static void
|
||||
gimp_tool_info_preview_render (GimpPreview *preview)
|
||||
{
|
||||
GtkWidget *widget;
|
||||
GimpToolInfo *tool_info;
|
||||
TempBuf *temp_buf;
|
||||
TempBuf *render_buf;
|
||||
guchar color[3];
|
||||
gint width;
|
||||
gint height;
|
||||
gint tool_info_width;
|
||||
gint tool_info_height;
|
||||
gint x, y;
|
||||
guchar *src;
|
||||
guchar *dest;
|
||||
gboolean new_buf = FALSE;
|
||||
|
||||
widget = GTK_WIDGET (preview);
|
||||
|
||||
tool_info = GIMP_TOOL_INFO (preview->viewable);
|
||||
tool_info_width = TOOL_INFO_WIDTH;
|
||||
tool_info_height = TOOL_INFO_HEIGHT;
|
||||
|
||||
width = preview->width;
|
||||
height = preview->height;
|
||||
|
||||
if (width == tool_info_width &&
|
||||
height == tool_info_height)
|
||||
{
|
||||
temp_buf = gimp_viewable_get_preview (preview->viewable,
|
||||
width, height);
|
||||
}
|
||||
else
|
||||
{
|
||||
temp_buf = gimp_viewable_get_new_preview (preview->viewable,
|
||||
width, height);
|
||||
new_buf = TRUE;
|
||||
}
|
||||
|
||||
color[0] = widget->style->bg[widget->state].red >> 8;
|
||||
color[1] = widget->style->bg[widget->state].green >> 8;
|
||||
color[2] = widget->style->bg[widget->state].blue >> 8;
|
||||
|
||||
render_buf = temp_buf_new (width, height, 3, 0, 0, color);
|
||||
|
||||
src = temp_buf_data (temp_buf);
|
||||
dest = temp_buf_data (render_buf);
|
||||
|
||||
for (y = 0; y < height; y++)
|
||||
{
|
||||
for (x = 0; x < width; x++)
|
||||
{
|
||||
if (src[3] != 0)
|
||||
{
|
||||
*dest++ = *src++;
|
||||
*dest++ = *src++;
|
||||
*dest++ = *src++;
|
||||
|
||||
src++;
|
||||
}
|
||||
else
|
||||
{
|
||||
src += 4;
|
||||
dest += 3;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (new_buf)
|
||||
temp_buf_free (temp_buf);
|
||||
|
||||
gimp_preview_render_and_flush (preview,
|
||||
render_buf,
|
||||
-1);
|
||||
|
||||
temp_buf_free (render_buf);
|
||||
}
|
||||
|
||||
static GtkWidget *
|
||||
gimp_tool_info_preview_create_popup (GimpPreview *preview)
|
||||
{
|
||||
gint popup_width;
|
||||
gint popup_height;
|
||||
|
||||
popup_width = TOOL_INFO_WIDTH;
|
||||
popup_height = TOOL_INFO_HEIGHT;
|
||||
|
||||
return gimp_preview_new_full (preview->viewable,
|
||||
popup_width,
|
||||
popup_height,
|
||||
0,
|
||||
TRUE, FALSE, FALSE);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gimp_tool_info_preview_needs_popup (GimpPreview *preview)
|
||||
{
|
||||
GimpToolInfo *tool_info;
|
||||
gint tool_info_width;
|
||||
gint tool_info_height;
|
||||
|
||||
tool_info = GIMP_TOOL_INFO (preview->viewable);
|
||||
tool_info_width = TOOL_INFO_WIDTH;
|
||||
tool_info_height = TOOL_INFO_HEIGHT;
|
||||
|
||||
if (tool_info_width > preview->width || tool_info_height > preview->height)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
|
@ -1,61 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* GimpToolInfoPreview Widget
|
||||
* Copyright (C) 2001 Michael Natterer
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GIMP_TOOL_INFO_PREVIEW_H__
|
||||
#define __GIMP_TOOL_INFO_PREVIEW_H__
|
||||
|
||||
|
||||
#include "gimppreview.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#define GIMP_TYPE_TOOL_INFO_PREVIEW (gimp_tool_info_preview_get_type ())
|
||||
#define GIMP_TOOL_INFO_PREVIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_TOOL_INFO_PREVIEW, GimpToolInfoPreview))
|
||||
#define GIMP_TOOL_INFO_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_TOOL_INFO_PREVIEW, GimpToolInfoPreviewClass))
|
||||
#define GIMP_IS_TOOL_INFO_PREVIEW(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_TOOL_INFO_PREVIEW))
|
||||
#define GIMP_IS_TOOL_INFO_PREVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_TOOL_INFO_PREVIEW))
|
||||
|
||||
|
||||
typedef struct _GimpToolInfoPreviewClass GimpToolInfoPreviewClass;
|
||||
|
||||
struct _GimpToolInfoPreview
|
||||
{
|
||||
GimpPreview parent_instance;
|
||||
};
|
||||
|
||||
struct _GimpToolInfoPreviewClass
|
||||
{
|
||||
GimpPreviewClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
GtkType gimp_tool_info_preview_get_type (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __GIMP_TOOL_INFO_PREVIEW_H__ */
|
|
@ -63,13 +63,14 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpcontainerlistview.h"
|
||||
|
||||
#include "color_notebook.h"
|
||||
#include "context_manager.h"
|
||||
#include "cursorutil.h"
|
||||
#include "datafiles.h"
|
||||
#include "errors.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontainerlistview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpdnd.h"
|
||||
|
|
|
@ -27,11 +27,12 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "dialog_handler.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpgradient.h"
|
||||
|
|
|
@ -1,656 +0,0 @@
|
|||
/* GTK - The GIMP Toolkit
|
||||
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
||||
*
|
||||
* GtkHWrapBox: Horizontal wrapping box widget
|
||||
* Copyright (C) 1999 Tim Janik
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library 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
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
#include "gtkhwrapbox.h"
|
||||
#include <math.h>
|
||||
|
||||
|
||||
/* --- prototypes --- */
|
||||
static void gtk_hwrap_box_class_init (GtkHWrapBoxClass *klass);
|
||||
static void gtk_hwrap_box_init (GtkHWrapBox *hwbox);
|
||||
static void gtk_hwrap_box_size_request (GtkWidget *widget,
|
||||
GtkRequisition *requisition);
|
||||
static void gtk_hwrap_box_size_allocate (GtkWidget *widget,
|
||||
GtkAllocation *allocation);
|
||||
static GSList* reverse_list_row_children (GtkWrapBox *wbox,
|
||||
GtkWrapBoxChild **child_p,
|
||||
GtkAllocation *area,
|
||||
guint *max_height,
|
||||
gboolean *can_vexpand);
|
||||
|
||||
|
||||
/* --- variables --- */
|
||||
static gpointer parent_class = NULL;
|
||||
|
||||
|
||||
/* --- functions --- */
|
||||
GtkType
|
||||
gtk_hwrap_box_get_type (void)
|
||||
{
|
||||
static GtkType hwrap_box_type = 0;
|
||||
|
||||
if (!hwrap_box_type)
|
||||
{
|
||||
static const GtkTypeInfo hwrap_box_info =
|
||||
{
|
||||
"GtkHWrapBox",
|
||||
sizeof (GtkHWrapBox),
|
||||
sizeof (GtkHWrapBoxClass),
|
||||
(GtkClassInitFunc) gtk_hwrap_box_class_init,
|
||||
(GtkObjectInitFunc) gtk_hwrap_box_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
hwrap_box_type = gtk_type_unique (GTK_TYPE_WRAP_BOX, &hwrap_box_info);
|
||||
}
|
||||
|
||||
return hwrap_box_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_hwrap_box_class_init (GtkHWrapBoxClass *class)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkWidgetClass *widget_class;
|
||||
GtkContainerClass *container_class;
|
||||
GtkWrapBoxClass *wrap_box_class;
|
||||
|
||||
object_class = GTK_OBJECT_CLASS (class);
|
||||
widget_class = GTK_WIDGET_CLASS (class);
|
||||
container_class = GTK_CONTAINER_CLASS (class);
|
||||
wrap_box_class = GTK_WRAP_BOX_CLASS (class);
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_WRAP_BOX);
|
||||
|
||||
widget_class->size_request = gtk_hwrap_box_size_request;
|
||||
widget_class->size_allocate = gtk_hwrap_box_size_allocate;
|
||||
|
||||
wrap_box_class->rlist_line_children = reverse_list_row_children;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_hwrap_box_init (GtkHWrapBox *hwbox)
|
||||
{
|
||||
hwbox->max_child_width = 0;
|
||||
hwbox->max_child_height = 0;
|
||||
}
|
||||
|
||||
GtkWidget*
|
||||
gtk_hwrap_box_new (gboolean homogeneous)
|
||||
{
|
||||
GtkHWrapBox *hwbox;
|
||||
|
||||
hwbox = GTK_HWRAP_BOX (gtk_widget_new (GTK_TYPE_HWRAP_BOX, NULL));
|
||||
|
||||
GTK_WRAP_BOX (hwbox)->homogeneous = homogeneous ? TRUE : FALSE;
|
||||
|
||||
return GTK_WIDGET (hwbox);
|
||||
}
|
||||
|
||||
static inline void
|
||||
get_child_requisition (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
GtkRequisition *child_requisition)
|
||||
{
|
||||
if (wbox->homogeneous)
|
||||
{
|
||||
GtkHWrapBox *hwbox = GTK_HWRAP_BOX (wbox);
|
||||
|
||||
child_requisition->width = hwbox->max_child_width;
|
||||
child_requisition->height = hwbox->max_child_height;
|
||||
}
|
||||
else
|
||||
gtk_widget_get_child_requisition (child, child_requisition);
|
||||
}
|
||||
|
||||
#ifdef UNUSED_CODE
|
||||
static void
|
||||
_gtk_hwrap_box_size_request (GtkWidget *widget,
|
||||
GtkRequisition *requisition)
|
||||
{
|
||||
GtkHWrapBox *this = GTK_HWRAP_BOX (widget);
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkWrapBoxChild *child;
|
||||
guint area = 0;
|
||||
|
||||
g_return_if_fail (requisition != NULL);
|
||||
|
||||
/*<h2v-off>*/
|
||||
requisition->width = 0;
|
||||
requisition->height = 0;
|
||||
this->max_child_width = 0;
|
||||
this->max_child_height = 0;
|
||||
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
if (GTK_WIDGET_VISIBLE (child->widget))
|
||||
{
|
||||
GtkRequisition child_requisition;
|
||||
|
||||
gtk_widget_size_request (child->widget, &child_requisition);
|
||||
|
||||
area += child_requisition.width * child_requisition.height;
|
||||
this->max_child_width = MAX (this->max_child_width, child_requisition.width);
|
||||
this->max_child_height = MAX (this->max_child_height, child_requisition.height);
|
||||
}
|
||||
if (wbox->homogeneous)
|
||||
area = this->max_child_width * this->max_child_height * wbox->n_children;
|
||||
|
||||
if (area)
|
||||
{
|
||||
requisition->width = sqrt (area * wbox->aspect_ratio);
|
||||
requisition->height = area / requisition->width;
|
||||
}
|
||||
else
|
||||
{
|
||||
requisition->width = 0;
|
||||
requisition->height = 0;
|
||||
}
|
||||
|
||||
requisition->width += GTK_CONTAINER (wbox)->border_width * 2;
|
||||
requisition->height += GTK_CONTAINER (wbox)->border_width * 2;
|
||||
/*<h2v-on>*/
|
||||
}
|
||||
#endif
|
||||
|
||||
static gfloat
|
||||
get_layout_size (GtkHWrapBox *this,
|
||||
guint max_width,
|
||||
guint *width_inc)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (this);
|
||||
GtkWrapBoxChild *child;
|
||||
guint n_rows, left_over = 0, total_height = 0;
|
||||
gboolean last_row_filled = TRUE;
|
||||
|
||||
*width_inc = this->max_child_width + 1;
|
||||
|
||||
n_rows = 0;
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
{
|
||||
GtkWrapBoxChild *row_child;
|
||||
GtkRequisition child_requisition;
|
||||
guint row_width, row_height, n = 1;
|
||||
|
||||
if (!GTK_WIDGET_VISIBLE (child->widget))
|
||||
continue;
|
||||
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
if (!last_row_filled)
|
||||
*width_inc = MIN (*width_inc, child_requisition.width - left_over);
|
||||
row_width = child_requisition.width;
|
||||
row_height = child_requisition.height;
|
||||
for (row_child = child->next; row_child && n < wbox->child_limit; row_child = row_child->next)
|
||||
{
|
||||
if (GTK_WIDGET_VISIBLE (row_child->widget))
|
||||
{
|
||||
get_child_requisition (wbox, row_child->widget, &child_requisition);
|
||||
if (row_width + wbox->hspacing + child_requisition.width > max_width)
|
||||
break;
|
||||
row_width += wbox->hspacing + child_requisition.width;
|
||||
row_height = MAX (row_height, child_requisition.height);
|
||||
n++;
|
||||
}
|
||||
child = row_child;
|
||||
}
|
||||
last_row_filled = n >= wbox->child_limit;
|
||||
left_over = last_row_filled ? 0 : max_width - (row_width + wbox->hspacing);
|
||||
total_height += (n_rows ? wbox->vspacing : 0) + row_height;
|
||||
n_rows++;
|
||||
}
|
||||
|
||||
if (*width_inc > this->max_child_width)
|
||||
*width_inc = 0;
|
||||
|
||||
return MAX (total_height, 1);
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_hwrap_box_size_request (GtkWidget *widget,
|
||||
GtkRequisition *requisition)
|
||||
{
|
||||
GtkHWrapBox *this = GTK_HWRAP_BOX (widget);
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkWrapBoxChild *child;
|
||||
gfloat ratio_dist, layout_width = 0;
|
||||
guint row_inc = 0;
|
||||
|
||||
g_return_if_fail (requisition != NULL);
|
||||
|
||||
requisition->width = 0;
|
||||
requisition->height = 0;
|
||||
this->max_child_width = 0;
|
||||
this->max_child_height = 0;
|
||||
|
||||
/* size_request all children */
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
if (GTK_WIDGET_VISIBLE (child->widget))
|
||||
{
|
||||
GtkRequisition child_requisition;
|
||||
|
||||
gtk_widget_size_request (child->widget, &child_requisition);
|
||||
|
||||
this->max_child_width = MAX (this->max_child_width, child_requisition.width);
|
||||
this->max_child_height = MAX (this->max_child_height, child_requisition.height);
|
||||
}
|
||||
|
||||
/* figure all possible layouts */
|
||||
ratio_dist = 32768;
|
||||
layout_width = this->max_child_width;
|
||||
do
|
||||
{
|
||||
gfloat layout_height;
|
||||
gfloat ratio, dist;
|
||||
|
||||
layout_width += row_inc;
|
||||
layout_height = get_layout_size (this, layout_width, &row_inc);
|
||||
ratio = layout_width / layout_height; /*<h2v-skip>*/
|
||||
dist = MAX (ratio, wbox->aspect_ratio) - MIN (ratio, wbox->aspect_ratio);
|
||||
if (dist < ratio_dist)
|
||||
{
|
||||
ratio_dist = dist;
|
||||
requisition->width = layout_width;
|
||||
requisition->height = layout_height;
|
||||
}
|
||||
|
||||
/* g_print ("ratio for width %d height %d = %f\n",
|
||||
(gint) layout_width,
|
||||
(gint) layout_height,
|
||||
ratio);
|
||||
*/
|
||||
}
|
||||
while (row_inc);
|
||||
|
||||
requisition->width += GTK_CONTAINER (wbox)->border_width * 2; /*<h2v-skip>*/
|
||||
requisition->height += GTK_CONTAINER (wbox)->border_width * 2; /*<h2v-skip>*/
|
||||
/* g_print ("choosen: width %d, height %d\n",
|
||||
requisition->width,
|
||||
requisition->height);
|
||||
*/
|
||||
}
|
||||
|
||||
static GSList*
|
||||
reverse_list_row_children (GtkWrapBox *wbox,
|
||||
GtkWrapBoxChild **child_p,
|
||||
GtkAllocation *area,
|
||||
guint *max_child_size,
|
||||
gboolean *expand_line)
|
||||
{
|
||||
GSList *slist = NULL;
|
||||
guint width = 0, row_width = area->width;
|
||||
GtkWrapBoxChild *child = *child_p;
|
||||
|
||||
*max_child_size = 0;
|
||||
*expand_line = FALSE;
|
||||
|
||||
while (child && !GTK_WIDGET_VISIBLE (child->widget))
|
||||
{
|
||||
*child_p = child->next;
|
||||
child = *child_p;
|
||||
}
|
||||
|
||||
if (child)
|
||||
{
|
||||
GtkRequisition child_requisition;
|
||||
guint n = 1;
|
||||
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
width += child_requisition.width;
|
||||
*max_child_size = MAX (*max_child_size, child_requisition.height);
|
||||
*expand_line |= child->vexpand;
|
||||
slist = g_slist_prepend (slist, child);
|
||||
*child_p = child->next;
|
||||
child = *child_p;
|
||||
|
||||
while (child && n < wbox->child_limit)
|
||||
{
|
||||
if (GTK_WIDGET_VISIBLE (child->widget))
|
||||
{
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
if (width + wbox->hspacing + child_requisition.width > row_width ||
|
||||
child->forced_break)
|
||||
break;
|
||||
width += wbox->hspacing + child_requisition.width;
|
||||
*max_child_size = MAX (*max_child_size, child_requisition.height);
|
||||
*expand_line |= child->vexpand;
|
||||
slist = g_slist_prepend (slist, child);
|
||||
n++;
|
||||
}
|
||||
*child_p = child->next;
|
||||
child = *child_p;
|
||||
}
|
||||
}
|
||||
|
||||
return slist;
|
||||
}
|
||||
|
||||
static void
|
||||
layout_row (GtkWrapBox *wbox,
|
||||
GtkAllocation *area,
|
||||
GSList *children,
|
||||
guint children_per_line,
|
||||
gboolean vexpand)
|
||||
{
|
||||
GSList *slist;
|
||||
guint n_children = 0, n_expand_children = 0, have_expand_children = 0, total_width = 0;
|
||||
gfloat x, width, extra;
|
||||
GtkAllocation child_allocation;
|
||||
|
||||
for (slist = children; slist; slist = slist->next)
|
||||
{
|
||||
GtkWrapBoxChild *child = slist->data;
|
||||
GtkRequisition child_requisition;
|
||||
|
||||
n_children++;
|
||||
if (child->hexpand)
|
||||
n_expand_children++;
|
||||
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
total_width += child_requisition.width;
|
||||
}
|
||||
|
||||
width = MAX (1, area->width - (n_children - 1) * wbox->hspacing);
|
||||
if (width > total_width)
|
||||
extra = width - total_width;
|
||||
else
|
||||
extra = 0;
|
||||
have_expand_children = n_expand_children && extra;
|
||||
|
||||
x = area->x;
|
||||
if (wbox->homogeneous)
|
||||
{
|
||||
width = MAX (1, area->width - (children_per_line - 1) * wbox->hspacing);
|
||||
width /= ((gdouble) children_per_line);
|
||||
extra = 0;
|
||||
}
|
||||
else if (have_expand_children && wbox->justify != GTK_JUSTIFY_FILL)
|
||||
{
|
||||
width = extra;
|
||||
extra /= ((gdouble) n_expand_children);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (wbox->justify == GTK_JUSTIFY_FILL)
|
||||
{
|
||||
width = extra;
|
||||
have_expand_children = TRUE;
|
||||
n_expand_children = n_children;
|
||||
extra /= ((gdouble) n_expand_children);
|
||||
}
|
||||
else if (wbox->justify == GTK_JUSTIFY_CENTER)
|
||||
{
|
||||
x += extra / 2;
|
||||
width = 0;
|
||||
extra = 0;
|
||||
}
|
||||
else if (wbox->justify == GTK_JUSTIFY_LEFT)
|
||||
{
|
||||
width = 0;
|
||||
extra = 0;
|
||||
}
|
||||
else if (wbox->justify == GTK_JUSTIFY_RIGHT)
|
||||
{
|
||||
x += extra;
|
||||
width = 0;
|
||||
extra = 0;
|
||||
}
|
||||
}
|
||||
|
||||
n_children = 0;
|
||||
for (slist = children; slist; slist = slist->next)
|
||||
{
|
||||
GtkWrapBoxChild *child = slist->data;
|
||||
|
||||
child_allocation.x = x;
|
||||
child_allocation.y = area->y;
|
||||
if (wbox->homogeneous)
|
||||
{
|
||||
child_allocation.height = area->height;
|
||||
child_allocation.width = width;
|
||||
x += child_allocation.width + wbox->hspacing;
|
||||
}
|
||||
else
|
||||
{
|
||||
GtkRequisition child_requisition;
|
||||
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
|
||||
if (child_requisition.height >= area->height)
|
||||
child_allocation.height = area->height;
|
||||
else
|
||||
{
|
||||
child_allocation.height = child_requisition.height;
|
||||
if (wbox->line_justify == GTK_JUSTIFY_FILL || child->vfill)
|
||||
child_allocation.height = area->height;
|
||||
else if (child->vexpand || wbox->line_justify == GTK_JUSTIFY_CENTER)
|
||||
child_allocation.y += (area->height - child_requisition.height) / 2;
|
||||
else if (wbox->line_justify == GTK_JUSTIFY_BOTTOM)
|
||||
child_allocation.y += area->height - child_requisition.height;
|
||||
}
|
||||
|
||||
if (have_expand_children)
|
||||
{
|
||||
child_allocation.width = child_requisition.width;
|
||||
if (child->hexpand || wbox->justify == GTK_JUSTIFY_FILL)
|
||||
{
|
||||
guint space;
|
||||
|
||||
n_expand_children--;
|
||||
space = extra * n_expand_children;
|
||||
space = width - space;
|
||||
width -= space;
|
||||
if (child->hfill)
|
||||
child_allocation.width += space;
|
||||
else
|
||||
{
|
||||
child_allocation.x += space / 2;
|
||||
x += space;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* g_print ("child_allocation.x %d += %d * %f ",
|
||||
child_allocation.x, n_children, extra); */
|
||||
child_allocation.x += n_children * extra;
|
||||
/* g_print ("= %d\n",
|
||||
child_allocation.x); */
|
||||
child_allocation.width = MIN (child_requisition.width,
|
||||
area->width - child_allocation.x + area->x);
|
||||
}
|
||||
}
|
||||
|
||||
x += child_allocation.width + wbox->hspacing;
|
||||
gtk_widget_size_allocate (child->widget, &child_allocation);
|
||||
n_children++;
|
||||
}
|
||||
}
|
||||
|
||||
typedef struct _Line Line;
|
||||
struct _Line
|
||||
{
|
||||
GSList *children;
|
||||
guint16 min_size;
|
||||
guint expand : 1;
|
||||
Line *next;
|
||||
};
|
||||
|
||||
static void
|
||||
layout_rows (GtkWrapBox *wbox,
|
||||
GtkAllocation *area)
|
||||
{
|
||||
GtkWrapBoxChild *next_child;
|
||||
guint min_height;
|
||||
gboolean vexpand;
|
||||
GSList *slist;
|
||||
Line *line_list = NULL;
|
||||
guint total_height = 0, n_expand_lines = 0, n_lines = 0;
|
||||
gfloat shrink_height;
|
||||
guint children_per_line;
|
||||
|
||||
next_child = wbox->children;
|
||||
slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
|
||||
&next_child,
|
||||
area,
|
||||
&min_height,
|
||||
&vexpand);
|
||||
slist = g_slist_reverse (slist);
|
||||
|
||||
children_per_line = g_slist_length (slist);
|
||||
while (slist)
|
||||
{
|
||||
Line *line = g_new (Line, 1);
|
||||
|
||||
line->children = slist;
|
||||
line->min_size = min_height;
|
||||
total_height += min_height;
|
||||
line->expand = vexpand;
|
||||
if (vexpand)
|
||||
n_expand_lines++;
|
||||
line->next = line_list;
|
||||
line_list = line;
|
||||
n_lines++;
|
||||
|
||||
slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
|
||||
&next_child,
|
||||
area,
|
||||
&min_height,
|
||||
&vexpand);
|
||||
slist = g_slist_reverse (slist);
|
||||
}
|
||||
|
||||
if (total_height > area->height)
|
||||
shrink_height = total_height - area->height;
|
||||
else
|
||||
shrink_height = 0;
|
||||
|
||||
if (1) /* reverse lines and shrink */
|
||||
{
|
||||
Line *prev = NULL, *last = NULL;
|
||||
gfloat n_shrink_lines = n_lines;
|
||||
|
||||
while (line_list)
|
||||
{
|
||||
Line *tmp = line_list->next;
|
||||
|
||||
if (shrink_height)
|
||||
{
|
||||
Line *line = line_list;
|
||||
guint shrink_fract = shrink_height / n_shrink_lines + 0.5;
|
||||
|
||||
if (line->min_size > shrink_fract)
|
||||
{
|
||||
shrink_height -= shrink_fract;
|
||||
line->min_size -= shrink_fract;
|
||||
}
|
||||
else
|
||||
{
|
||||
shrink_height -= line->min_size - 1;
|
||||
line->min_size = 1;
|
||||
}
|
||||
}
|
||||
n_shrink_lines--;
|
||||
|
||||
last = line_list;
|
||||
line_list->next = prev;
|
||||
prev = line_list;
|
||||
line_list = tmp;
|
||||
}
|
||||
line_list = last;
|
||||
}
|
||||
|
||||
if (n_lines)
|
||||
{
|
||||
Line *line;
|
||||
gfloat y, height, extra = 0;
|
||||
|
||||
height = area->height;
|
||||
height = MAX (n_lines, height - (n_lines - 1) * wbox->vspacing);
|
||||
|
||||
if (wbox->homogeneous)
|
||||
height /= ((gdouble) n_lines);
|
||||
else if (n_expand_lines)
|
||||
{
|
||||
height = MAX (0, height - total_height);
|
||||
extra = height / ((gdouble) n_expand_lines);
|
||||
}
|
||||
else
|
||||
height = 0;
|
||||
|
||||
y = area->y;
|
||||
line = line_list;
|
||||
while (line)
|
||||
{
|
||||
GtkAllocation row_allocation;
|
||||
Line *next_line = line->next;
|
||||
|
||||
row_allocation.x = area->x;
|
||||
row_allocation.width = area->width;
|
||||
if (wbox->homogeneous)
|
||||
row_allocation.height = height;
|
||||
else
|
||||
{
|
||||
row_allocation.height = line->min_size;
|
||||
|
||||
if (line->expand)
|
||||
row_allocation.height += extra;
|
||||
}
|
||||
|
||||
row_allocation.y = y;
|
||||
|
||||
y += row_allocation.height + wbox->vspacing;
|
||||
layout_row (wbox,
|
||||
&row_allocation,
|
||||
line->children,
|
||||
children_per_line,
|
||||
line->expand);
|
||||
|
||||
g_slist_free (line->children);
|
||||
g_free (line);
|
||||
line = next_line;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_hwrap_box_size_allocate (GtkWidget *widget,
|
||||
GtkAllocation *allocation)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkAllocation area;
|
||||
guint border = GTK_CONTAINER (wbox)->border_width; /*<h2v-skip>*/
|
||||
|
||||
widget->allocation = *allocation;
|
||||
area.x = allocation->x + border;
|
||||
area.y = allocation->y + border;
|
||||
area.width = MAX (1, (gint) allocation->width - border * 2);
|
||||
area.height = MAX (1, (gint) allocation->height - border * 2);
|
||||
|
||||
/*<h2v-off>*/
|
||||
/* g_print ("got: width %d, height %d\n",
|
||||
allocation->width,
|
||||
allocation->height);
|
||||
*/
|
||||
/*<h2v-on>*/
|
||||
|
||||
layout_rows (wbox, &area);
|
||||
}
|
|
@ -1,75 +0,0 @@
|
|||
/* GTK - The GIMP Toolkit
|
||||
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
||||
*
|
||||
* GtkHWrapBox: Horizontal wrapping box widget
|
||||
* Copyright (C) 1999 Tim Janik
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library 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
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
#ifndef __GTK_HWRAP_BOX_H__
|
||||
#define __GTK_HWRAP_BOX_H__
|
||||
|
||||
|
||||
#include "gtkwrapbox.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
/* --- type macros --- */
|
||||
#define GTK_TYPE_HWRAP_BOX (gtk_hwrap_box_get_type ())
|
||||
#define GTK_HWRAP_BOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_HWRAP_BOX, GtkHWrapBox))
|
||||
#define GTK_HWRAP_BOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_HWRAP_BOX, GtkHWrapBoxClass))
|
||||
#define GTK_IS_HWRAP_BOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_HWRAP_BOX))
|
||||
#define GTK_IS_HWRAP_BOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HWRAP_BOX))
|
||||
#define GTK_HWRAP_BOX_GET_CLASS(obj) (GTK_HWRAP_BOX_CLASS (((GtkObject*) (obj))->klass))
|
||||
|
||||
|
||||
/* --- typedefs --- */
|
||||
typedef struct _GtkHWrapBox GtkHWrapBox;
|
||||
typedef struct _GtkHWrapBoxClass GtkHWrapBoxClass;
|
||||
|
||||
|
||||
/* --- GtkHWrapBox --- */
|
||||
struct _GtkHWrapBox
|
||||
{
|
||||
GtkWrapBox parent_widget;
|
||||
|
||||
/*<h2v-off>*/
|
||||
guint16 max_child_width;
|
||||
guint16 max_child_height;
|
||||
/*<h2v-on>*/
|
||||
};
|
||||
|
||||
struct _GtkHWrapBoxClass
|
||||
{
|
||||
GtkWrapBoxClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
/* --- prototypes --- */
|
||||
GtkType gtk_hwrap_box_get_type (void);
|
||||
GtkWidget* gtk_hwrap_box_new (gboolean homogeneous);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#endif /* __GTK_HWRAP_BOX_H__ */
|
|
@ -1,656 +0,0 @@
|
|||
/* GTK - The GIMP Toolkit
|
||||
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
||||
*
|
||||
* GtkVWrapBox: Vertical wrapping box widget
|
||||
* Copyright (C) 1999 Tim Janik
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library 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
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
#include "gtkvwrapbox.h"
|
||||
#include <math.h>
|
||||
|
||||
|
||||
/* --- prototypes --- */
|
||||
static void gtk_vwrap_box_class_init (GtkVWrapBoxClass *klass);
|
||||
static void gtk_vwrap_box_init (GtkVWrapBox *vwbox);
|
||||
static void gtk_vwrap_box_size_request (GtkWidget *widget,
|
||||
GtkRequisition *requisition);
|
||||
static void gtk_vwrap_box_size_allocate (GtkWidget *widget,
|
||||
GtkAllocation *allocation);
|
||||
static GSList* reverse_list_col_children (GtkWrapBox *wbox,
|
||||
GtkWrapBoxChild **child_p,
|
||||
GtkAllocation *area,
|
||||
guint *max_width,
|
||||
gboolean *can_hexpand);
|
||||
|
||||
|
||||
/* --- variables --- */
|
||||
static gpointer parent_class = NULL;
|
||||
|
||||
|
||||
/* --- functions --- */
|
||||
GtkType
|
||||
gtk_vwrap_box_get_type (void)
|
||||
{
|
||||
static GtkType vwrap_box_type = 0;
|
||||
|
||||
if (!vwrap_box_type)
|
||||
{
|
||||
static const GtkTypeInfo vwrap_box_info =
|
||||
{
|
||||
"GtkVWrapBox",
|
||||
sizeof (GtkVWrapBox),
|
||||
sizeof (GtkVWrapBoxClass),
|
||||
(GtkClassInitFunc) gtk_vwrap_box_class_init,
|
||||
(GtkObjectInitFunc) gtk_vwrap_box_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
vwrap_box_type = gtk_type_unique (GTK_TYPE_WRAP_BOX, &vwrap_box_info);
|
||||
}
|
||||
|
||||
return vwrap_box_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_vwrap_box_class_init (GtkVWrapBoxClass *class)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkWidgetClass *widget_class;
|
||||
GtkContainerClass *container_class;
|
||||
GtkWrapBoxClass *wrap_box_class;
|
||||
|
||||
object_class = GTK_OBJECT_CLASS (class);
|
||||
widget_class = GTK_WIDGET_CLASS (class);
|
||||
container_class = GTK_CONTAINER_CLASS (class);
|
||||
wrap_box_class = GTK_WRAP_BOX_CLASS (class);
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_WRAP_BOX);
|
||||
|
||||
widget_class->size_request = gtk_vwrap_box_size_request;
|
||||
widget_class->size_allocate = gtk_vwrap_box_size_allocate;
|
||||
|
||||
wrap_box_class->rlist_line_children = reverse_list_col_children;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_vwrap_box_init (GtkVWrapBox *vwbox)
|
||||
{
|
||||
vwbox->max_child_height = 0;
|
||||
vwbox->max_child_width = 0;
|
||||
}
|
||||
|
||||
GtkWidget*
|
||||
gtk_vwrap_box_new (gboolean homogeneous)
|
||||
{
|
||||
GtkVWrapBox *vwbox;
|
||||
|
||||
vwbox = GTK_VWRAP_BOX (gtk_widget_new (GTK_TYPE_VWRAP_BOX, NULL));
|
||||
|
||||
GTK_WRAP_BOX (vwbox)->homogeneous = homogeneous ? TRUE : FALSE;
|
||||
|
||||
return GTK_WIDGET (vwbox);
|
||||
}
|
||||
|
||||
static inline void
|
||||
get_child_requisition (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
GtkRequisition *child_requisition)
|
||||
{
|
||||
if (wbox->homogeneous)
|
||||
{
|
||||
GtkVWrapBox *vwbox = GTK_VWRAP_BOX (wbox);
|
||||
|
||||
child_requisition->height = vwbox->max_child_height;
|
||||
child_requisition->width = vwbox->max_child_width;
|
||||
}
|
||||
else
|
||||
gtk_widget_get_child_requisition (child, child_requisition);
|
||||
}
|
||||
|
||||
#ifdef UNUSED_CODE
|
||||
static void
|
||||
_gtk_vwrap_box_size_request (GtkWidget *widget,
|
||||
GtkRequisition *requisition)
|
||||
{
|
||||
GtkVWrapBox *this = GTK_VWRAP_BOX (widget);
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkWrapBoxChild *child;
|
||||
guint area = 0;
|
||||
|
||||
g_return_if_fail (requisition != NULL);
|
||||
|
||||
/*<h2v-off>*/
|
||||
requisition->width = 0;
|
||||
requisition->height = 0;
|
||||
this->max_child_width = 0;
|
||||
this->max_child_height = 0;
|
||||
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
if (GTK_WIDGET_VISIBLE (child->widget))
|
||||
{
|
||||
GtkRequisition child_requisition;
|
||||
|
||||
gtk_widget_size_request (child->widget, &child_requisition);
|
||||
|
||||
area += child_requisition.width * child_requisition.height;
|
||||
this->max_child_width = MAX (this->max_child_width, child_requisition.width);
|
||||
this->max_child_height = MAX (this->max_child_height, child_requisition.height);
|
||||
}
|
||||
if (wbox->homogeneous)
|
||||
area = this->max_child_width * this->max_child_height * wbox->n_children;
|
||||
|
||||
if (area)
|
||||
{
|
||||
requisition->width = sqrt (area * wbox->aspect_ratio);
|
||||
requisition->height = area / requisition->width;
|
||||
}
|
||||
else
|
||||
{
|
||||
requisition->width = 0;
|
||||
requisition->height = 0;
|
||||
}
|
||||
|
||||
requisition->width += GTK_CONTAINER (wbox)->border_width * 2;
|
||||
requisition->height += GTK_CONTAINER (wbox)->border_width * 2;
|
||||
/*<h2v-on>*/
|
||||
}
|
||||
#endif
|
||||
|
||||
static gfloat
|
||||
get_layout_size (GtkVWrapBox *this,
|
||||
guint max_height,
|
||||
guint *height_inc)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (this);
|
||||
GtkWrapBoxChild *child;
|
||||
guint n_cols, left_over = 0, total_width = 0;
|
||||
gboolean last_col_filled = TRUE;
|
||||
|
||||
*height_inc = this->max_child_height + 1;
|
||||
|
||||
n_cols = 0;
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
{
|
||||
GtkWrapBoxChild *col_child;
|
||||
GtkRequisition child_requisition;
|
||||
guint col_height, col_width, n = 1;
|
||||
|
||||
if (!GTK_WIDGET_VISIBLE (child->widget))
|
||||
continue;
|
||||
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
if (!last_col_filled)
|
||||
*height_inc = MIN (*height_inc, child_requisition.height - left_over);
|
||||
col_height = child_requisition.height;
|
||||
col_width = child_requisition.width;
|
||||
for (col_child = child->next; col_child && n < wbox->child_limit; col_child = col_child->next)
|
||||
{
|
||||
if (GTK_WIDGET_VISIBLE (col_child->widget))
|
||||
{
|
||||
get_child_requisition (wbox, col_child->widget, &child_requisition);
|
||||
if (col_height + wbox->vspacing + child_requisition.height > max_height)
|
||||
break;
|
||||
col_height += wbox->vspacing + child_requisition.height;
|
||||
col_width = MAX (col_width, child_requisition.width);
|
||||
n++;
|
||||
}
|
||||
child = col_child;
|
||||
}
|
||||
last_col_filled = n >= wbox->child_limit;
|
||||
left_over = last_col_filled ? 0 : max_height - (col_height + wbox->vspacing);
|
||||
total_width += (n_cols ? wbox->hspacing : 0) + col_width;
|
||||
n_cols++;
|
||||
}
|
||||
|
||||
if (*height_inc > this->max_child_height)
|
||||
*height_inc = 0;
|
||||
|
||||
return MAX (total_width, 1);
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_vwrap_box_size_request (GtkWidget *widget,
|
||||
GtkRequisition *requisition)
|
||||
{
|
||||
GtkVWrapBox *this = GTK_VWRAP_BOX (widget);
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkWrapBoxChild *child;
|
||||
gfloat ratio_dist, layout_height = 0;
|
||||
guint col_inc = 0;
|
||||
|
||||
g_return_if_fail (requisition != NULL);
|
||||
|
||||
requisition->height = 0;
|
||||
requisition->width = 0;
|
||||
this->max_child_height = 0;
|
||||
this->max_child_width = 0;
|
||||
|
||||
/* size_request all children */
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
if (GTK_WIDGET_VISIBLE (child->widget))
|
||||
{
|
||||
GtkRequisition child_requisition;
|
||||
|
||||
gtk_widget_size_request (child->widget, &child_requisition);
|
||||
|
||||
this->max_child_height = MAX (this->max_child_height, child_requisition.height);
|
||||
this->max_child_width = MAX (this->max_child_width, child_requisition.width);
|
||||
}
|
||||
|
||||
/* figure all possible layouts */
|
||||
ratio_dist = 32768;
|
||||
layout_height = this->max_child_height;
|
||||
do
|
||||
{
|
||||
gfloat layout_width;
|
||||
gfloat ratio, dist;
|
||||
|
||||
layout_height += col_inc;
|
||||
layout_width = get_layout_size (this, layout_height, &col_inc);
|
||||
ratio = layout_width / layout_height; /*<h2v-skip>*/
|
||||
dist = MAX (ratio, wbox->aspect_ratio) - MIN (ratio, wbox->aspect_ratio);
|
||||
if (dist < ratio_dist)
|
||||
{
|
||||
ratio_dist = dist;
|
||||
requisition->height = layout_height;
|
||||
requisition->width = layout_width;
|
||||
}
|
||||
|
||||
/* g_print ("ratio for height %d width %d = %f\n",
|
||||
(gint) layout_height,
|
||||
(gint) layout_width,
|
||||
ratio);
|
||||
*/
|
||||
}
|
||||
while (col_inc);
|
||||
|
||||
requisition->width += GTK_CONTAINER (wbox)->border_width * 2; /*<h2v-skip>*/
|
||||
requisition->height += GTK_CONTAINER (wbox)->border_width * 2; /*<h2v-skip>*/
|
||||
/* g_print ("choosen: height %d, width %d\n",
|
||||
requisition->height,
|
||||
requisition->width);
|
||||
*/
|
||||
}
|
||||
|
||||
static GSList*
|
||||
reverse_list_col_children (GtkWrapBox *wbox,
|
||||
GtkWrapBoxChild **child_p,
|
||||
GtkAllocation *area,
|
||||
guint *max_child_size,
|
||||
gboolean *expand_line)
|
||||
{
|
||||
GSList *slist = NULL;
|
||||
guint height = 0, col_height = area->height;
|
||||
GtkWrapBoxChild *child = *child_p;
|
||||
|
||||
*max_child_size = 0;
|
||||
*expand_line = FALSE;
|
||||
|
||||
while (child && !GTK_WIDGET_VISIBLE (child->widget))
|
||||
{
|
||||
*child_p = child->next;
|
||||
child = *child_p;
|
||||
}
|
||||
|
||||
if (child)
|
||||
{
|
||||
GtkRequisition child_requisition;
|
||||
guint n = 1;
|
||||
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
height += child_requisition.height;
|
||||
*max_child_size = MAX (*max_child_size, child_requisition.width);
|
||||
*expand_line |= child->hexpand;
|
||||
slist = g_slist_prepend (slist, child);
|
||||
*child_p = child->next;
|
||||
child = *child_p;
|
||||
|
||||
while (child && n < wbox->child_limit)
|
||||
{
|
||||
if (GTK_WIDGET_VISIBLE (child->widget))
|
||||
{
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
if (height + wbox->vspacing + child_requisition.height > col_height ||
|
||||
child->forced_break)
|
||||
break;
|
||||
height += wbox->vspacing + child_requisition.height;
|
||||
*max_child_size = MAX (*max_child_size, child_requisition.width);
|
||||
*expand_line |= child->hexpand;
|
||||
slist = g_slist_prepend (slist, child);
|
||||
n++;
|
||||
}
|
||||
*child_p = child->next;
|
||||
child = *child_p;
|
||||
}
|
||||
}
|
||||
|
||||
return slist;
|
||||
}
|
||||
|
||||
static void
|
||||
layout_col (GtkWrapBox *wbox,
|
||||
GtkAllocation *area,
|
||||
GSList *children,
|
||||
guint children_per_line,
|
||||
gboolean hexpand)
|
||||
{
|
||||
GSList *slist;
|
||||
guint n_children = 0, n_expand_children = 0, have_expand_children = 0, total_height = 0;
|
||||
gfloat y, height, extra;
|
||||
GtkAllocation child_allocation;
|
||||
|
||||
for (slist = children; slist; slist = slist->next)
|
||||
{
|
||||
GtkWrapBoxChild *child = slist->data;
|
||||
GtkRequisition child_requisition;
|
||||
|
||||
n_children++;
|
||||
if (child->vexpand)
|
||||
n_expand_children++;
|
||||
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
total_height += child_requisition.height;
|
||||
}
|
||||
|
||||
height = MAX (1, area->height - (n_children - 1) * wbox->vspacing);
|
||||
if (height > total_height)
|
||||
extra = height - total_height;
|
||||
else
|
||||
extra = 0;
|
||||
have_expand_children = n_expand_children && extra;
|
||||
|
||||
y = area->y;
|
||||
if (wbox->homogeneous)
|
||||
{
|
||||
height = MAX (1, area->height - (children_per_line - 1) * wbox->vspacing);
|
||||
height /= ((gdouble) children_per_line);
|
||||
extra = 0;
|
||||
}
|
||||
else if (have_expand_children && wbox->justify != GTK_JUSTIFY_FILL)
|
||||
{
|
||||
height = extra;
|
||||
extra /= ((gdouble) n_expand_children);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (wbox->justify == GTK_JUSTIFY_FILL)
|
||||
{
|
||||
height = extra;
|
||||
have_expand_children = TRUE;
|
||||
n_expand_children = n_children;
|
||||
extra /= ((gdouble) n_expand_children);
|
||||
}
|
||||
else if (wbox->justify == GTK_JUSTIFY_CENTER)
|
||||
{
|
||||
y += extra / 2;
|
||||
height = 0;
|
||||
extra = 0;
|
||||
}
|
||||
else if (wbox->justify == GTK_JUSTIFY_LEFT)
|
||||
{
|
||||
height = 0;
|
||||
extra = 0;
|
||||
}
|
||||
else if (wbox->justify == GTK_JUSTIFY_RIGHT)
|
||||
{
|
||||
y += extra;
|
||||
height = 0;
|
||||
extra = 0;
|
||||
}
|
||||
}
|
||||
|
||||
n_children = 0;
|
||||
for (slist = children; slist; slist = slist->next)
|
||||
{
|
||||
GtkWrapBoxChild *child = slist->data;
|
||||
|
||||
child_allocation.y = y;
|
||||
child_allocation.x = area->x;
|
||||
if (wbox->homogeneous)
|
||||
{
|
||||
child_allocation.width = area->width;
|
||||
child_allocation.height = height;
|
||||
y += child_allocation.height + wbox->vspacing;
|
||||
}
|
||||
else
|
||||
{
|
||||
GtkRequisition child_requisition;
|
||||
|
||||
get_child_requisition (wbox, child->widget, &child_requisition);
|
||||
|
||||
if (child_requisition.width >= area->width)
|
||||
child_allocation.width = area->width;
|
||||
else
|
||||
{
|
||||
child_allocation.width = child_requisition.width;
|
||||
if (wbox->line_justify == GTK_JUSTIFY_FILL || child->hfill)
|
||||
child_allocation.width = area->width;
|
||||
else if (child->hexpand || wbox->line_justify == GTK_JUSTIFY_CENTER)
|
||||
child_allocation.x += (area->width - child_requisition.width) / 2;
|
||||
else if (wbox->line_justify == GTK_JUSTIFY_BOTTOM)
|
||||
child_allocation.x += area->width - child_requisition.width;
|
||||
}
|
||||
|
||||
if (have_expand_children)
|
||||
{
|
||||
child_allocation.height = child_requisition.height;
|
||||
if (child->vexpand || wbox->justify == GTK_JUSTIFY_FILL)
|
||||
{
|
||||
guint space;
|
||||
|
||||
n_expand_children--;
|
||||
space = extra * n_expand_children;
|
||||
space = height - space;
|
||||
height -= space;
|
||||
if (child->vfill)
|
||||
child_allocation.height += space;
|
||||
else
|
||||
{
|
||||
child_allocation.y += space / 2;
|
||||
y += space;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* g_print ("child_allocation.y %d += %d * %f ",
|
||||
child_allocation.y, n_children, extra); */
|
||||
child_allocation.y += n_children * extra;
|
||||
/* g_print ("= %d\n",
|
||||
child_allocation.y); */
|
||||
child_allocation.height = MIN (child_requisition.height,
|
||||
area->height - child_allocation.y + area->y);
|
||||
}
|
||||
}
|
||||
|
||||
y += child_allocation.height + wbox->vspacing;
|
||||
gtk_widget_size_allocate (child->widget, &child_allocation);
|
||||
n_children++;
|
||||
}
|
||||
}
|
||||
|
||||
typedef struct _Line Line;
|
||||
struct _Line
|
||||
{
|
||||
GSList *children;
|
||||
guint16 min_size;
|
||||
guint expand : 1;
|
||||
Line *next;
|
||||
};
|
||||
|
||||
static void
|
||||
layout_cols (GtkWrapBox *wbox,
|
||||
GtkAllocation *area)
|
||||
{
|
||||
GtkWrapBoxChild *next_child;
|
||||
guint min_width;
|
||||
gboolean hexpand;
|
||||
GSList *slist;
|
||||
Line *line_list = NULL;
|
||||
guint total_width = 0, n_expand_lines = 0, n_lines = 0;
|
||||
gfloat shrink_width;
|
||||
guint children_per_line;
|
||||
|
||||
next_child = wbox->children;
|
||||
slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
|
||||
&next_child,
|
||||
area,
|
||||
&min_width,
|
||||
&hexpand);
|
||||
slist = g_slist_reverse (slist);
|
||||
|
||||
children_per_line = g_slist_length (slist);
|
||||
while (slist)
|
||||
{
|
||||
Line *line = g_new (Line, 1);
|
||||
|
||||
line->children = slist;
|
||||
line->min_size = min_width;
|
||||
total_width += min_width;
|
||||
line->expand = hexpand;
|
||||
if (hexpand)
|
||||
n_expand_lines++;
|
||||
line->next = line_list;
|
||||
line_list = line;
|
||||
n_lines++;
|
||||
|
||||
slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
|
||||
&next_child,
|
||||
area,
|
||||
&min_width,
|
||||
&hexpand);
|
||||
slist = g_slist_reverse (slist);
|
||||
}
|
||||
|
||||
if (total_width > area->width)
|
||||
shrink_width = total_width - area->width;
|
||||
else
|
||||
shrink_width = 0;
|
||||
|
||||
if (1) /* reverse lines and shrink */
|
||||
{
|
||||
Line *prev = NULL, *last = NULL;
|
||||
gfloat n_shrink_lines = n_lines;
|
||||
|
||||
while (line_list)
|
||||
{
|
||||
Line *tmp = line_list->next;
|
||||
|
||||
if (shrink_width)
|
||||
{
|
||||
Line *line = line_list;
|
||||
guint shrink_fract = shrink_width / n_shrink_lines + 0.5;
|
||||
|
||||
if (line->min_size > shrink_fract)
|
||||
{
|
||||
shrink_width -= shrink_fract;
|
||||
line->min_size -= shrink_fract;
|
||||
}
|
||||
else
|
||||
{
|
||||
shrink_width -= line->min_size - 1;
|
||||
line->min_size = 1;
|
||||
}
|
||||
}
|
||||
n_shrink_lines--;
|
||||
|
||||
last = line_list;
|
||||
line_list->next = prev;
|
||||
prev = line_list;
|
||||
line_list = tmp;
|
||||
}
|
||||
line_list = last;
|
||||
}
|
||||
|
||||
if (n_lines)
|
||||
{
|
||||
Line *line;
|
||||
gfloat x, width, extra = 0;
|
||||
|
||||
width = area->width;
|
||||
width = MAX (n_lines, width - (n_lines - 1) * wbox->hspacing);
|
||||
|
||||
if (wbox->homogeneous)
|
||||
width /= ((gdouble) n_lines);
|
||||
else if (n_expand_lines)
|
||||
{
|
||||
width = MAX (0, width - total_width);
|
||||
extra = width / ((gdouble) n_expand_lines);
|
||||
}
|
||||
else
|
||||
width = 0;
|
||||
|
||||
x = area->x;
|
||||
line = line_list;
|
||||
while (line)
|
||||
{
|
||||
GtkAllocation col_allocation;
|
||||
Line *next_line = line->next;
|
||||
|
||||
col_allocation.y = area->y;
|
||||
col_allocation.height = area->height;
|
||||
if (wbox->homogeneous)
|
||||
col_allocation.width = width;
|
||||
else
|
||||
{
|
||||
col_allocation.width = line->min_size;
|
||||
|
||||
if (line->expand)
|
||||
col_allocation.width += extra;
|
||||
}
|
||||
|
||||
col_allocation.x = x;
|
||||
|
||||
x += col_allocation.width + wbox->hspacing;
|
||||
layout_col (wbox,
|
||||
&col_allocation,
|
||||
line->children,
|
||||
children_per_line,
|
||||
line->expand);
|
||||
|
||||
g_slist_free (line->children);
|
||||
g_free (line);
|
||||
line = next_line;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_vwrap_box_size_allocate (GtkWidget *widget,
|
||||
GtkAllocation *allocation)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkAllocation area;
|
||||
guint border = GTK_CONTAINER (wbox)->border_width; /*<h2v-skip>*/
|
||||
|
||||
widget->allocation = *allocation;
|
||||
area.y = allocation->y + border;
|
||||
area.x = allocation->x + border;
|
||||
area.height = MAX (1, (gint) allocation->height - border * 2);
|
||||
area.width = MAX (1, (gint) allocation->width - border * 2);
|
||||
|
||||
/*<h2v-off>*/
|
||||
/* g_print ("got: width %d, height %d\n",
|
||||
allocation->width,
|
||||
allocation->height);
|
||||
*/
|
||||
/*<h2v-on>*/
|
||||
|
||||
layout_cols (wbox, &area);
|
||||
}
|
|
@ -1,75 +0,0 @@
|
|||
/* GTK - The GIMP Toolkit
|
||||
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
||||
*
|
||||
* GtkVWrapBox: Vertical wrapping box widget
|
||||
* Copyright (C) 1999 Tim Janik
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library 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
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
#ifndef __GTK_VWRAP_BOX_H__
|
||||
#define __GTK_VWRAP_BOX_H__
|
||||
|
||||
|
||||
#include "gtkwrapbox.h"
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
/* --- type macros --- */
|
||||
#define GTK_TYPE_VWRAP_BOX (gtk_vwrap_box_get_type ())
|
||||
#define GTK_VWRAP_BOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_VWRAP_BOX, GtkVWrapBox))
|
||||
#define GTK_VWRAP_BOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_VWRAP_BOX, GtkVWrapBoxClass))
|
||||
#define GTK_IS_VWRAP_BOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_VWRAP_BOX))
|
||||
#define GTK_IS_VWRAP_BOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VWRAP_BOX))
|
||||
#define GTK_VWRAP_BOX_GET_CLASS(obj) (GTK_VWRAP_BOX_CLASS (((GtkObject*) (obj))->klass))
|
||||
|
||||
|
||||
/* --- typedefs --- */
|
||||
typedef struct _GtkVWrapBox GtkVWrapBox;
|
||||
typedef struct _GtkVWrapBoxClass GtkVWrapBoxClass;
|
||||
|
||||
|
||||
/* --- GtkVWrapBox --- */
|
||||
struct _GtkVWrapBox
|
||||
{
|
||||
GtkWrapBox parent_widget;
|
||||
|
||||
/*<h2v-off>*/
|
||||
guint16 max_child_width;
|
||||
guint16 max_child_height;
|
||||
/*<h2v-on>*/
|
||||
};
|
||||
|
||||
struct _GtkVWrapBoxClass
|
||||
{
|
||||
GtkWrapBoxClass parent_class;
|
||||
};
|
||||
|
||||
|
||||
/* --- prototypes --- */
|
||||
GtkType gtk_vwrap_box_get_type (void);
|
||||
GtkWidget* gtk_vwrap_box_new (gboolean homogeneous);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#endif /* __GTK_VWRAP_BOX_H__ */
|
830
app/gtkwrapbox.c
830
app/gtkwrapbox.c
|
@ -1,830 +0,0 @@
|
|||
/* GTK - The GIMP Toolkit
|
||||
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
||||
*
|
||||
* GtkWrapBox: Wrapping box widget
|
||||
* Copyright (C) 1999 Tim Janik
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library 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
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
#include <math.h>
|
||||
|
||||
#include "gtkwrapbox.h"
|
||||
|
||||
|
||||
/* --- arguments --- */
|
||||
enum {
|
||||
ARG_0,
|
||||
ARG_HOMOGENEOUS,
|
||||
ARG_JUSTIFY,
|
||||
ARG_HSPACING,
|
||||
ARG_VSPACING,
|
||||
ARG_LINE_JUSTIFY,
|
||||
ARG_ASPECT_RATIO,
|
||||
ARG_CURRENT_RATIO,
|
||||
ARG_CHILD_LIMIT
|
||||
};
|
||||
enum {
|
||||
CHILD_ARG_0,
|
||||
CHILD_ARG_POSITION,
|
||||
CHILD_ARG_HEXPAND,
|
||||
CHILD_ARG_HFILL,
|
||||
CHILD_ARG_VEXPAND,
|
||||
CHILD_ARG_VFILL,
|
||||
CHILD_ARG_FORCED_BREAK
|
||||
};
|
||||
|
||||
|
||||
/* --- prototypes --- */
|
||||
static void gtk_wrap_box_class_init (GtkWrapBoxClass *klass);
|
||||
static void gtk_wrap_box_init (GtkWrapBox *wbox);
|
||||
static void gtk_wrap_box_get_arg (GtkObject *object,
|
||||
GtkArg *arg,
|
||||
guint arg_id);
|
||||
static void gtk_wrap_box_set_arg (GtkObject *object,
|
||||
GtkArg *arg,
|
||||
guint arg_id);
|
||||
static void gtk_wrap_box_set_child_arg (GtkContainer *container,
|
||||
GtkWidget *child,
|
||||
GtkArg *arg,
|
||||
guint arg_id);
|
||||
static void gtk_wrap_box_get_child_arg (GtkContainer *container,
|
||||
GtkWidget *child,
|
||||
GtkArg *arg,
|
||||
guint arg_id);
|
||||
static void gtk_wrap_box_map (GtkWidget *widget);
|
||||
static void gtk_wrap_box_unmap (GtkWidget *widget);
|
||||
static void gtk_wrap_box_draw (GtkWidget *widget,
|
||||
GdkRectangle *area);
|
||||
static gint gtk_wrap_box_expose (GtkWidget *widget,
|
||||
GdkEventExpose *event);
|
||||
static void gtk_wrap_box_add (GtkContainer *container,
|
||||
GtkWidget *widget);
|
||||
static void gtk_wrap_box_remove (GtkContainer *container,
|
||||
GtkWidget *widget);
|
||||
static void gtk_wrap_box_forall (GtkContainer *container,
|
||||
gboolean include_internals,
|
||||
GtkCallback callback,
|
||||
gpointer callback_data);
|
||||
static GtkType gtk_wrap_box_child_type (GtkContainer *container);
|
||||
|
||||
|
||||
/* --- variables --- */
|
||||
static gpointer parent_class = NULL;
|
||||
|
||||
|
||||
/* --- functions --- */
|
||||
GtkType
|
||||
gtk_wrap_box_get_type (void)
|
||||
{
|
||||
static GtkType wrap_box_type = 0;
|
||||
|
||||
if (!wrap_box_type)
|
||||
{
|
||||
static const GtkTypeInfo wrap_box_info =
|
||||
{
|
||||
"GtkWrapBox",
|
||||
sizeof (GtkWrapBox),
|
||||
sizeof (GtkWrapBoxClass),
|
||||
(GtkClassInitFunc) gtk_wrap_box_class_init,
|
||||
(GtkObjectInitFunc) gtk_wrap_box_init,
|
||||
/* reserved_1 */ NULL,
|
||||
/* reserved_2 */ NULL,
|
||||
(GtkClassInitFunc) NULL,
|
||||
};
|
||||
|
||||
wrap_box_type = gtk_type_unique (GTK_TYPE_CONTAINER, &wrap_box_info);
|
||||
}
|
||||
|
||||
return wrap_box_type;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_class_init (GtkWrapBoxClass *class)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
GtkWidgetClass *widget_class;
|
||||
GtkContainerClass *container_class;
|
||||
|
||||
object_class = GTK_OBJECT_CLASS (class);
|
||||
widget_class = GTK_WIDGET_CLASS (class);
|
||||
container_class = GTK_CONTAINER_CLASS (class);
|
||||
|
||||
parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
|
||||
|
||||
object_class->set_arg = gtk_wrap_box_set_arg;
|
||||
object_class->get_arg = gtk_wrap_box_get_arg;
|
||||
|
||||
widget_class->map = gtk_wrap_box_map;
|
||||
widget_class->unmap = gtk_wrap_box_unmap;
|
||||
widget_class->draw = gtk_wrap_box_draw;
|
||||
widget_class->expose_event = gtk_wrap_box_expose;
|
||||
|
||||
container_class->add = gtk_wrap_box_add;
|
||||
container_class->remove = gtk_wrap_box_remove;
|
||||
container_class->forall = gtk_wrap_box_forall;
|
||||
container_class->child_type = gtk_wrap_box_child_type;
|
||||
container_class->set_child_arg = gtk_wrap_box_set_child_arg;
|
||||
container_class->get_child_arg = gtk_wrap_box_get_child_arg;
|
||||
|
||||
class->rlist_line_children = NULL;
|
||||
|
||||
gtk_object_add_arg_type ("GtkWrapBox::homogeneous",
|
||||
GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HOMOGENEOUS);
|
||||
gtk_object_add_arg_type ("GtkWrapBox::justify",
|
||||
GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFY);
|
||||
gtk_object_add_arg_type ("GtkWrapBox::hspacing",
|
||||
GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_HSPACING);
|
||||
gtk_object_add_arg_type ("GtkWrapBox::vspacing",
|
||||
GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_VSPACING);
|
||||
gtk_object_add_arg_type ("GtkWrapBox::line_justify",
|
||||
GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_LINE_JUSTIFY);
|
||||
gtk_object_add_arg_type ("GtkWrapBox::aspect_ratio",
|
||||
GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_ASPECT_RATIO);
|
||||
gtk_object_add_arg_type ("GtkWrapBox::current_ratio",
|
||||
GTK_TYPE_FLOAT, GTK_ARG_READABLE, ARG_CURRENT_RATIO);
|
||||
gtk_object_add_arg_type ("GtkWrapBox::max_children_per_line",
|
||||
GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_CHILD_LIMIT);
|
||||
gtk_container_add_child_arg_type ("GtkWrapBox::position",
|
||||
GTK_TYPE_INT, GTK_ARG_READWRITE, CHILD_ARG_POSITION);
|
||||
gtk_container_add_child_arg_type ("GtkWrapBox::hexpand",
|
||||
GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_HEXPAND);
|
||||
gtk_container_add_child_arg_type ("GtkWrapBox::hfill",
|
||||
GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_HFILL);
|
||||
gtk_container_add_child_arg_type ("GtkWrapBox::vexpand",
|
||||
GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_VEXPAND);
|
||||
gtk_container_add_child_arg_type ("GtkWrapBox::vfill",
|
||||
GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_VFILL);
|
||||
gtk_container_add_child_arg_type ("GtkWrapBox::forcebreak",
|
||||
GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FORCED_BREAK);
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_init (GtkWrapBox *wbox)
|
||||
{
|
||||
GTK_WIDGET_SET_FLAGS (wbox, GTK_NO_WINDOW);
|
||||
|
||||
wbox->homogeneous = FALSE;
|
||||
wbox->hspacing = 0;
|
||||
wbox->vspacing = 0;
|
||||
wbox->justify = GTK_JUSTIFY_LEFT;
|
||||
wbox->line_justify = GTK_JUSTIFY_BOTTOM;
|
||||
wbox->n_children = 0;
|
||||
wbox->children = NULL;
|
||||
wbox->aspect_ratio = 1;
|
||||
wbox->child_limit = 32767;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_set_arg (GtkObject *object,
|
||||
GtkArg *arg,
|
||||
guint arg_id)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (object);
|
||||
|
||||
switch (arg_id)
|
||||
{
|
||||
case ARG_HOMOGENEOUS:
|
||||
gtk_wrap_box_set_homogeneous (wbox, GTK_VALUE_BOOL (*arg));
|
||||
break;
|
||||
case ARG_JUSTIFY:
|
||||
gtk_wrap_box_set_justify (wbox, GTK_VALUE_ENUM (*arg));
|
||||
break;
|
||||
case ARG_LINE_JUSTIFY:
|
||||
gtk_wrap_box_set_line_justify (wbox, GTK_VALUE_ENUM (*arg));
|
||||
break;
|
||||
case ARG_HSPACING:
|
||||
gtk_wrap_box_set_hspacing (wbox, GTK_VALUE_UINT (*arg));
|
||||
break;
|
||||
case ARG_VSPACING:
|
||||
gtk_wrap_box_set_vspacing (wbox, GTK_VALUE_UINT (*arg));
|
||||
break;
|
||||
case ARG_ASPECT_RATIO:
|
||||
gtk_wrap_box_set_aspect_ratio (wbox, GTK_VALUE_FLOAT (*arg));
|
||||
break;
|
||||
case ARG_CHILD_LIMIT:
|
||||
if (wbox->child_limit != GTK_VALUE_UINT (*arg))
|
||||
{
|
||||
wbox->child_limit = CLAMP (GTK_VALUE_UINT (*arg), 1, 32767);
|
||||
gtk_widget_queue_resize (GTK_WIDGET (wbox));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_get_arg (GtkObject *object,
|
||||
GtkArg *arg,
|
||||
guint arg_id)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (object);
|
||||
GtkWidget *widget = GTK_WIDGET (object);
|
||||
|
||||
switch (arg_id)
|
||||
{
|
||||
case ARG_HOMOGENEOUS:
|
||||
GTK_VALUE_BOOL (*arg) = wbox->homogeneous;
|
||||
break;
|
||||
case ARG_JUSTIFY:
|
||||
GTK_VALUE_ENUM (*arg) = wbox->justify;
|
||||
break;
|
||||
case ARG_LINE_JUSTIFY:
|
||||
GTK_VALUE_ENUM (*arg) = wbox->line_justify;
|
||||
break;
|
||||
case ARG_HSPACING:
|
||||
GTK_VALUE_UINT (*arg) = wbox->hspacing;
|
||||
break;
|
||||
case ARG_VSPACING:
|
||||
GTK_VALUE_UINT (*arg) = wbox->vspacing;
|
||||
break;
|
||||
case ARG_ASPECT_RATIO:
|
||||
GTK_VALUE_FLOAT (*arg) = wbox->aspect_ratio;
|
||||
break;
|
||||
case ARG_CURRENT_RATIO:
|
||||
GTK_VALUE_FLOAT (*arg) = (((gfloat) widget->allocation.width) /
|
||||
((gfloat) widget->allocation.height));
|
||||
break;
|
||||
case ARG_CHILD_LIMIT:
|
||||
GTK_VALUE_UINT (*arg) = wbox->child_limit;
|
||||
break;
|
||||
default:
|
||||
arg->type = GTK_TYPE_INVALID;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_set_child_arg (GtkContainer *container,
|
||||
GtkWidget *child,
|
||||
GtkArg *arg,
|
||||
guint arg_id)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (container);
|
||||
gboolean hexpand = FALSE, hfill = FALSE, vexpand = FALSE, vfill = FALSE;
|
||||
|
||||
if (arg_id != CHILD_ARG_POSITION)
|
||||
gtk_wrap_box_query_child_packing (wbox, child, &hexpand, &hfill, &vexpand, &vfill);
|
||||
|
||||
switch (arg_id)
|
||||
{
|
||||
case CHILD_ARG_POSITION:
|
||||
gtk_wrap_box_reorder_child (wbox, child, GTK_VALUE_INT (*arg));
|
||||
break;
|
||||
case CHILD_ARG_HEXPAND:
|
||||
gtk_wrap_box_set_child_packing (wbox, child,
|
||||
GTK_VALUE_BOOL (*arg), hfill,
|
||||
vexpand, vfill);
|
||||
break;
|
||||
case CHILD_ARG_HFILL:
|
||||
gtk_wrap_box_set_child_packing (wbox, child,
|
||||
hexpand, GTK_VALUE_BOOL (*arg),
|
||||
vexpand, vfill);
|
||||
break;
|
||||
case CHILD_ARG_VEXPAND:
|
||||
gtk_wrap_box_set_child_packing (wbox, child,
|
||||
hexpand, hfill,
|
||||
GTK_VALUE_BOOL (*arg), vfill);
|
||||
break;
|
||||
case CHILD_ARG_VFILL:
|
||||
gtk_wrap_box_set_child_packing (wbox, child,
|
||||
hexpand, hfill,
|
||||
vexpand, GTK_VALUE_BOOL (*arg));
|
||||
break;
|
||||
case CHILD_ARG_FORCED_BREAK:
|
||||
gtk_wrap_box_set_child_forced_break (wbox, child,
|
||||
GTK_VALUE_BOOL (*arg));
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_get_child_arg (GtkContainer *container,
|
||||
GtkWidget *child,
|
||||
GtkArg *arg,
|
||||
guint arg_id)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (container);
|
||||
gboolean hexpand = FALSE, hfill = FALSE, vexpand = FALSE, vfill = FALSE;
|
||||
|
||||
if (arg_id != CHILD_ARG_POSITION)
|
||||
gtk_wrap_box_query_child_packing (wbox, child, &hexpand, &hfill, &vexpand, &vfill);
|
||||
|
||||
switch (arg_id)
|
||||
{
|
||||
GtkWrapBoxChild *child_info;
|
||||
case CHILD_ARG_POSITION:
|
||||
GTK_VALUE_INT (*arg) = 0;
|
||||
for (child_info = wbox->children; child_info; child_info = child_info->next)
|
||||
{
|
||||
if (child_info->widget == child)
|
||||
break;
|
||||
GTK_VALUE_INT (*arg)++;
|
||||
}
|
||||
if (!child_info)
|
||||
GTK_VALUE_INT (*arg) = -1;
|
||||
break;
|
||||
case CHILD_ARG_HEXPAND:
|
||||
GTK_VALUE_BOOL (*arg) = hexpand;
|
||||
break;
|
||||
case CHILD_ARG_HFILL:
|
||||
GTK_VALUE_BOOL (*arg) = hfill;
|
||||
break;
|
||||
case CHILD_ARG_VEXPAND:
|
||||
GTK_VALUE_BOOL (*arg) = vexpand;
|
||||
break;
|
||||
case CHILD_ARG_VFILL:
|
||||
GTK_VALUE_BOOL (*arg) = vfill;
|
||||
break;
|
||||
default:
|
||||
arg->type = GTK_TYPE_INVALID;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static GtkType
|
||||
gtk_wrap_box_child_type (GtkContainer *container)
|
||||
{
|
||||
return GTK_TYPE_WIDGET;
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_set_homogeneous (GtkWrapBox *wbox,
|
||||
gboolean homogeneous)
|
||||
{
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
|
||||
homogeneous = homogeneous != FALSE;
|
||||
if (wbox->homogeneous != homogeneous)
|
||||
{
|
||||
wbox->homogeneous = homogeneous;
|
||||
gtk_widget_queue_resize (GTK_WIDGET (wbox));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_set_hspacing (GtkWrapBox *wbox,
|
||||
guint hspacing)
|
||||
{
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
|
||||
if (wbox->hspacing != hspacing)
|
||||
{
|
||||
wbox->hspacing = hspacing;
|
||||
gtk_widget_queue_resize (GTK_WIDGET (wbox));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_set_vspacing (GtkWrapBox *wbox,
|
||||
guint vspacing)
|
||||
{
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
|
||||
if (wbox->vspacing != vspacing)
|
||||
{
|
||||
wbox->vspacing = vspacing;
|
||||
gtk_widget_queue_resize (GTK_WIDGET (wbox));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_set_justify (GtkWrapBox *wbox,
|
||||
GtkJustification justify)
|
||||
{
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
g_return_if_fail (justify <= GTK_JUSTIFY_FILL);
|
||||
|
||||
if (wbox->justify != justify)
|
||||
{
|
||||
wbox->justify = justify;
|
||||
gtk_widget_queue_resize (GTK_WIDGET (wbox));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_set_line_justify (GtkWrapBox *wbox,
|
||||
GtkJustification line_justify)
|
||||
{
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
g_return_if_fail (line_justify <= GTK_JUSTIFY_FILL);
|
||||
|
||||
if (wbox->line_justify != line_justify)
|
||||
{
|
||||
wbox->line_justify = line_justify;
|
||||
gtk_widget_queue_resize (GTK_WIDGET (wbox));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_set_aspect_ratio (GtkWrapBox *wbox,
|
||||
gfloat aspect_ratio)
|
||||
{
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
|
||||
aspect_ratio = CLAMP (aspect_ratio, 1.0 / 256.0, 256.0);
|
||||
|
||||
if (wbox->aspect_ratio != aspect_ratio)
|
||||
{
|
||||
wbox->aspect_ratio = aspect_ratio;
|
||||
gtk_widget_queue_resize (GTK_WIDGET (wbox));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_pack (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean hexpand,
|
||||
gboolean hfill,
|
||||
gboolean vexpand,
|
||||
gboolean vfill)
|
||||
{
|
||||
GtkWrapBoxChild *child_info;
|
||||
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
g_return_if_fail (GTK_IS_WIDGET (child));
|
||||
g_return_if_fail (child->parent == NULL);
|
||||
|
||||
child_info = g_new (GtkWrapBoxChild, 1);
|
||||
child_info->widget = child;
|
||||
child_info->hexpand = hexpand ? TRUE : FALSE;
|
||||
child_info->hfill = hfill ? TRUE : FALSE;
|
||||
child_info->vexpand = vexpand ? TRUE : FALSE;
|
||||
child_info->vfill = vfill ? TRUE : FALSE;
|
||||
child_info->forced_break = FALSE;
|
||||
child_info->next = NULL;
|
||||
if (wbox->children)
|
||||
{
|
||||
GtkWrapBoxChild *last = wbox->children;
|
||||
|
||||
while (last->next)
|
||||
last = last->next;
|
||||
last->next = child_info;
|
||||
}
|
||||
else
|
||||
wbox->children = child_info;
|
||||
wbox->n_children++;
|
||||
|
||||
gtk_widget_set_parent (child, GTK_WIDGET (wbox));
|
||||
|
||||
if (GTK_WIDGET_REALIZED (wbox))
|
||||
gtk_widget_realize (child);
|
||||
|
||||
if (GTK_WIDGET_VISIBLE (wbox) && GTK_WIDGET_VISIBLE (child))
|
||||
{
|
||||
if (GTK_WIDGET_MAPPED (wbox))
|
||||
gtk_widget_map (child);
|
||||
|
||||
gtk_widget_queue_resize (child);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_reorder_child (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gint position)
|
||||
{
|
||||
GtkWrapBoxChild *child_info, *last = NULL;
|
||||
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
g_return_if_fail (GTK_IS_WIDGET (child));
|
||||
|
||||
for (child_info = wbox->children; child_info; last = child_info, child_info = last->next)
|
||||
if (child_info->widget == child)
|
||||
break;
|
||||
|
||||
if (child_info && wbox->children->next)
|
||||
{
|
||||
GtkWrapBoxChild *tmp;
|
||||
|
||||
if (last)
|
||||
last->next = child_info->next;
|
||||
else
|
||||
wbox->children = child_info->next;
|
||||
|
||||
last = NULL;
|
||||
tmp = wbox->children;
|
||||
while (position && tmp->next)
|
||||
{
|
||||
position--;
|
||||
last = tmp;
|
||||
tmp = last->next;
|
||||
}
|
||||
|
||||
if (position)
|
||||
{
|
||||
tmp->next = child_info;
|
||||
child_info->next = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
child_info->next = tmp;
|
||||
if (last)
|
||||
last->next = child_info;
|
||||
else
|
||||
wbox->children = child_info;
|
||||
}
|
||||
|
||||
if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (wbox))
|
||||
gtk_widget_queue_resize (child);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_query_child_packing (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean *hexpand,
|
||||
gboolean *hfill,
|
||||
gboolean *vexpand,
|
||||
gboolean *vfill)
|
||||
{
|
||||
GtkWrapBoxChild *child_info;
|
||||
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
g_return_if_fail (GTK_IS_WIDGET (child));
|
||||
|
||||
for (child_info = wbox->children; child_info; child_info = child_info->next)
|
||||
if (child_info->widget == child)
|
||||
break;
|
||||
|
||||
if (child_info)
|
||||
{
|
||||
if (hexpand)
|
||||
*hexpand = child_info->hexpand;
|
||||
if (hfill)
|
||||
*hfill = child_info->hfill;
|
||||
if (vexpand)
|
||||
*vexpand = child_info->vexpand;
|
||||
if (vfill)
|
||||
*vfill = child_info->vfill;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_query_child_forced_break (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean *forced_break)
|
||||
{
|
||||
GtkWrapBoxChild *child_info;
|
||||
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
g_return_if_fail (GTK_IS_WIDGET (child));
|
||||
|
||||
for (child_info = wbox->children; child_info; child_info = child_info->next)
|
||||
if (child_info->widget == child)
|
||||
break;
|
||||
|
||||
if (child_info)
|
||||
{
|
||||
if (forced_break)
|
||||
*forced_break = child_info->forced_break;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_set_child_packing (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean hexpand,
|
||||
gboolean hfill,
|
||||
gboolean vexpand,
|
||||
gboolean vfill)
|
||||
{
|
||||
GtkWrapBoxChild *child_info;
|
||||
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
g_return_if_fail (GTK_IS_WIDGET (child));
|
||||
|
||||
hexpand = hexpand != FALSE;
|
||||
hfill = hfill != FALSE;
|
||||
vexpand = vexpand != FALSE;
|
||||
vfill = vfill != FALSE;
|
||||
|
||||
for (child_info = wbox->children; child_info; child_info = child_info->next)
|
||||
if (child_info->widget == child)
|
||||
break;
|
||||
|
||||
if (child_info &&
|
||||
(child_info->hexpand != hexpand || child_info->vexpand != vexpand ||
|
||||
child_info->hfill != hfill || child_info->vfill != vfill))
|
||||
{
|
||||
child_info->hexpand = hexpand;
|
||||
child_info->hfill = hfill;
|
||||
child_info->vexpand = vexpand;
|
||||
child_info->vfill = vfill;
|
||||
|
||||
if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (wbox))
|
||||
gtk_widget_queue_resize (child);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gtk_wrap_box_set_child_forced_break (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean forced_break)
|
||||
{
|
||||
GtkWrapBoxChild *child_info;
|
||||
|
||||
g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
|
||||
g_return_if_fail (GTK_IS_WIDGET (child));
|
||||
|
||||
forced_break = forced_break != FALSE;
|
||||
|
||||
for (child_info = wbox->children; child_info; child_info = child_info->next)
|
||||
if (child_info->widget == child)
|
||||
break;
|
||||
|
||||
if (child_info &&
|
||||
(child_info->forced_break != forced_break))
|
||||
{
|
||||
child_info->forced_break = forced_break;
|
||||
|
||||
if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (wbox))
|
||||
gtk_widget_queue_resize (child);
|
||||
}
|
||||
}
|
||||
|
||||
guint*
|
||||
gtk_wrap_box_query_line_lengths (GtkWrapBox *wbox,
|
||||
guint *_n_lines)
|
||||
{
|
||||
GtkWrapBoxChild *next_child = NULL;
|
||||
GtkAllocation area, *allocation;
|
||||
gboolean expand_line;
|
||||
GSList *slist;
|
||||
guint max_child_size, border, n_lines = 0, *lines = NULL;
|
||||
|
||||
if (_n_lines)
|
||||
*_n_lines = 0;
|
||||
g_return_val_if_fail (GTK_IS_WRAP_BOX (wbox), NULL);
|
||||
|
||||
allocation = >K_WIDGET (wbox)->allocation;
|
||||
border = GTK_CONTAINER (wbox)->border_width;
|
||||
area.x = allocation->x + border;
|
||||
area.y = allocation->y + border;
|
||||
area.width = MAX (1, (gint) allocation->width - border * 2);
|
||||
area.height = MAX (1, (gint) allocation->height - border * 2);
|
||||
|
||||
next_child = wbox->children;
|
||||
slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
|
||||
&next_child,
|
||||
&area,
|
||||
&max_child_size,
|
||||
&expand_line);
|
||||
while (slist)
|
||||
{
|
||||
guint l = n_lines++;
|
||||
|
||||
lines = g_renew (guint, lines, n_lines);
|
||||
lines[l] = g_slist_length (slist);
|
||||
g_slist_free (slist);
|
||||
|
||||
slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
|
||||
&next_child,
|
||||
&area,
|
||||
&max_child_size,
|
||||
&expand_line);
|
||||
}
|
||||
|
||||
if (_n_lines)
|
||||
*_n_lines = n_lines;
|
||||
|
||||
return lines;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_map (GtkWidget *widget)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkWrapBoxChild *child;
|
||||
|
||||
GTK_WIDGET_SET_FLAGS (wbox, GTK_MAPPED);
|
||||
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
if (GTK_WIDGET_VISIBLE (child->widget) &&
|
||||
!GTK_WIDGET_MAPPED (child->widget))
|
||||
gtk_widget_map (child->widget);
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_unmap (GtkWidget *widget)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkWrapBoxChild *child;
|
||||
|
||||
GTK_WIDGET_UNSET_FLAGS (wbox, GTK_MAPPED);
|
||||
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
if (GTK_WIDGET_VISIBLE (child->widget) &&
|
||||
GTK_WIDGET_MAPPED (child->widget))
|
||||
gtk_widget_unmap (child->widget);
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_draw (GtkWidget *widget,
|
||||
GdkRectangle *area)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkWrapBoxChild *child;
|
||||
GdkRectangle child_area;
|
||||
|
||||
if (GTK_WIDGET_DRAWABLE (widget))
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
if (GTK_WIDGET_DRAWABLE (child->widget) &&
|
||||
gtk_widget_intersect (child->widget, area, &child_area))
|
||||
gtk_widget_draw (child->widget, &child_area);
|
||||
}
|
||||
|
||||
static gint
|
||||
gtk_wrap_box_expose (GtkWidget *widget,
|
||||
GdkEventExpose *event)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
|
||||
GtkWrapBoxChild *child;
|
||||
GdkEventExpose child_event = *event;
|
||||
|
||||
g_return_val_if_fail (event != NULL, FALSE);
|
||||
|
||||
if (GTK_WIDGET_DRAWABLE (widget))
|
||||
for (child = wbox->children; child; child = child->next)
|
||||
if (GTK_WIDGET_DRAWABLE (child->widget) &&
|
||||
GTK_WIDGET_NO_WINDOW (child->widget) &&
|
||||
gtk_widget_intersect (child->widget, &event->area, &child_event.area))
|
||||
gtk_widget_event (child->widget, (GdkEvent*) &child_event);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_add (GtkContainer *container,
|
||||
GtkWidget *widget)
|
||||
{
|
||||
gtk_wrap_box_pack (GTK_WRAP_BOX (container), widget, FALSE, TRUE, FALSE, TRUE);
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_remove (GtkContainer *container,
|
||||
GtkWidget *widget)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (container);
|
||||
GtkWrapBoxChild *child, *last = NULL;
|
||||
|
||||
child = wbox->children;
|
||||
while (child)
|
||||
{
|
||||
if (child->widget == widget)
|
||||
{
|
||||
gboolean was_visible;
|
||||
|
||||
was_visible = GTK_WIDGET_VISIBLE (widget);
|
||||
gtk_widget_unparent (widget);
|
||||
|
||||
if (last)
|
||||
last->next = child->next;
|
||||
else
|
||||
wbox->children = child->next;
|
||||
g_free (child);
|
||||
wbox->n_children--;
|
||||
|
||||
if (was_visible)
|
||||
gtk_widget_queue_resize (GTK_WIDGET (container));
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
last = child;
|
||||
child = last->next;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_wrap_box_forall (GtkContainer *container,
|
||||
gboolean include_internals,
|
||||
GtkCallback callback,
|
||||
gpointer callback_data)
|
||||
{
|
||||
GtkWrapBox *wbox = GTK_WRAP_BOX (container);
|
||||
GtkWrapBoxChild *child;
|
||||
|
||||
child = wbox->children;
|
||||
while (child)
|
||||
{
|
||||
GtkWidget *widget = child->widget;
|
||||
|
||||
child = child->next;
|
||||
|
||||
callback (widget, callback_data);
|
||||
}
|
||||
}
|
140
app/gtkwrapbox.h
140
app/gtkwrapbox.h
|
@ -1,140 +0,0 @@
|
|||
/* GTK - The GIMP Toolkit
|
||||
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
||||
*
|
||||
* GtkWrapBox: Wrapping box widget
|
||||
* Copyright (C) 1999 Tim Janik
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library 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
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
#ifndef __GTK_WRAP_BOX_H__
|
||||
#define __GTK_WRAP_BOX_H__
|
||||
|
||||
|
||||
#include <gdk/gdk.h>
|
||||
#include <gtk/gtkcontainer.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
/* --- type macros --- */
|
||||
#define GTK_TYPE_WRAP_BOX (gtk_wrap_box_get_type ())
|
||||
#define GTK_WRAP_BOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_WRAP_BOX, GtkWrapBox))
|
||||
#define GTK_WRAP_BOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_WRAP_BOX, GtkWrapBoxClass))
|
||||
#define GTK_IS_WRAP_BOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_WRAP_BOX))
|
||||
#define GTK_IS_WRAP_BOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WRAP_BOX))
|
||||
#define GTK_WRAP_BOX_GET_CLASS(obj) (GTK_WRAP_BOX_CLASS (((GtkObject*) (obj))->klass))
|
||||
|
||||
|
||||
/* --- typedefs --- */
|
||||
typedef struct _GtkWrapBox GtkWrapBox;
|
||||
typedef struct _GtkWrapBoxClass GtkWrapBoxClass;
|
||||
typedef struct _GtkWrapBoxChild GtkWrapBoxChild;
|
||||
|
||||
/* --- GtkWrapBox --- */
|
||||
struct _GtkWrapBox
|
||||
{
|
||||
GtkContainer container;
|
||||
|
||||
guint homogeneous : 1;
|
||||
guint justify : 4;
|
||||
guint line_justify : 4;
|
||||
guint8 hspacing;
|
||||
guint8 vspacing;
|
||||
guint16 n_children;
|
||||
GtkWrapBoxChild *children;
|
||||
gfloat aspect_ratio; /* 1/256..256 */
|
||||
guint child_limit;
|
||||
};
|
||||
struct _GtkWrapBoxClass
|
||||
{
|
||||
GtkContainerClass parent_class;
|
||||
|
||||
GSList* (*rlist_line_children) (GtkWrapBox *wbox,
|
||||
GtkWrapBoxChild **child_p,
|
||||
GtkAllocation *area,
|
||||
guint *max_child_size,
|
||||
gboolean *expand_line);
|
||||
};
|
||||
struct _GtkWrapBoxChild
|
||||
{
|
||||
GtkWidget *widget;
|
||||
guint hexpand : 1;
|
||||
guint hfill : 1;
|
||||
guint vexpand : 1;
|
||||
guint vfill : 1;
|
||||
guint forced_break : 1;
|
||||
|
||||
GtkWrapBoxChild *next;
|
||||
};
|
||||
#define GTK_JUSTIFY_TOP GTK_JUSTIFY_LEFT
|
||||
#define GTK_JUSTIFY_BOTTOM GTK_JUSTIFY_RIGHT
|
||||
|
||||
|
||||
/* --- prototypes --- */
|
||||
GtkType gtk_wrap_box_get_type (void);
|
||||
void gtk_wrap_box_set_homogeneous (GtkWrapBox *wbox,
|
||||
gboolean homogeneous);
|
||||
void gtk_wrap_box_set_hspacing (GtkWrapBox *wbox,
|
||||
guint hspacing);
|
||||
void gtk_wrap_box_set_vspacing (GtkWrapBox *wbox,
|
||||
guint vspacing);
|
||||
void gtk_wrap_box_set_justify (GtkWrapBox *wbox,
|
||||
GtkJustification justify);
|
||||
void gtk_wrap_box_set_line_justify (GtkWrapBox *wbox,
|
||||
GtkJustification line_justify);
|
||||
void gtk_wrap_box_set_aspect_ratio (GtkWrapBox *wbox,
|
||||
gfloat aspect_ratio);
|
||||
void gtk_wrap_box_pack (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean hexpand,
|
||||
gboolean hfill,
|
||||
gboolean vexpand,
|
||||
gboolean vfill);
|
||||
void gtk_wrap_box_reorder_child (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gint position);
|
||||
void gtk_wrap_box_query_child_packing (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean *hexpand,
|
||||
gboolean *hfill,
|
||||
gboolean *vexpand,
|
||||
gboolean *vfill);
|
||||
void gtk_wrap_box_query_child_forced_break (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean *forced_break);
|
||||
void gtk_wrap_box_set_child_packing (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean hexpand,
|
||||
gboolean hfill,
|
||||
gboolean vexpand,
|
||||
gboolean vfill);
|
||||
void gtk_wrap_box_set_child_forced_break (GtkWrapBox *wbox,
|
||||
GtkWidget *child,
|
||||
gboolean forced_break);
|
||||
guint* gtk_wrap_box_query_line_lengths (GtkWrapBox *wbox,
|
||||
guint *n_lines);
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#endif /* __GTK_WRAP_BOX_H__ */
|
|
@ -26,6 +26,8 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "brush_edit.h"
|
||||
|
@ -33,7 +35,6 @@
|
|||
#include "dialog_handler.h"
|
||||
#include "gimpbrushgenerated.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdata.h"
|
||||
#include "gimpdatafactory.h"
|
||||
|
|
|
@ -29,9 +29,10 @@
|
|||
|
||||
#include "paint-funcs/paint-funcs.h"
|
||||
|
||||
#include "widgets/gimpcolorpanel.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "channels_dialog.h"
|
||||
#include "color_panel.h"
|
||||
#include "drawable.h"
|
||||
#include "gdisplay.h"
|
||||
#include "gimage.h"
|
||||
|
|
|
@ -31,6 +31,8 @@
|
|||
#include "tools/gimptoolinfo.h"
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "devices.h"
|
||||
|
@ -41,7 +43,6 @@
|
|||
#include "gimpdnd.h"
|
||||
#include "gimpgradient.h"
|
||||
#include "gimppattern.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimplist.h"
|
||||
#include "gimprc.h"
|
||||
#include "session.h"
|
||||
|
|
|
@ -63,13 +63,14 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpcontainerlistview.h"
|
||||
|
||||
#include "color_notebook.h"
|
||||
#include "context_manager.h"
|
||||
#include "cursorutil.h"
|
||||
#include "datafiles.h"
|
||||
#include "errors.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontainerlistview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpdnd.h"
|
||||
|
|
|
@ -27,11 +27,12 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "dialog_handler.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpgradient.h"
|
||||
|
|
|
@ -27,12 +27,13 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "brush_select.h"
|
||||
#include "gimpbrush.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpgradient.h"
|
||||
#include "gimppattern.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gradient_select.h"
|
||||
#include "indicator_area.h"
|
||||
|
|
|
@ -28,13 +28,14 @@
|
|||
#include "tools/gimpcolorpickertool.h"
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "context_manager.h"
|
||||
#include "colormaps.h"
|
||||
#include "gdisplay.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimppreview.h"
|
||||
#include "info_dialog.h"
|
||||
#include "info_window.h"
|
||||
|
||||
|
|
|
@ -31,6 +31,8 @@
|
|||
#include "tools/gimptoolinfo.h"
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "devices.h"
|
||||
|
@ -41,7 +43,6 @@
|
|||
#include "gimpdnd.h"
|
||||
#include "gimpgradient.h"
|
||||
#include "gimppattern.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimplist.h"
|
||||
#include "gimprc.h"
|
||||
#include "session.h"
|
||||
|
|
|
@ -25,19 +25,20 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpcontainerlistview.h"
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "color_area.h"
|
||||
#include "color_notebook.h"
|
||||
#include "context_manager.h"
|
||||
#include "dialog_handler.h"
|
||||
#include "gimage.h"
|
||||
#include "gimpcontainerlistview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpdatalist.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimppalette.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimprc.h"
|
||||
#include "palette.h"
|
||||
#include "palette_import.h"
|
||||
|
|
|
@ -27,12 +27,13 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "dialog_handler.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimppalette.h"
|
||||
|
|
|
@ -26,12 +26,13 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "dialog_handler.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimppattern.h"
|
||||
#include "pattern_select.h"
|
||||
|
|
|
@ -29,7 +29,8 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "color_panel.h"
|
||||
#include "widgets/gimpcolorpanel.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "floating_sel.h"
|
||||
#include "gdisplay.h"
|
||||
|
|
|
@ -27,22 +27,23 @@
|
|||
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimpcontainerlistview.h"
|
||||
#include "widgets/gimpcontainergridview.h"
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
#include "widgets/gimpdock.h"
|
||||
#include "widgets/gimpdockable.h"
|
||||
#include "widgets/gimpdockbook.h"
|
||||
#include "widgets/gimpdrawablelistview.h"
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "context_manager.h"
|
||||
#include "gradient_editor.h"
|
||||
#include "gimpchannel.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontainerlistview.h"
|
||||
#include "gimpcontainergridview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpdock.h"
|
||||
#include "gimpdockable.h"
|
||||
#include "gimpdockbook.h"
|
||||
#include "gimpdrawablelistview.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimprc.h"
|
||||
|
||||
#include "libgimp/gimpintl.h"
|
||||
|
|
|
@ -24,11 +24,12 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "dialog_handler.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimplist.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimpui.h"
|
||||
#include "session.h"
|
||||
|
||||
|
|
|
@ -32,6 +32,9 @@
|
|||
#include "tools/tool_options_dialog.h"
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
#include "widgets/gtkhwrapbox.h"
|
||||
|
||||
#include "app_procs.h"
|
||||
#include "color_area.h"
|
||||
#include "devices.h"
|
||||
|
@ -42,9 +45,7 @@
|
|||
#include "gimpdnd.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimplist.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimprc.h"
|
||||
#include "gtkhwrapbox.h"
|
||||
#include "indicator_area.h"
|
||||
#include "menus.h"
|
||||
#include "session.h"
|
||||
|
|
|
@ -1,315 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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 "config.h"
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "libgimpmath/gimpmath.h"
|
||||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimage.h"
|
||||
#include "gimage_mask.h"
|
||||
#include "gimphistogram.h"
|
||||
#include "histogramwidget.h"
|
||||
#include "tile_manager.h"
|
||||
|
||||
|
||||
#define WAITING 0
|
||||
#define WORKING 1
|
||||
|
||||
#define WORK_DELAY 1
|
||||
|
||||
#define HISTOGRAM_MASK GDK_EXPOSURE_MASK | \
|
||||
GDK_BUTTON_PRESS_MASK | \
|
||||
GDK_BUTTON_RELEASE_MASK | \
|
||||
GDK_BUTTON1_MOTION_MASK
|
||||
|
||||
#define HISTOGRAM 0x1
|
||||
#define RANGE 0x2
|
||||
#define ALL 0xF
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
RANGE_CHANGED,
|
||||
LAST_SIGNAL
|
||||
};
|
||||
|
||||
static guint histogram_widget_signals[LAST_SIGNAL];
|
||||
|
||||
static void histogram_widget_class_init (HistogramWidgetClass *klass);
|
||||
static void histogram_widget_init (HistogramWidget *histogram);
|
||||
|
||||
|
||||
/**************************/
|
||||
/* Function definitions */
|
||||
|
||||
GtkType
|
||||
histogram_widget_get_type (void)
|
||||
{
|
||||
static GtkType histogram_widet_type = 0;
|
||||
|
||||
if (! histogram_widet_type)
|
||||
{
|
||||
static const GtkTypeInfo info =
|
||||
{
|
||||
"HistogramWidget",
|
||||
sizeof (HistogramWidget),
|
||||
sizeof (HistogramWidgetClass),
|
||||
(GtkClassInitFunc) histogram_widget_class_init,
|
||||
(GtkObjectInitFunc) histogram_widget_init,
|
||||
NULL, NULL
|
||||
};
|
||||
|
||||
histogram_widet_type =
|
||||
gtk_type_unique (gtk_drawing_area_get_type (), &info);
|
||||
}
|
||||
|
||||
return histogram_widet_type;
|
||||
}
|
||||
|
||||
static void
|
||||
histogram_widget_class_init (HistogramWidgetClass *klass)
|
||||
{
|
||||
GtkObjectClass *object_class;
|
||||
|
||||
object_class = GTK_OBJECT_CLASS (klass);
|
||||
|
||||
histogram_widget_signals[RANGE_CHANGED] =
|
||||
gtk_signal_new ("range_changed",
|
||||
GTK_RUN_FIRST,
|
||||
object_class->type,
|
||||
GTK_SIGNAL_OFFSET (HistogramWidgetClass, range_changed),
|
||||
gtk_marshal_NONE__INT_INT,
|
||||
GTK_TYPE_NONE, 2,
|
||||
GTK_TYPE_INT,
|
||||
GTK_TYPE_INT);
|
||||
|
||||
gtk_object_class_add_signals (GTK_OBJECT_CLASS (klass),
|
||||
histogram_widget_signals, LAST_SIGNAL);
|
||||
|
||||
klass->range_changed = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
histogram_widget_init (HistogramWidget *histogram)
|
||||
{
|
||||
histogram->histogram = NULL;
|
||||
histogram->channel = GIMP_HISTOGRAM_VALUE;
|
||||
histogram->start = 0;
|
||||
histogram->end = 255;
|
||||
}
|
||||
|
||||
static void
|
||||
histogram_widget_draw (HistogramWidget *histogram,
|
||||
gint update)
|
||||
{
|
||||
gdouble max;
|
||||
gdouble v;
|
||||
gint i, x, y;
|
||||
gint x1, x2;
|
||||
gint width, height;
|
||||
|
||||
width = GTK_WIDGET (histogram)->allocation.width - 2;
|
||||
height = GTK_WIDGET (histogram)->allocation.height - 2;
|
||||
|
||||
if (update & HISTOGRAM)
|
||||
{
|
||||
/* find the maximum value */
|
||||
max = gimp_histogram_get_maximum (histogram->histogram,
|
||||
histogram->channel);
|
||||
|
||||
if (max > 0.0)
|
||||
max = log (max);
|
||||
else
|
||||
max = 1.0;
|
||||
|
||||
/* clear the histogram */
|
||||
gdk_window_clear (GTK_WIDGET (histogram)->window);
|
||||
|
||||
/* Draw the axis */
|
||||
gdk_draw_line (GTK_WIDGET (histogram)->window,
|
||||
GTK_WIDGET (histogram)->style->black_gc,
|
||||
1, height + 1, width, height + 1);
|
||||
|
||||
/* Draw the spikes */
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
x = (width * i) / 256 + 1;
|
||||
v = gimp_histogram_get_value (histogram->histogram,
|
||||
histogram->channel, i);
|
||||
if (v > 0.0)
|
||||
y = (int) ((height * log (v)) / max);
|
||||
else
|
||||
y = 0;
|
||||
gdk_draw_line (GTK_WIDGET (histogram)->window,
|
||||
GTK_WIDGET (histogram)->style->black_gc,
|
||||
x, height + 1,
|
||||
x, height + 1 - y);
|
||||
}
|
||||
}
|
||||
|
||||
if ((update & RANGE) && histogram->start >= 0)
|
||||
{
|
||||
x1 = (width * MIN (histogram->start, histogram->end)) / 256 + 1;
|
||||
x2 = (width * MAX (histogram->start, histogram->end)) / 256 + 1;
|
||||
gdk_gc_set_function (GTK_WIDGET (histogram)->style->black_gc, GDK_INVERT);
|
||||
gdk_draw_rectangle (GTK_WIDGET (histogram)->window,
|
||||
GTK_WIDGET (histogram)->style->black_gc, TRUE,
|
||||
x1, 1, (x2 - x1) + 1, height);
|
||||
gdk_gc_set_function (GTK_WIDGET (histogram)->style->black_gc, GDK_COPY);
|
||||
}
|
||||
}
|
||||
|
||||
static gint
|
||||
histogram_widget_events (HistogramWidget *histogram,
|
||||
GdkEvent *event)
|
||||
{
|
||||
GdkEventButton *bevent;
|
||||
GdkEventMotion *mevent;
|
||||
gint width;
|
||||
|
||||
switch (event->type)
|
||||
{
|
||||
case GDK_EXPOSE:
|
||||
histogram_widget_draw (histogram, ALL);
|
||||
break;
|
||||
|
||||
case GDK_BUTTON_PRESS:
|
||||
bevent = (GdkEventButton *) event;
|
||||
|
||||
if (bevent->button != 1)
|
||||
break;
|
||||
|
||||
gdk_pointer_grab (GTK_WIDGET (histogram)->window, FALSE,
|
||||
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON1_MOTION_MASK,
|
||||
NULL, NULL, bevent->time);
|
||||
|
||||
width = GTK_WIDGET (histogram)->allocation.width - 2;
|
||||
|
||||
histogram_widget_draw (histogram, RANGE);
|
||||
|
||||
histogram->start = CLAMP ((((bevent->x - 1) * 256) / width), 0, 255);
|
||||
histogram->end = histogram->start;
|
||||
|
||||
histogram_widget_draw (histogram, RANGE);
|
||||
break;
|
||||
|
||||
case GDK_BUTTON_RELEASE:
|
||||
bevent = (GdkEventButton *) event;
|
||||
|
||||
gdk_pointer_ungrab (bevent->time);
|
||||
|
||||
gtk_signal_emit (GTK_OBJECT(histogram),
|
||||
histogram_widget_signals[RANGE_CHANGED],
|
||||
MIN (histogram->start, histogram->end),
|
||||
MAX (histogram->start, histogram->end));
|
||||
break;
|
||||
|
||||
case GDK_MOTION_NOTIFY:
|
||||
mevent = (GdkEventMotion *) event;
|
||||
width = GTK_WIDGET (histogram)->allocation.width - 2;
|
||||
|
||||
histogram_widget_draw (histogram, RANGE);
|
||||
|
||||
histogram->start = CLAMP ((((mevent->x - 1) * 256) / width), 0, 255);
|
||||
|
||||
histogram_widget_draw (histogram, RANGE);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
HistogramWidget *
|
||||
histogram_widget_new (gint width,
|
||||
gint height)
|
||||
{
|
||||
HistogramWidget *histogram;
|
||||
|
||||
histogram = HISTOGRAM_WIDGET (gtk_type_new (HISTOGRAM_WIDGET_TYPE));
|
||||
|
||||
gtk_drawing_area_size (GTK_DRAWING_AREA (histogram), width + 2, height + 2);
|
||||
gtk_widget_set_events (GTK_WIDGET (histogram), HISTOGRAM_MASK);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (histogram), "event",
|
||||
GTK_SIGNAL_FUNC (histogram_widget_events),
|
||||
histogram);
|
||||
|
||||
return histogram;
|
||||
}
|
||||
|
||||
void
|
||||
histogram_widget_update (HistogramWidget *histogram_widget,
|
||||
GimpHistogram *hist)
|
||||
{
|
||||
histogram_widget->histogram = hist;
|
||||
|
||||
if (!hist)
|
||||
return;
|
||||
|
||||
if (histogram_widget->channel >= gimp_histogram_nchannels (hist))
|
||||
histogram_widget_channel (histogram_widget, 0);
|
||||
|
||||
/* Make sure the histogram is updated */
|
||||
gtk_widget_draw (GTK_WIDGET (histogram_widget), NULL);
|
||||
|
||||
/* Give a range callback */
|
||||
gtk_signal_emit (GTK_OBJECT (histogram_widget),
|
||||
histogram_widget_signals[RANGE_CHANGED],
|
||||
MIN (histogram_widget->start, histogram_widget->end),
|
||||
MAX (histogram_widget->start, histogram_widget->end));
|
||||
}
|
||||
|
||||
void
|
||||
histogram_widget_range (HistogramWidget *histogram,
|
||||
gint start,
|
||||
gint end)
|
||||
{
|
||||
histogram_widget_draw (histogram, RANGE);
|
||||
|
||||
histogram->start = start;
|
||||
histogram->end = end;
|
||||
|
||||
histogram_widget_draw (histogram, RANGE);
|
||||
}
|
||||
|
||||
void
|
||||
histogram_widget_channel (HistogramWidget *histogram,
|
||||
int channel)
|
||||
{
|
||||
histogram->channel = channel;
|
||||
histogram_widget_draw (histogram, ALL);
|
||||
|
||||
/* Give a range callback */
|
||||
gtk_signal_emit (GTK_OBJECT (histogram),
|
||||
histogram_widget_signals[RANGE_CHANGED],
|
||||
MIN (histogram->start, histogram->end),
|
||||
MAX (histogram->start, histogram->end));
|
||||
}
|
||||
|
||||
GimpHistogram *
|
||||
histogram_widget_histogram (HistogramWidget *histogram)
|
||||
{
|
||||
return histogram->histogram;
|
||||
}
|
|
@ -1,70 +0,0 @@
|
|||
/* The GIMP -- an image manipulation program
|
||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __HISTOGRAM_WIDGET_H__
|
||||
#define __HISTOGRAM_WIDGET_H__
|
||||
|
||||
|
||||
#include <gtk/gtkdrawingarea.h>
|
||||
|
||||
|
||||
#define HISTOGRAM_WIDGET_TYPE (histogram_widget_get_type ())
|
||||
#define HISTOGRAM_WIDGET(obj) GTK_CHECK_CAST (obj, histogram_widget_get_type (), HistogramWidget)
|
||||
#define IS_HISTOGRAM_WIDGET(obj) GTK_CHECK_TYPE (obj, histogram_widget_get_type ())
|
||||
#define HISTOGRAM_WIDGET_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, histogram_widget_get_type (), HistogramWidget)
|
||||
|
||||
|
||||
typedef struct _HistogramWidgetClass HistogramWidgetClass;
|
||||
|
||||
struct _HistogramWidget
|
||||
{
|
||||
GtkDrawingArea parent_instance;
|
||||
|
||||
GimpHistogram *histogram;
|
||||
GimpHistogramChannel channel;
|
||||
gint start;
|
||||
gint end;
|
||||
};
|
||||
|
||||
struct _HistogramWidgetClass
|
||||
{
|
||||
GtkDrawingAreaClass parent_class;
|
||||
|
||||
void (* range_changed) (HistogramWidget *hw,
|
||||
gint start,
|
||||
gint end);
|
||||
};
|
||||
|
||||
|
||||
/* Histogram functions */
|
||||
|
||||
GtkType histogram_widget_get_type (void);
|
||||
|
||||
HistogramWidget * histogram_widget_new (gint width,
|
||||
gint height);
|
||||
void histogram_widget_update (HistogramWidget *hw,
|
||||
GimpHistogram *histogram);
|
||||
void histogram_widget_range (HistogramWidget *hw,
|
||||
gint start,
|
||||
gint end);
|
||||
void histogram_widget_channel (HistogramWidget *hw,
|
||||
gint channel);
|
||||
GimpHistogram * histogram_widget_histogram (HistogramWidget *hw);
|
||||
|
||||
|
||||
#endif /* __HISTOGRAM_WIDGET_H__ */
|
|
@ -27,12 +27,13 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "brush_select.h"
|
||||
#include "gimpbrush.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpgradient.h"
|
||||
#include "gimppattern.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gradient_select.h"
|
||||
#include "indicator_area.h"
|
||||
|
|
|
@ -28,13 +28,14 @@
|
|||
#include "tools/gimpcolorpickertool.h"
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "context_manager.h"
|
||||
#include "colormaps.h"
|
||||
#include "gdisplay.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimppreview.h"
|
||||
#include "info_dialog.h"
|
||||
#include "info_window.h"
|
||||
|
||||
|
|
|
@ -25,19 +25,20 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpcontainerlistview.h"
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "color_area.h"
|
||||
#include "color_notebook.h"
|
||||
#include "context_manager.h"
|
||||
#include "dialog_handler.h"
|
||||
#include "gimage.h"
|
||||
#include "gimpcontainerlistview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpdatalist.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimppalette.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimprc.h"
|
||||
#include "palette.h"
|
||||
#include "palette_import.h"
|
||||
|
|
|
@ -27,12 +27,13 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "dialog_handler.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimppalette.h"
|
||||
|
|
|
@ -26,12 +26,13 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "context_manager.h"
|
||||
#include "dialog_handler.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimppattern.h"
|
||||
#include "pattern_select.h"
|
||||
|
|
|
@ -33,7 +33,6 @@
|
|||
#include "gimphistogram.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimplut.h"
|
||||
#include "histogramwidget.h"
|
||||
#include "invert.h"
|
||||
#include "lut_funcs.h"
|
||||
#include "pixel_processor.h"
|
||||
|
@ -43,6 +42,7 @@
|
|||
#include "tools/histogram_tool.h"
|
||||
#include "tools/hue_saturation.h"
|
||||
#include "tools/threshold.h"
|
||||
#include "widgets/gimphistogramview.h"
|
||||
|
||||
static ProcRecord brightness_contrast_proc;
|
||||
static ProcRecord levels_proc;
|
||||
|
|
|
@ -29,7 +29,8 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "color_panel.h"
|
||||
#include "widgets/gimpcolorpanel.h"
|
||||
|
||||
#include "drawable.h"
|
||||
#include "floating_sel.h"
|
||||
#include "gdisplay.h"
|
||||
|
|
|
@ -27,22 +27,23 @@
|
|||
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimpcontainerlistview.h"
|
||||
#include "widgets/gimpcontainergridview.h"
|
||||
#include "widgets/gimpdatafactoryview.h"
|
||||
#include "widgets/gimpdock.h"
|
||||
#include "widgets/gimpdockable.h"
|
||||
#include "widgets/gimpdockbook.h"
|
||||
#include "widgets/gimpdrawablelistview.h"
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "context_manager.h"
|
||||
#include "gradient_editor.h"
|
||||
#include "gimpchannel.h"
|
||||
#include "gimpcontainer.h"
|
||||
#include "gimpcontainerlistview.h"
|
||||
#include "gimpcontainergridview.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdatafactory.h"
|
||||
#include "gimpdatafactoryview.h"
|
||||
#include "gimpdock.h"
|
||||
#include "gimpdockable.h"
|
||||
#include "gimpdockbook.h"
|
||||
#include "gimpdrawablelistview.h"
|
||||
#include "gimpimage.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimprc.h"
|
||||
|
||||
#include "libgimp/gimpintl.h"
|
||||
|
|
|
@ -32,6 +32,9 @@
|
|||
#include "tools/tool_options_dialog.h"
|
||||
#include "tools/tool_manager.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
#include "widgets/gtkhwrapbox.h"
|
||||
|
||||
#include "app_procs.h"
|
||||
#include "color_area.h"
|
||||
#include "devices.h"
|
||||
|
@ -42,9 +45,7 @@
|
|||
#include "gimpdnd.h"
|
||||
#include "gimplayer.h"
|
||||
#include "gimplist.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimprc.h"
|
||||
#include "gtkhwrapbox.h"
|
||||
#include "indicator_area.h"
|
||||
#include "menus.h"
|
||||
#include "session.h"
|
||||
|
|
|
@ -24,9 +24,10 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gtkhwrapbox.h"
|
||||
|
||||
#include "gimpcontext.h"
|
||||
#include "gimprc.h"
|
||||
#include "gtkhwrapbox.h"
|
||||
|
||||
#include "gimptool.h"
|
||||
#include "gimptoolinfo.h"
|
||||
|
|
|
@ -24,9 +24,10 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gtkhwrapbox.h"
|
||||
|
||||
#include "gimpcontext.h"
|
||||
#include "gimprc.h"
|
||||
#include "gtkhwrapbox.h"
|
||||
|
||||
#include "gimptool.h"
|
||||
#include "gimptoolinfo.h"
|
||||
|
|
|
@ -24,11 +24,12 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "widgets/gimppreview.h"
|
||||
|
||||
#include "dialog_handler.h"
|
||||
#include "gimpcontext.h"
|
||||
#include "gimpdnd.h"
|
||||
#include "gimplist.h"
|
||||
#include "gimppreview.h"
|
||||
#include "gimpui.h"
|
||||
#include "session.h"
|
||||
|
||||
|
|
|
@ -5,6 +5,8 @@ noinst_LTLIBRARIES = libappwidgets.la
|
|||
libappwidgets_la_SOURCES = \
|
||||
gimpbrushpreview.c \
|
||||
gimpbrushpreview.h \
|
||||
gimpcolorpanel.c \
|
||||
gimpcolorpanel.h \
|
||||
gimpcontainergridview.h \
|
||||
gimpcontainergridview.c \
|
||||
gimpcontainerlistview.h \
|
||||
|
|
|
@ -24,8 +24,9 @@
|
|||
|
||||
#include "apptypes.h"
|
||||
|
||||
#include "gimpcolorpanel.h"
|
||||
|
||||
#include "appenv.h"
|
||||
#include "color_panel.h"
|
||||
#include "color_notebook.h"
|
||||
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue