dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Started migration from GtkList to GtkTreeView: 

2003-02-21  Michael Natterer  <mitch@gimp.org>

	Started migration from GtkList to GtkTreeView:

	* app/widgets/Makefile.am
	* app/widgets/widgets-types.h
	* app/widgets/gimpcontainertreeview.[ch]; new GimpContainerView
	subclass using GtkListStore/GtkTreeView.

	* app/widgets/widgets-enums.h: added GIMP_VIEW_TYPE_TREE to
	thje GimpViewType enum.

	* app/widgets/gimpcontainereditor.c: added GimpContainerTreeView
	to the switch() which selects the view type.

	* app/gui/dialogs-commands.c
	* app/gui/dialogs-constructors.[ch]
	* app/gui/dialogs-menu.c
	* app/gui/dialogs.c: added tree view versions of many dialogs.

	* app/widgets/gimppreview.[ch]: removed the get_size() virtual
	function and gimp_preview_calc_size().

	* app/core/gimpviewable.[ch]: added virtual function
	get_preview_size() and gimp_viewable_calc_preview_size().

	* app/core/gimpbuffer.c
	* app/core/gimpdrawable-preview.[ch]
	* app/core/gimpdrawable.c
	* app/core/gimpgradient.c
	* app/core/gimpimage.c
	* app/core/gimppalette.c: added get_preview_size() implementations.

	* app/widgets/gimpbufferpreview.c
	* app/widgets/gimpdrawablepreview.c
	* app/widgets/gimpgradientpreview.c
	* app/widgets/gimpimagepreview.c
	* app/widgets/gimppalettepreview.c
	* app/widgets/gimpselectioneditor.c
	* app/widgets/gimpundopreview.c
	* app/display/gimpnavigationview.c: changed accordingly, removed
	get_size() implementations.

	* app/widgets/widgets-types.h: changed the first param of
	GimpItemGetNameFunc from GtkWidget to GObject.

	* app/widgets/gimpcontainerview-utils.c: accept a GimpViewable as
	object in the built-in get_name funcs.

	* app/widgets/gimpcomponentlistitem.c
	* app/widgets/gimpcontainergridview.c
	* app/widgets/gimplistitem.c
	* app/widgets/gimpmenuitem.c: changed accordingly.
This commit is contained in:
Michael Natterer 2003-02-21 19:03:19 +00:00 committed by Michael Natterer
parent 758635d7a4
commit 9ee632a656
53 changed files with 1997 additions and 1109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
ChangeLog
View File

@ -1,3 +1,57 @@
2003-02-21 Michael Natterer <mitch@gimp.org>
Started migration from GtkList to GtkTreeView:
* app/widgets/Makefile.am
* app/widgets/widgets-types.h
* app/widgets/gimpcontainertreeview.[ch]; new GimpContainerView
subclass using GtkListStore/GtkTreeView.
* app/widgets/widgets-enums.h: added GIMP_VIEW_TYPE_TREE to
thje GimpViewType enum.
* app/widgets/gimpcontainereditor.c: added GimpContainerTreeView
to the switch() which selects the view type.
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.[ch]
* app/gui/dialogs-menu.c
* app/gui/dialogs.c: added tree view versions of many dialogs.
* app/widgets/gimppreview.[ch]: removed the get_size() virtual
function and gimp_preview_calc_size().
* app/core/gimpviewable.[ch]: added virtual function
get_preview_size() and gimp_viewable_calc_preview_size().
* app/core/gimpbuffer.c
* app/core/gimpdrawable-preview.[ch]
* app/core/gimpdrawable.c
* app/core/gimpgradient.c
* app/core/gimpimage.c
* app/core/gimppalette.c: added get_preview_size() implementations.
* app/widgets/gimpbufferpreview.c
* app/widgets/gimpdrawablepreview.c
* app/widgets/gimpgradientpreview.c
* app/widgets/gimpimagepreview.c
* app/widgets/gimppalettepreview.c
* app/widgets/gimpselectioneditor.c
* app/widgets/gimpundopreview.c
* app/display/gimpnavigationview.c: changed accordingly, removed
get_size() implementations.
* app/widgets/widgets-types.h: changed the first param of
GimpItemGetNameFunc from GtkWidget to GObject.
* app/widgets/gimpcontainerview-utils.c: accept a GimpViewable as
object in the built-in get_name funcs.
* app/widgets/gimpcomponentlistitem.c
* app/widgets/gimpcontainergridview.c
* app/widgets/gimplistitem.c
* app/widgets/gimpmenuitem.c: changed accordingly.
2003-02-21 Sven Neumann <sven@gimp.org>
* app/display/gimpdisplayshell-scroll.c (gimp_display_shell_scroll):

24
app/actions/dialogs-commands.c
View File

@ -172,16 +172,13 @@ dialogs_toggle_view_cmd_callback (GtkWidget *widget,
identifier = g_strdup (entry->identifier);
if ((substring = strstr (identifier, "grid")) &&
view_type == GIMP_VIEW_TYPE_LIST)
{
memcpy (substring, "list", 4);
}
else if ((substring = strstr (identifier, "list")) &&
view_type == GIMP_VIEW_TYPE_GRID)
{
memcpy (substring, "grid", 4);
}
substring = strstr (identifier, "grid");
if (! substring)
substring = strstr (identifier, "list");
if (! substring)
substring = strstr (identifier, "grid");
if (substring)
{
@ -189,6 +186,13 @@ dialogs_toggle_view_cmd_callback (GtkWidget *widget,
GtkWidget *new_dockable;
gint preview_size = -1;
if (view_type == GIMP_VIEW_TYPE_LIST)
memcpy (substring, "list", 4);
else if (view_type == GIMP_VIEW_TYPE_GRID)
memcpy (substring, "grid", 4);
else if (view_type == GIMP_VIEW_TYPE_TREE)
memcpy (substring, "tree", 4);
old_view = gimp_container_view_get_by_dockable (dockable);
if (old_view)

50
app/core/gimpbuffer.c
View File

@ -33,16 +33,22 @@
#include "gimpbuffer.h"
static void gimp_buffer_class_init (GimpBufferClass *klass);
static void gimp_buffer_init (GimpBuffer *buffer);
static void gimp_buffer_class_init (GimpBufferClass *klass);
static void gimp_buffer_init (GimpBuffer *buffer);
static void gimp_buffer_finalize (GObject *object);
static void gimp_buffer_finalize (GObject *object);
static gsize gimp_buffer_get_memsize (GimpObject *object);
static gsize gimp_buffer_get_memsize (GimpObject *object);
static TempBuf * gimp_buffer_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
static void gimp_buffer_get_preview_size (GimpViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *width,
gint *height);
static TempBuf * gimp_buffer_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
static GimpViewableClass *parent_class = NULL;
@ -89,11 +95,12 @@ gimp_buffer_class_init (GimpBufferClass *klass)
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_buffer_finalize;
object_class->finalize = gimp_buffer_finalize;
gimp_object_class->get_memsize = gimp_buffer_get_memsize;
gimp_object_class->get_memsize = gimp_buffer_get_memsize;
viewable_class->get_new_preview = gimp_buffer_get_new_preview;
viewable_class->get_preview_size = gimp_buffer_get_preview_size;
viewable_class->get_new_preview = gimp_buffer_get_new_preview;
}
static void
@ -132,6 +139,29 @@ gimp_buffer_get_memsize (GimpObject *object)
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object);
}
static void
gimp_buffer_get_preview_size (GimpViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
GimpBuffer *buffer;
buffer = GIMP_BUFFER (viewable);
gimp_viewable_calc_preview_size (viewable,
gimp_buffer_get_width (buffer),
gimp_buffer_get_height (buffer),
size,
size,
dot_for_dot, 1.0, 1.0,
width,
height,
NULL);
}
static TempBuf *
gimp_buffer_get_new_preview (GimpViewable *viewable,
gint width,

44
app/core/gimpdrawable-preview.c
View File

@ -54,6 +54,50 @@ static void gimp_drawable_preview_scale (GimpImageBaseType type,
/* public functions */
void
gimp_drawable_get_preview_size (GimpViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
GimpDrawable *drawable;
GimpImage *gimage;
drawable = GIMP_DRAWABLE (viewable);
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
if (gimage && ! is_popup)
{
gimp_viewable_calc_preview_size (viewable,
gimage->width,
gimage->height,
size,
size,
dot_for_dot,
gimage->xresolution,
gimage->yresolution,
width,
height,
NULL);
}
else
{
gimp_viewable_calc_preview_size (viewable,
drawable->width,
drawable->height,
size,
size,
dot_for_dot,
1.0,
1.0,
width,
height,
NULL);
}
}
TempBuf *
gimp_drawable_get_preview (GimpViewable *viewable,
gint width,

14
app/core/gimpdrawable-preview.h
View File

@ -21,12 +21,18 @@
/*
* virtual function of GimpDrawable -- dont't call directly
* virtual functions of GimpDrawable -- dont't call directly
*/
TempBuf * gimp_drawable_get_preview (GimpViewable *viewable,
gint width,
gint height);
void gimp_drawable_get_preview_size (GimpViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *width,
gint *height);
TempBuf * gimp_drawable_get_preview (GimpViewable *viewable,
gint width,
gint height);
#endif /* __GIMP_DRAWABLE__PREVIEW_H__ */

1
app/core/gimpdrawable.c
View File

@ -140,6 +140,7 @@ gimp_drawable_class_init (GimpDrawableClass *klass)
gimp_object_class->get_memsize = gimp_drawable_get_memsize;
viewable_class->invalidate_preview = gimp_drawable_invalidate_preview;
viewable_class->get_preview_size = gimp_drawable_get_preview_size;
viewable_class->get_preview = gimp_drawable_get_preview;
item_class->duplicate = gimp_drawable_duplicate;

59
app/core/gimpgradient.c
View File

@ -42,22 +42,28 @@
#define EPSILON 1e-10
static void gimp_gradient_class_init (GimpGradientClass *klass);
static void gimp_gradient_init (GimpGradient *gradient);
static void gimp_gradient_class_init (GimpGradientClass *klass);
static void gimp_gradient_init (GimpGradient *gradient);
static void gimp_gradient_finalize (GObject *object);
static void gimp_gradient_finalize (GObject *object);
static gsize gimp_gradient_get_memsize (GimpObject *object);
static gsize gimp_gradient_get_memsize (GimpObject *object);
static TempBuf * gimp_gradient_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
static void gimp_gradient_dirty (GimpData *data);
static gboolean gimp_gradient_save (GimpData *data,
GError **error);
static gchar * gimp_gradient_get_extension (GimpData *data);
static GimpData * gimp_gradient_duplicate (GimpData *data,
gboolean stingy_memory_use);
static void gimp_gradient_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height);
static TempBuf * gimp_gradient_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
static void gimp_gradient_dirty (GimpData *data);
static gboolean gimp_gradient_save (GimpData *data,
GError **error);
static gchar * gimp_gradient_get_extension (GimpData *data);
static GimpData * gimp_gradient_duplicate (GimpData *data,
gboolean stingy_memory_use);
static gdouble gimp_gradient_calc_linear_factor (gdouble middle,
gdouble pos);
@ -117,16 +123,17 @@ gimp_gradient_class_init (GimpGradientClass *klass)
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_gradient_finalize;
object_class->finalize = gimp_gradient_finalize;
gimp_object_class->get_memsize = gimp_gradient_get_memsize;
gimp_object_class->get_memsize = gimp_gradient_get_memsize;
viewable_class->get_new_preview = gimp_gradient_get_new_preview;
viewable_class->get_preview_size = gimp_gradient_get_preview_size;
viewable_class->get_new_preview = gimp_gradient_get_new_preview;
data_class->dirty = gimp_gradient_dirty;
data_class->save = gimp_gradient_save;
data_class->get_extension = gimp_gradient_get_extension;
data_class->duplicate = gimp_gradient_duplicate;
data_class->dirty = gimp_gradient_dirty;
data_class->save = gimp_gradient_save;
data_class->get_extension = gimp_gradient_get_extension;
data_class->duplicate = gimp_gradient_duplicate;
}
static void
@ -169,6 +176,18 @@ gimp_gradient_get_memsize (GimpObject *object)
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object);
}
static void
gimp_gradient_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
*width = size;
*height = size / 2;
}
static TempBuf *
gimp_gradient_get_new_preview (GimpViewable *viewable,
gint width,

32
app/core/gimpimage.c
View File

@ -109,6 +109,12 @@ static gsize gimp_image_get_memsize (GimpObject *object);
static void gimp_image_invalidate_preview (GimpViewable *viewable);
static void gimp_image_size_changed (GimpViewable *viewable);
static void gimp_image_get_preview_size (GimpViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *width,
gint *height);
static TempBuf *gimp_image_get_preview (GimpViewable *gimage,
gint width,
gint height);
@ -393,6 +399,7 @@ gimp_image_class_init (GimpImageClass *klass)
viewable_class->invalidate_preview = gimp_image_invalidate_preview;
viewable_class->size_changed = gimp_image_size_changed;
viewable_class->get_preview_size = gimp_image_get_preview_size;
viewable_class->get_preview = gimp_image_get_preview;
viewable_class->get_new_preview = gimp_image_get_new_preview;
@ -677,6 +684,31 @@ gimp_image_size_changed (GimpViewable *viewable)
NULL);
}
static void
gimp_image_get_preview_size (GimpViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
GimpImage *gimage;
gimage = GIMP_IMAGE (viewable);
gimp_viewable_calc_preview_size (viewable,
gimage->width,
gimage->height,
size,
size,
dot_for_dot,
gimage->xresolution,
gimage->yresolution,
width,
height,
NULL);
}
static TempBuf *
gimp_image_get_preview (GimpViewable *viewable,
gint width,

31
app/core/gimppalette-load.c
View File

@ -48,6 +48,12 @@ static void gimp_palette_finalize (GObject *object);
static gsize gimp_palette_get_memsize (GimpObject *object);
static void gimp_palette_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height);
static TempBuf * gimp_palette_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
@ -107,15 +113,16 @@ gimp_palette_class_init (GimpPaletteClass *klass)
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_palette_finalize;
object_class->finalize = gimp_palette_finalize;
gimp_object_class->get_memsize = gimp_palette_get_memsize;
gimp_object_class->get_memsize = gimp_palette_get_memsize;
viewable_class->get_new_preview = gimp_palette_get_new_preview;
viewable_class->get_preview_size = gimp_palette_get_preview_size;
viewable_class->get_new_preview = gimp_palette_get_new_preview;
data_class->dirty = gimp_palette_dirty;
data_class->save = gimp_palette_save;
data_class->get_extension = gimp_palette_get_extension;
data_class->dirty = gimp_palette_dirty;
data_class->save = gimp_palette_save;
data_class->get_extension = gimp_palette_get_extension;
}
static void
@ -169,6 +176,18 @@ gimp_palette_get_memsize (GimpObject *object)
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object);
}
static void
gimp_palette_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
*width = size;
*height = size / 2;
}
static TempBuf *
gimp_palette_get_new_preview (GimpViewable *viewable,
gint width,

31
app/core/gimppalette-save.c
View File

@ -48,6 +48,12 @@ static void gimp_palette_finalize (GObject *object);
static gsize gimp_palette_get_memsize (GimpObject *object);
static void gimp_palette_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height);
static TempBuf * gimp_palette_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
@ -107,15 +113,16 @@ gimp_palette_class_init (GimpPaletteClass *klass)
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_palette_finalize;
object_class->finalize = gimp_palette_finalize;
gimp_object_class->get_memsize = gimp_palette_get_memsize;
gimp_object_class->get_memsize = gimp_palette_get_memsize;
viewable_class->get_new_preview = gimp_palette_get_new_preview;
viewable_class->get_preview_size = gimp_palette_get_preview_size;
viewable_class->get_new_preview = gimp_palette_get_new_preview;
data_class->dirty = gimp_palette_dirty;
data_class->save = gimp_palette_save;
data_class->get_extension = gimp_palette_get_extension;
data_class->dirty = gimp_palette_dirty;
data_class->save = gimp_palette_save;
data_class->get_extension = gimp_palette_get_extension;
}
static void
@ -169,6 +176,18 @@ gimp_palette_get_memsize (GimpObject *object)
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object);
}
static void
gimp_palette_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
*width = size;
*height = size / 2;
}
static TempBuf *
gimp_palette_get_new_preview (GimpViewable *viewable,
gint width,

31
app/core/gimppalette.c
View File

@ -48,6 +48,12 @@ static void gimp_palette_finalize (GObject *object);
static gsize gimp_palette_get_memsize (GimpObject *object);
static void gimp_palette_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height);
static TempBuf * gimp_palette_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
@ -107,15 +113,16 @@ gimp_palette_class_init (GimpPaletteClass *klass)
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_palette_finalize;
object_class->finalize = gimp_palette_finalize;
gimp_object_class->get_memsize = gimp_palette_get_memsize;
gimp_object_class->get_memsize = gimp_palette_get_memsize;
viewable_class->get_new_preview = gimp_palette_get_new_preview;
viewable_class->get_preview_size = gimp_palette_get_preview_size;
viewable_class->get_new_preview = gimp_palette_get_new_preview;
data_class->dirty = gimp_palette_dirty;
data_class->save = gimp_palette_save;
data_class->get_extension = gimp_palette_get_extension;
data_class->dirty = gimp_palette_dirty;
data_class->save = gimp_palette_save;
data_class->get_extension = gimp_palette_get_extension;
}
static void
@ -169,6 +176,18 @@ gimp_palette_get_memsize (GimpObject *object)
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object);
}
static void
gimp_palette_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
*width = size;
*height = size / 2;
}
static TempBuf *
gimp_palette_get_new_preview (GimpViewable *viewable,
gint width,

89
app/core/gimpviewable.c
View File

@ -46,6 +46,13 @@ static gsize gimp_viewable_get_memsize (GimpObject *object);
static void gimp_viewable_real_invalidate_preview (GimpViewable *viewable);
static void gimp_viewable_real_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height);
static guint viewable_signals[LAST_SIGNAL] = { 0 };
@ -120,6 +127,7 @@ gimp_viewable_class_init (GimpViewableClass *klass)
klass->invalidate_preview = gimp_viewable_real_invalidate_preview;
klass->size_changed = NULL;
klass->get_preview_size = gimp_viewable_real_get_preview_size;
klass->get_preview = NULL;
klass->get_new_preview = NULL;
}
@ -165,6 +173,27 @@ gimp_viewable_get_memsize (GimpObject *object)
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object);
}
static void
gimp_viewable_real_invalidate_preview (GimpViewable *viewable)
{
g_return_if_fail (GIMP_IS_VIEWABLE (viewable));
g_object_set_qdata (G_OBJECT (viewable), quark_preview_temp_buf, NULL);
g_object_set_qdata (G_OBJECT (viewable), quark_preview_pixbuf, NULL);
}
static void
gimp_viewable_real_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
*width = size;
*height = size;
}
void
gimp_viewable_invalidate_preview (GimpViewable *viewable)
{
@ -181,13 +210,65 @@ gimp_viewable_size_changed (GimpViewable *viewable)
g_signal_emit (viewable, viewable_signals[SIZE_CHANGED], 0);
}
static void
gimp_viewable_real_invalidate_preview (GimpViewable *viewable)
void
gimp_viewable_calc_preview_size (GimpViewable *viewable,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gboolean dot_for_dot,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up)
{
gdouble xratio;
gdouble yratio;
g_return_if_fail (GIMP_IS_VIEWABLE (viewable));
g_object_set_qdata (G_OBJECT (viewable), quark_preview_temp_buf, NULL);
g_object_set_qdata (G_OBJECT (viewable), quark_preview_pixbuf, NULL);
if (aspect_width > aspect_height)
{
xratio = yratio = (gdouble) width / (gdouble) aspect_width;
}
else
{
xratio = yratio = (gdouble) height / (gdouble) aspect_height;
}
if (dot_for_dot && xresolution != yresolution)
{
yratio *= xresolution / yresolution;
}
width = RINT (xratio * (gdouble) aspect_width);
height = RINT (yratio * (gdouble) aspect_height);
if (width < 1) width = 1;
if (height < 1) height = 1;
if (return_width) *return_width = width;
if (return_height) *return_height = height;
if (scaling_up) *scaling_up = (xratio > 1.0) || (yratio > 1.0);
}
void
gimp_viewable_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
g_return_if_fail (GIMP_IS_VIEWABLE (viewable));
g_return_if_fail (size > 0);
g_return_if_fail (width != NULL);
g_return_if_fail (height != NULL);
GIMP_VIEWABLE_GET_CLASS (viewable)->get_preview_size (viewable, size,
popup, dot_for_dot,
width, height);
}
TempBuf *

24
app/core/gimpviewable.h
View File

@ -54,6 +54,12 @@ struct _GimpViewableClass
void (* size_changed) (GimpViewable *viewable);
/* virtual functions */
void (* get_preview_size) (GimpViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *width,
gint *height);
TempBuf * (* get_preview) (GimpViewable *viewable,
gint width,
gint height);
@ -68,6 +74,24 @@ GType gimp_viewable_get_type (void) G_GNUC_CONST;
void gimp_viewable_invalidate_preview (GimpViewable *viewable);
void gimp_viewable_size_changed (GimpViewable *viewable);
void gimp_viewable_calc_preview_size (GimpViewable *viewable,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gboolean dot_for_dot,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up);
void gimp_viewable_get_preview_size (GimpViewable *viewable,
gint size,
gboolean popup,
gboolean dot_for_dot,
gint *width,
gint *height);
TempBuf * gimp_viewable_get_preview (GimpViewable *viewable,
gint width,
gint height);

149
app/dialogs/dialogs-constructors.c
View File

@ -43,6 +43,7 @@
#include "widgets/gimpcolormapeditor.h"
#include "widgets/gimpcontainerlistview.h"
#include "widgets/gimpcontainergridview.h"
#include "widgets/gimpcontainertreeview.h"
#include "widgets/gimpdataeditor.h"
#include "widgets/gimpdatafactoryview.h"
#include "widgets/gimpdialogfactory.h"
@ -587,6 +588,154 @@ dialogs_buffer_grid_view_new (GimpDialogFactory *factory,
}
/***** tree views *****/
GtkWidget *
dialogs_image_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_image_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->images,
context,
preview_size,
5, 3,
factory->menu_factory);
return dialogs_dockable_new (view,
_("Image Tree"), _("Images"), NULL,
NULL,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_brush_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_brush_factory_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->brush_factory,
dialogs_edit_brush_func,
context,
TRUE,
preview_size,
5, 3,
factory->menu_factory);
return dialogs_dockable_new (view,
_("Brush Tree"), _("Brushes"), NULL,
dialogs_brush_tab_func,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_pattern_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->pattern_factory,
NULL,
context,
preview_size,
5, 3,
factory->menu_factory, "<Patterns>");
return dialogs_dockable_new (view,
_("Pattern Tree"), _("Patterns"), NULL,
dialogs_pattern_tab_func,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_gradient_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->gradient_factory,
dialogs_edit_gradient_func,
context,
preview_size,
5, 3,
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Gradient Tree"), _("Gradients"), NULL,
dialogs_gradient_tab_func,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_palette_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->palette_factory,
dialogs_edit_palette_func,
context,
preview_size,
5, 3,
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Palette Tree"), _("Palettes"), NULL,
dialogs_palette_tab_func,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_tool_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_container_tree_view_new (context->gimp->tool_info_list,
context,
preview_size,
FALSE,
5, 3);
return dialogs_dockable_new (view,
_("Tool Tree"), _("Tools"), NULL,
dialogs_tool_tab_func,
dialogs_set_view_context_func);
}
GtkWidget *
dialogs_buffer_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_buffer_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->named_buffers,
context,
preview_size,
5, 3,
factory->menu_factory);
return dialogs_dockable_new (view,
_("Buffer Tree"), _("Buffers"),
GTK_STOCK_PASTE,
dialogs_stock_text_tab_func,
dialogs_set_editor_context_func);
}
/***** image related dialogs *****/
GtkWidget *

22
app/dialogs/dialogs-constructors.h
View File

@ -105,6 +105,28 @@ GtkWidget * dialogs_buffer_grid_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_image_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_brush_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_pattern_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_gradient_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_palette_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_tool_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_buffer_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_layer_list_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);

8
app/dialogs/dialogs.c
View File

@ -69,6 +69,14 @@ static const GimpDialogFactoryEntry dock_entries[] =
{ "gimp-tool-grid", dialogs_tool_grid_view_new, 24, FALSE, FALSE, FALSE, TRUE },
{ "gimp-buffer-grid", dialogs_buffer_grid_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-image-tree", dialogs_image_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-brush-tree", dialogs_brush_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-pattern-tree", dialogs_pattern_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-gradient-tree", dialogs_gradient_tree_view_new, 16, FALSE, FALSE, FALSE, TRUE },
{ "gimp-palette-tree", dialogs_palette_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-tool-tree", dialogs_tool_tree_view_new, 24, FALSE, FALSE, FALSE, TRUE },
{ "gimp-buffer-tree", dialogs_buffer_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-layer-list", dialogs_layer_list_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-channel-list", dialogs_channel_list_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-vectors-list", dialogs_vectors_list_view_new, 32, FALSE, FALSE, FALSE, TRUE },

23
app/display/gimpnavigationeditor.c
View File

@ -491,16 +491,19 @@ gimp_navigation_view_abox_resized (GtkWidget *widget,
gimage = GIMP_IMAGE (preview->viewable);
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
MIN (allocation->width, GIMP_PREVIEW_MAX_SIZE),
MIN (allocation->height, GIMP_PREVIEW_MAX_SIZE),
gimage->xresolution,
gimage->yresolution,
&width,
&height,
&dummy);
gimp_viewable_calc_preview_size (preview->viewable,
gimage->width,
gimage->height,
MIN (allocation->width,
GIMP_PREVIEW_MAX_SIZE),
MIN (allocation->height,
GIMP_PREVIEW_MAX_SIZE),
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&width,
&height,
&dummy);
if (width > allocation->width)
{

23
app/display/gimpnavigationview.c
View File

@ -491,16 +491,19 @@ gimp_navigation_view_abox_resized (GtkWidget *widget,
gimage = GIMP_IMAGE (preview->viewable);
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
MIN (allocation->width, GIMP_PREVIEW_MAX_SIZE),
MIN (allocation->height, GIMP_PREVIEW_MAX_SIZE),
gimage->xresolution,
gimage->yresolution,
&width,
&height,
&dummy);
gimp_viewable_calc_preview_size (preview->viewable,
gimage->width,
gimage->height,
MIN (allocation->width,
GIMP_PREVIEW_MAX_SIZE),
MIN (allocation->height,
GIMP_PREVIEW_MAX_SIZE),
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&width,
&height,
&dummy);
if (width > allocation->width)
{

24
app/gui/dialogs-commands.c
View File

@ -172,16 +172,13 @@ dialogs_toggle_view_cmd_callback (GtkWidget *widget,
identifier = g_strdup (entry->identifier);
if ((substring = strstr (identifier, "grid")) &&
view_type == GIMP_VIEW_TYPE_LIST)
{
memcpy (substring, "list", 4);
}
else if ((substring = strstr (identifier, "list")) &&
view_type == GIMP_VIEW_TYPE_GRID)
{
memcpy (substring, "grid", 4);
}
substring = strstr (identifier, "grid");
if (! substring)
substring = strstr (identifier, "list");
if (! substring)
substring = strstr (identifier, "grid");
if (substring)
{
@ -189,6 +186,13 @@ dialogs_toggle_view_cmd_callback (GtkWidget *widget,
GtkWidget *new_dockable;
gint preview_size = -1;
if (view_type == GIMP_VIEW_TYPE_LIST)
memcpy (substring, "list", 4);
else if (view_type == GIMP_VIEW_TYPE_GRID)
memcpy (substring, "grid", 4);
else if (view_type == GIMP_VIEW_TYPE_TREE)
memcpy (substring, "tree", 4);
old_view = gimp_container_view_get_by_dockable (dockable);
if (old_view)

149
app/gui/dialogs-constructors.c
View File

@ -43,6 +43,7 @@
#include "widgets/gimpcolormapeditor.h"
#include "widgets/gimpcontainerlistview.h"
#include "widgets/gimpcontainergridview.h"
#include "widgets/gimpcontainertreeview.h"
#include "widgets/gimpdataeditor.h"
#include "widgets/gimpdatafactoryview.h"
#include "widgets/gimpdialogfactory.h"
@ -587,6 +588,154 @@ dialogs_buffer_grid_view_new (GimpDialogFactory *factory,
}
/***** tree views *****/
GtkWidget *
dialogs_image_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_image_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->images,
context,
preview_size,
5, 3,
factory->menu_factory);
return dialogs_dockable_new (view,
_("Image Tree"), _("Images"), NULL,
NULL,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_brush_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_brush_factory_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->brush_factory,
dialogs_edit_brush_func,
context,
TRUE,
preview_size,
5, 3,
factory->menu_factory);
return dialogs_dockable_new (view,
_("Brush Tree"), _("Brushes"), NULL,
dialogs_brush_tab_func,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_pattern_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->pattern_factory,
NULL,
context,
preview_size,
5, 3,
factory->menu_factory, "<Patterns>");
return dialogs_dockable_new (view,
_("Pattern Tree"), _("Patterns"), NULL,
dialogs_pattern_tab_func,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_gradient_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->gradient_factory,
dialogs_edit_gradient_func,
context,
preview_size,
5, 3,
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Gradient Tree"), _("Gradients"), NULL,
dialogs_gradient_tab_func,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_palette_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_data_factory_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->palette_factory,
dialogs_edit_palette_func,
context,
preview_size,
5, 3,
factory->menu_factory, "<Gradients>");
return dialogs_dockable_new (view,
_("Palette Tree"), _("Palettes"), NULL,
dialogs_palette_tab_func,
dialogs_set_editor_context_func);
}
GtkWidget *
dialogs_tool_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_container_tree_view_new (context->gimp->tool_info_list,
context,
preview_size,
FALSE,
5, 3);
return dialogs_dockable_new (view,
_("Tool Tree"), _("Tools"), NULL,
dialogs_tool_tab_func,
dialogs_set_view_context_func);
}
GtkWidget *
dialogs_buffer_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
GtkWidget *view;
view = gimp_buffer_view_new (GIMP_VIEW_TYPE_TREE,
context->gimp->named_buffers,
context,
preview_size,
5, 3,
factory->menu_factory);
return dialogs_dockable_new (view,
_("Buffer Tree"), _("Buffers"),
GTK_STOCK_PASTE,
dialogs_stock_text_tab_func,
dialogs_set_editor_context_func);
}
/***** image related dialogs *****/
GtkWidget *

22
app/gui/dialogs-constructors.h
View File

@ -105,6 +105,28 @@ GtkWidget * dialogs_buffer_grid_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_image_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_brush_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_pattern_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_gradient_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_palette_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_tool_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_buffer_tree_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_layer_list_view_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);

41
app/gui/dialogs-menu.c
View File

@ -127,6 +127,9 @@ GimpItemFactoryEntry dialogs_menu_entries[] =
{ { N_("/View as Grid"), NULL,
dialogs_toggle_view_cmd_callback, GIMP_VIEW_TYPE_GRID, "/View as List" },
NULL, NULL, NULL },
{ { N_("/View as Tree"), NULL,
dialogs_toggle_view_cmd_callback, GIMP_VIEW_TYPE_TREE, "/View as List" },
NULL, NULL, NULL },
MENU_SEPARATOR ("/image-menu-separator"),
@ -158,9 +161,11 @@ dialogs_menu_update (GtkItemFactory *factory,
gint page_num;
GimpDialogFactoryEntry *entry;
GimpContainerView *view;
GimpViewType view_type = -1;
gboolean other_view_type = FALSE;
GimpPreviewSize preview_size = GIMP_PREVIEW_SIZE_NONE;
GimpViewType view_type = -1;
gboolean list_view_available = FALSE;
gboolean grid_view_available = FALSE;
gboolean tree_view_available = FALSE;
GimpPreviewSize preview_size = GIMP_PREVIEW_SIZE_NONE;
page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
@ -181,17 +186,25 @@ dialogs_menu_update (GtkItemFactory *factory,
view_type = GIMP_VIEW_TYPE_GRID;
else if ((substring = strstr (identifier, "list")))
view_type = GIMP_VIEW_TYPE_LIST;
else if ((substring = strstr (identifier, "tree")))
view_type = GIMP_VIEW_TYPE_TREE;
if (substring)
{
if (view_type == GIMP_VIEW_TYPE_GRID)
memcpy (substring, "list", 4);
else if (view_type == GIMP_VIEW_TYPE_LIST)
memcpy (substring, "grid", 4);
memcpy (substring, "list", 4);
if (gimp_dialog_factory_find_entry (dockbook->dock->dialog_factory,
identifier))
other_view_type = TRUE;
list_view_available = TRUE;
memcpy (substring, "grid", 4);
if (gimp_dialog_factory_find_entry (dockbook->dock->dialog_factory,
identifier))
grid_view_available = TRUE;
memcpy (substring, "tree", 4);
if (gimp_dialog_factory_find_entry (dockbook->dock->dialog_factory,
identifier))
tree_view_available = TRUE;
}
g_free (identifier);
@ -256,16 +269,20 @@ dialogs_menu_update (GtkItemFactory *factory,
SET_VISIBLE ("/View as Grid", view_type != -1);
SET_VISIBLE ("/View as List", view_type != -1);
SET_VISIBLE ("/View as Tree", view_type != -1);
if (view_type != -1)
{
if (view_type == GIMP_VIEW_TYPE_LIST)
SET_ACTIVE ("/View as List", TRUE);
else
else if (view_type == GIMP_VIEW_TYPE_GRID)
SET_ACTIVE ("/View as Grid", TRUE);
else
SET_ACTIVE ("/View as Tree", TRUE);
SET_SENSITIVE ("/View as Grid", other_view_type);
SET_SENSITIVE ("/View as List", other_view_type);
SET_SENSITIVE ("/View as Grid", grid_view_available);
SET_SENSITIVE ("/View as List", list_view_available);
SET_SENSITIVE ("/View as Tree", tree_view_available);
}
if (GIMP_IS_IMAGE_DOCK (dockbook->dock))

8
app/gui/dialogs.c
View File

@ -69,6 +69,14 @@ static const GimpDialogFactoryEntry dock_entries[] =
{ "gimp-tool-grid", dialogs_tool_grid_view_new, 24, FALSE, FALSE, FALSE, TRUE },
{ "gimp-buffer-grid", dialogs_buffer_grid_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-image-tree", dialogs_image_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-brush-tree", dialogs_brush_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-pattern-tree", dialogs_pattern_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-gradient-tree", dialogs_gradient_tree_view_new, 16, FALSE, FALSE, FALSE, TRUE },
{ "gimp-palette-tree", dialogs_palette_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-tool-tree", dialogs_tool_tree_view_new, 24, FALSE, FALSE, FALSE, TRUE },
{ "gimp-buffer-tree", dialogs_buffer_tree_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-layer-list", dialogs_layer_list_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-channel-list", dialogs_channel_list_view_new, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp-vectors-list", dialogs_vectors_list_view_new, 32, FALSE, FALSE, FALSE, TRUE },

2
app/widgets/Makefile.am
View File

@ -51,6 +51,8 @@ libappwidgets_a_sources = \
gimpcontainermenu.h \
gimpcontainermenuimpl.c \
gimpcontainermenuimpl.h \
gimpcontainertreeview.c \
gimpcontainertreeview.h \
gimpcontainerview.c \
gimpcontainerview.h \
gimpcontainerview-utils.c \

72
app/widgets/gimpbufferpreview.c
View File

@ -35,10 +35,6 @@
static void gimp_buffer_preview_class_init (GimpBufferPreviewClass *klass);
static void gimp_buffer_preview_init (GimpBufferPreview *preview);
static void gimp_buffer_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static void gimp_buffer_preview_render (GimpPreview *preview);
static GtkWidget * gimp_buffer_preview_create_popup (GimpPreview *preview);
static gboolean gimp_buffer_preview_needs_popup (GimpPreview *preview);
@ -84,7 +80,6 @@ gimp_buffer_preview_class_init (GimpBufferPreviewClass *klass)
parent_class = g_type_class_peek_parent (klass);
preview_class->get_size = gimp_buffer_preview_get_size;
preview_class->render = gimp_buffer_preview_render;
preview_class->create_popup = gimp_buffer_preview_create_popup;
preview_class->needs_popup = gimp_buffer_preview_needs_popup;
@ -95,29 +90,6 @@ gimp_buffer_preview_init (GimpBufferPreview *buffer_preview)
{
}
static void
gimp_buffer_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
GimpBuffer *buffer;
gboolean scaling_up;
buffer = GIMP_BUFFER (preview->viewable);
gimp_preview_calc_size (preview,
gimp_buffer_get_width (buffer),
gimp_buffer_get_height (buffer),
size,
size,
1.0,
1.0,
width,
height,
&scaling_up);
}
static void
gimp_buffer_preview_render (GimpPreview *preview)
{
@ -139,16 +111,17 @@ gimp_buffer_preview_render (GimpPreview *preview)
width = preview->width;
height = preview->height;
gimp_preview_calc_size (preview,
buffer_width,
buffer_height,
width,
height,
1.0,
1.0,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
buffer_width,
buffer_height,
width,
height,
preview->dot_for_dot,
1.0,
1.0,
&preview_width,
&preview_height,
&scaling_up);
if (scaling_up)
{
@ -224,16 +197,19 @@ gimp_buffer_preview_create_popup (GimpPreview *preview)
buffer_width = gimp_buffer_get_width (buffer);
buffer_height = gimp_buffer_get_height (buffer);
gimp_preview_calc_size (preview,
buffer_width,
buffer_height,
MIN (preview->width * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
1.0,
1.0,
&popup_width,
&popup_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
buffer_width,
buffer_height,
MIN (preview->width * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
preview->dot_for_dot,
1.0,
1.0,
&popup_width,
&popup_height,
&scaling_up);
if (scaling_up)
{

8
app/widgets/gimpcomponentlistitem.c
View File

@ -63,7 +63,7 @@ static void gimp_component_list_item_active_changed
GimpChannelType channel,
gpointer data);
static gchar * gimp_component_list_item_get_name (GtkWidget *widget,
static gchar * gimp_component_list_item_get_name (GObject *object,
gchar **tooltip);
@ -466,12 +466,12 @@ gimp_component_list_item_active_changed (GimpImage *gimage,
}
static gchar *
gimp_component_list_item_get_name (GtkWidget *widget,
gchar **tooltip)
gimp_component_list_item_get_name (GObject *object,
gchar **tooltip)
{
GimpComponentListItem *component_item;
component_item = GIMP_COMPONENT_LIST_ITEM (widget);
component_item = GIMP_COMPONENT_LIST_ITEM (object);
if (tooltip)
*tooltip = NULL;

10
app/widgets/gimpcontainereditor.c
View File

@ -33,6 +33,7 @@
#include "gimpcontainereditor.h"
#include "gimpcontainergridview.h"
#include "gimpcontainerlistview.h"
#include "gimpcontainertreeview.h"
#include "gimpdnd.h"
#include "gimpitemfactory.h"
#include "gimpmenufactory.h"
@ -181,6 +182,15 @@ gimp_container_editor_construct (GimpContainerEditor *editor,
min_items_y));
break;
case GIMP_VIEW_TYPE_TREE:
editor->view =
GIMP_CONTAINER_VIEW (gimp_container_tree_view_new (container,
context,
preview_size,
reorderable,
min_items_x,
min_items_y));
break;
default:
g_warning ("%s(): unknown GimpViewType passed", G_GNUC_FUNCTION);
return FALSE;

2
app/widgets/gimpcontainergridview.c
View File

@ -420,7 +420,7 @@ gimp_container_grid_view_highlight_item (GimpContainerView *view,
{
gchar *name;
name = view->get_name_func (GTK_WIDGET (preview), NULL);
name = view->get_name_func (G_OBJECT (preview), NULL);
gtk_label_set_text (GTK_LABEL (grid_view->name_label), name);

648
app/widgets/gimpcontainertreeview.c Normal file
View File

@ -0,0 +1,648 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpcontainertreeview.c
* Copyright (C) 2003 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 <stdio.h>
#include <gtk/gtk.h>
#include "widgets-types.h"
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimpviewable.h"
#include "gimpcellrendererviewable.h"
#include "gimpcontainertreeview.h"
#include "gimpdnd.h"
#include "gimppreview.h"
enum
{
COLUMN_VIEWABLE,
COLUMN_PIXBUF,
COLUMN_NAME,
NUM_COLUMNS
};
static void gimp_container_tree_view_class_init (GimpContainerTreeViewClass *klass);
static void gimp_container_tree_view_init (GimpContainerTreeView *view);
static void gimp_container_tree_view_set_container (GimpContainerView *view,
GimpContainer *container);
static gpointer gimp_container_tree_view_insert_item (GimpContainerView *view,
GimpViewable *viewable,
gint index);
static void gimp_container_tree_view_remove_item (GimpContainerView *view,
GimpViewable *viewable,
gpointer insert_data);
static void gimp_container_tree_view_reorder_item (GimpContainerView *view,
GimpViewable *viewable,
gint new_index,
gpointer insert_data);
static void gimp_container_tree_view_select_item (GimpContainerView *view,
GimpViewable *viewable,
gpointer insert_data);
static void gimp_container_tree_view_clear_items (GimpContainerView *view);
static void gimp_container_tree_view_set_preview_size (GimpContainerView *view);
static void gimp_container_tree_view_selection_changed (GtkTreeSelection *sel,
GimpContainerTreeView *tree_view);
static gboolean gimp_container_tree_view_button_press (GtkWidget *widget,
GdkEventButton *bevent,
GimpContainerTreeView *tree_view);
static void gimp_container_tree_view_invalidate_preview (GimpViewable *viewable,
GimpContainerTreeView *tree_view);
static void gimp_container_tree_view_name_changed (GimpObject *object,
GimpContainerTreeView *tree_view);
static GimpContainerViewClass *parent_class = NULL;
GType
gimp_container_tree_view_get_type (void)
{
static GType view_type = 0;
if (! view_type)
{
static const GTypeInfo view_info =
{
sizeof (GimpContainerTreeViewClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_container_tree_view_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpContainerTreeView),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_container_tree_view_init,
};
view_type = g_type_register_static (GIMP_TYPE_CONTAINER_VIEW,
"GimpContainerTreeView",
&view_info, 0);
}
return view_type;
}
static void
gimp_container_tree_view_class_init (GimpContainerTreeViewClass *klass)
{
GimpContainerViewClass *container_view_class;
container_view_class = GIMP_CONTAINER_VIEW_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
container_view_class->set_container = gimp_container_tree_view_set_container;
container_view_class->insert_item = gimp_container_tree_view_insert_item;
container_view_class->remove_item = gimp_container_tree_view_remove_item;
container_view_class->reorder_item = gimp_container_tree_view_reorder_item;
container_view_class->select_item = gimp_container_tree_view_select_item;
container_view_class->clear_items = gimp_container_tree_view_clear_items;
container_view_class->set_preview_size = gimp_container_tree_view_set_preview_size;
}
static void
gimp_container_tree_view_init (GimpContainerTreeView *tree_view)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
tree_view->scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (tree_view->scrolled_win),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tree_view->scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (tree_view), tree_view->scrolled_win,
TRUE, TRUE, 0);
gtk_widget_show (tree_view->scrolled_win);
GIMP_CONTAINER_VIEW (tree_view)->dnd_widget = tree_view->scrolled_win;
tree_view->list = gtk_list_store_new (NUM_COLUMNS,
GIMP_TYPE_VIEWABLE,
GDK_TYPE_PIXBUF,
G_TYPE_STRING);
tree_view->view = GTK_TREE_VIEW
(gtk_tree_view_new_with_model (GTK_TREE_MODEL (tree_view->list)));
g_object_unref (G_OBJECT (tree_view->list));
gtk_tree_view_set_headers_visible (tree_view->view, FALSE);
column = gtk_tree_view_column_new ();
gtk_tree_view_append_column (tree_view->view, column);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"pixbuf", COLUMN_PIXBUF,
NULL);
gtk_tree_view_insert_column_with_attributes (tree_view->view,
1, NULL,
gtk_cell_renderer_text_new (),
"text", COLUMN_NAME,
NULL);
gtk_container_add (GTK_CONTAINER (tree_view->scrolled_win),
GTK_WIDGET (tree_view->view));
gtk_widget_show (GTK_WIDGET (tree_view->view));
GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW
(tree_view->scrolled_win)->vscrollbar,
GTK_CAN_FOCUS);
tree_view->selection = gtk_tree_view_get_selection (tree_view->view);
g_signal_connect (tree_view->selection, "changed",
G_CALLBACK (gimp_container_tree_view_selection_changed),
tree_view);
g_signal_connect (tree_view->view, "button_press_event",
G_CALLBACK (gimp_container_tree_view_button_press),
tree_view);
}
GtkWidget *
gimp_container_tree_view_new (GimpContainer *container,
GimpContext *context,
gint preview_size,
gboolean reorderable,
gint min_items_x,
gint min_items_y)
{
GimpContainerTreeView *tree_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);
tree_view = g_object_new (GIMP_TYPE_CONTAINER_TREE_VIEW, NULL);
view = GIMP_CONTAINER_VIEW (tree_view);
view->preview_size = preview_size;
view->reorderable = reorderable ? TRUE : FALSE;
window_border =
GTK_SCROLLED_WINDOW (tree_view->scrolled_win)->vscrollbar->requisition.width +
GTK_SCROLLED_WINDOW_GET_CLASS (tree_view->scrolled_win)->scrollbar_spacing +
tree_view->scrolled_win->style->xthickness * 4;
gtk_widget_set_size_request (GTK_WIDGET (tree_view),
(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);
if (context)
gimp_container_view_set_context (view, context);
return GTK_WIDGET (tree_view);
}
static void
gimp_container_tree_view_set (GimpContainerTreeView *tree_view,
GtkTreeIter *iter,
GimpViewable *viewable)
{
GimpContainerView *view;
GdkPixbuf *pixbuf;
gchar *name;
gint width;
gint height;
view = GIMP_CONTAINER_VIEW (tree_view);
gimp_viewable_get_preview_size (viewable, view->preview_size, FALSE, TRUE,
&width, &height);
pixbuf = gimp_viewable_get_new_preview_pixbuf (viewable, width, height);
if (view->get_name_func)
name = view->get_name_func (G_OBJECT (viewable), NULL);
else
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (viewable)));
gtk_list_store_set (tree_view->list, iter,
COLUMN_VIEWABLE, viewable,
COLUMN_PIXBUF, pixbuf,
COLUMN_NAME, name,
-1);
g_object_unref (pixbuf);
g_free (name);
}
/* GimpContainerView methods */
static void
gimp_container_tree_view_set_container (GimpContainerView *view,
GimpContainer *container)
{
GimpContainerTreeView *tree_view;
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
if (view->container)
{
gimp_container_remove_handler (view->container,
tree_view->invalidate_preview_handler_id);
gimp_container_remove_handler (view->container,
tree_view->name_changed_handler_id);
}
GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container (view, container);
if (view->container)
{
tree_view->invalidate_preview_handler_id =
gimp_container_add_handler (view->container, "invalidate_preview",
G_CALLBACK (gimp_container_tree_view_invalidate_preview),
tree_view);
tree_view->name_changed_handler_id =
gimp_container_add_handler (view->container, "name_changed",
G_CALLBACK (gimp_container_tree_view_name_changed),
tree_view);
}
}
static gpointer
gimp_container_tree_view_insert_item (GimpContainerView *view,
GimpViewable *viewable,
gint index)
{
GimpContainerTreeView *tree_view;
GtkTreeIter *iter;
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
iter = g_new0 (GtkTreeIter, 1);
if (index == -1)
gtk_list_store_append (tree_view->list, iter);
else
gtk_list_store_insert (tree_view->list, iter, index);
gimp_container_tree_view_set (tree_view, iter, viewable);
return (gpointer) iter;
}
static void
gimp_container_tree_view_remove_item (GimpContainerView *view,
GimpViewable *viewable,
gpointer insert_data)
{
GimpContainerTreeView *tree_view;
GtkTreeIter *iter;
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
if (insert_data)
iter = (GtkTreeIter *) insert_data;
else
iter = NULL;
if (iter)
{
gtk_list_store_remove (tree_view->list, iter);
g_free (iter);
}
}
static void
gimp_container_tree_view_reorder_item (GimpContainerView *view,
GimpViewable *viewable,
gint new_index,
gpointer insert_data)
{
GimpContainerTreeView *tree_view;
GtkTreeIter *iter;
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
if (insert_data)
iter = (GtkTreeIter *) insert_data;
else
iter = NULL;
if (iter)
{
GtkTreeIter selected_iter;
gboolean selected;
selected = gtk_tree_selection_get_selected (tree_view->selection,
NULL, &selected_iter);
if (selected)
{
GimpViewable *selected_viewable;
gtk_tree_model_get (GTK_TREE_MODEL (tree_view->list),
&selected_iter,
COLUMN_VIEWABLE, &selected_viewable,
NULL);
if (selected_viewable != viewable)
selected = FALSE;
g_object_unref (selected_viewable);
}
gtk_list_store_remove (tree_view->list, iter);
if (new_index == -1)
gtk_list_store_append (tree_view->list, iter);
else
gtk_list_store_insert (tree_view->list, iter, new_index);
gimp_container_tree_view_set (tree_view, iter, viewable);
if (selected)
gimp_container_view_select_item (view, viewable);
}
}
static void
gimp_container_tree_view_select_item (GimpContainerView *view,
GimpViewable *viewable,
gpointer insert_data)
{
GimpContainerTreeView *tree_view;
GtkTreeIter *iter;
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
if (insert_data)
iter = (GtkTreeIter *) insert_data;
else
iter = NULL;
if (iter)
{
GtkTreePath *path;
GtkTreeIter selected_iter;
if (gtk_tree_selection_get_selected (tree_view->selection, NULL,
&selected_iter))
{
GimpViewable *selected_viewable;
gboolean equal;
gtk_tree_model_get (GTK_TREE_MODEL (tree_view->list), &selected_iter,
COLUMN_VIEWABLE, &selected_viewable,
-1);
equal = (selected_viewable == viewable);
g_object_unref (selected_viewable);
if (equal)
return;
}
g_signal_handlers_block_by_func (tree_view->selection,
gimp_container_tree_view_selection_changed,
tree_view);
gtk_tree_selection_select_iter (tree_view->selection, iter);
g_signal_handlers_unblock_by_func (tree_view->selection,
gimp_container_tree_view_selection_changed,
tree_view);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (tree_view->list), iter);
#ifdef __GNUC__
#warning FIXME: use use_align == FALSE as soon as implemented by GtkTreeView
#endif
gtk_tree_view_scroll_to_cell (tree_view->view, path,
NULL, TRUE, 0.5, 0.0);
gtk_tree_path_free (path);
}
else
{
gtk_tree_selection_unselect_all (tree_view->selection);
}
}
static void
gimp_container_tree_view_clear_items (GimpContainerView *view)
{
GimpContainerTreeView *tree_view;
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
gtk_list_store_clear (tree_view->list);
if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->clear_items)
GIMP_CONTAINER_VIEW_CLASS (parent_class)->clear_items (view);
}
static void
gimp_container_tree_view_set_preview_size (GimpContainerView *view)
{
GimpContainerTreeView *tree_view;
GtkTreeModel *tree_model;
GtkTreeIter iter;
tree_view = GIMP_CONTAINER_TREE_VIEW (view);
tree_model = GTK_TREE_MODEL (tree_view->list);
if (gtk_tree_model_get_iter_first (tree_model, &iter))
{
do
{
GimpViewable *viewable;
GdkPixbuf *pixbuf;
gint width;
gint height;
gtk_tree_model_get (tree_model, &iter,
COLUMN_VIEWABLE, &viewable,
-1);
gimp_viewable_get_preview_size (viewable, view->preview_size,
FALSE, TRUE,
&width, &height);
pixbuf = gimp_viewable_get_new_preview_pixbuf (viewable,
width, height);
gtk_list_store_set (tree_view->list, &iter,
COLUMN_PIXBUF, pixbuf,
-1);
g_object_unref (viewable);
g_object_unref (pixbuf);
}
while (gtk_tree_model_iter_next (tree_model, &iter));
}
}
/* callbacks */
static void
gimp_container_tree_view_selection_changed (GtkTreeSelection *selection,
GimpContainerTreeView *tree_view)
{
GimpViewable *selected_viewable = NULL;
GtkTreeIter selected_iter;
gboolean selected;
selected = gtk_tree_selection_get_selected (selection, NULL, &selected_iter);
if (selected)
gtk_tree_model_get (GTK_TREE_MODEL (tree_view->list), &selected_iter,
COLUMN_VIEWABLE, &selected_viewable,
-1);
if (selected_viewable)
{
gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (tree_view),
selected_viewable);
g_object_unref (selected_viewable);
}
}
static gboolean
gimp_container_tree_view_button_press (GtkWidget *widget,
GdkEventButton *bevent,
GimpContainerTreeView *tree_view)
{
if ((bevent->button == 1 && bevent->type == GDK_2BUTTON_PRESS) ||
bevent->button == 3)
{
GtkTreePath *path;
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
bevent->x,
bevent->y,
&path, NULL, NULL, NULL))
{
GimpViewable *viewable;
GtkTreeIter iter;
gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->list),
&iter, path);
gtk_tree_path_free (path);
gtk_tree_model_get (GTK_TREE_MODEL (tree_view->list), &iter,
COLUMN_VIEWABLE, &viewable,
-1);
if (bevent->button == 1 && bevent->type == GDK_2BUTTON_PRESS)
{
gimp_container_view_item_activated (GIMP_CONTAINER_VIEW (tree_view),
viewable);
}
else if (bevent->button == 3)
{
gimp_container_view_item_context (GIMP_CONTAINER_VIEW (tree_view),
viewable);
}
g_object_unref (viewable);
}
}
return FALSE;
}
static void
gimp_container_tree_view_invalidate_preview (GimpViewable *viewable,
GimpContainerTreeView *tree_view)
{
GimpContainerView *view;
GtkTreeIter *iter;
view = GIMP_CONTAINER_VIEW (tree_view);
iter = g_hash_table_lookup (view->hash_table, viewable);
if (iter)
{
GdkPixbuf *pixbuf;
gint width;
gint height;
gimp_viewable_get_preview_size (viewable, view->preview_size,
FALSE, TRUE,
&width, &height);
pixbuf = gimp_viewable_get_new_preview_pixbuf (viewable, width, height);
gtk_list_store_set (tree_view->list, iter,
COLUMN_PIXBUF, pixbuf,
-1);
g_object_unref (pixbuf);
}
}
static void
gimp_container_tree_view_name_changed (GimpObject *object,
GimpContainerTreeView *tree_view)
{
GimpContainerView *view;
GtkTreeIter *iter;
view = GIMP_CONTAINER_VIEW (tree_view);
iter = g_hash_table_lookup (view->hash_table, object);
if (iter)
{
gchar *name;
if (view->get_name_func)
name = view->get_name_func (G_OBJECT (object), NULL);
else
name = g_strdup (gimp_object_get_name (object));
gtk_list_store_set (tree_view->list, iter,
COLUMN_NAME, name,
-1);
g_free (name);
}
}

69
app/widgets/gimpcontainertreeview.h Normal file
View File

@ -0,0 +1,69 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpcontainertreeview.h
* Copyright (C) 2003 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_CONTAINER_TREE_VIEW_H__
#define __GIMP_CONTAINER_TREE_VIEW_H__
#include "gimpcontainerview.h"
#define GIMP_TYPE_CONTAINER_TREE_VIEW (gimp_container_tree_view_get_type ())
#define GIMP_CONTAINER_TREE_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CONTAINER_TREE_VIEW, GimpContainerTreeView))
#define GIMP_CONTAINER_TREE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CONTAINER_TREE_VIEW, GimpContainerTreeViewClass))
#define GIMP_IS_CONTAINER_TREE_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CONTAINER_TREE_VIEW))
#define GIMP_IS_CONTAINER_TREE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONTAINER_TREE_VIEW))
#define GIMP_CONTAINER_TREE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CONTAINER_TREE_VIEW, GimpContainerTreeViewClass))
typedef struct _GimpContainerTreeViewClass GimpContainerTreeViewClass;
struct _GimpContainerTreeView
{
GimpContainerView parent_instance;
GtkListStore *list;
GtkWidget *scrolled_win;
GtkTreeView *view;
GtkTreeSelection *selection;
GQuark invalidate_preview_handler_id;
GQuark name_changed_handler_id;
};
struct _GimpContainerTreeViewClass
{
GimpContainerViewClass parent_class;
};
GType gimp_container_tree_view_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_container_tree_view_new (GimpContainer *container,
GimpContext *context,
gint preview_size,
gboolean reorderable,
gint min_items_x,
gint min_items_y);
#endif /* __GIMP_CONTAINER_TREE_VIEW_H__ */

291
app/widgets/gimpcontainerview-utils.c
View File

@ -52,19 +52,19 @@ struct _GimpNameFuncEntry
};
static gchar * gimp_container_view_tool_name_func (GtkWidget *widget,
static gchar * gimp_container_view_tool_name_func (GObject *object,
gchar **tooltip);
static gchar * gimp_container_view_image_name_func (GtkWidget *widget,
static gchar * gimp_container_view_image_name_func (GObject *object,
gchar **tooltip);
static gchar * gimp_container_view_brush_name_func (GtkWidget *widget,
static gchar * gimp_container_view_brush_name_func (GObject *object,
gchar **tooltip);
static gchar * gimp_container_view_pattern_name_func (GtkWidget *widget,
static gchar * gimp_container_view_pattern_name_func (GObject *object,
gchar **tooltip);
static gchar * gimp_container_view_palette_name_func (GtkWidget *widget,
static gchar * gimp_container_view_palette_name_func (GObject *object,
gchar **tooltip);
static gchar * gimp_container_view_buffer_name_func (GtkWidget *widget,
static gchar * gimp_container_view_buffer_name_func (GObject *object,
gchar **tooltip);
static gchar * gimp_container_view_imagefile_name_func (GtkWidget *widget,
static gchar * gimp_container_view_imagefile_name_func (GObject *object,
gchar **tooltip);
@ -107,7 +107,7 @@ gimp_container_view_get_by_dockable (GimpDockable *dockable)
}
GimpItemGetNameFunc
gimp_container_view_get_built_in_name_func (GType type)
gimp_container_view_get_built_in_name_func (GType type)
{
gint i;
@ -148,270 +148,251 @@ gimp_container_view_is_built_in_name_func (GimpItemGetNameFunc get_name_func)
/* private functions */
static GimpPreview *
gimp_container_view_get_name_func_preview (GtkWidget *widget)
static GimpViewable *
gimp_container_view_get_name_func_viewable (GObject *object)
{
if (GIMP_IS_PREVIEW (widget))
if (GIMP_IS_VIEWABLE (object))
{
return GIMP_PREVIEW (widget);
return GIMP_VIEWABLE (object);
}
else if (GIMP_IS_LIST_ITEM (widget))
if (GIMP_IS_PREVIEW (object))
{
return GIMP_PREVIEW (GIMP_LIST_ITEM (widget)->preview);
return GIMP_PREVIEW (object)->viewable;
}
else if (GIMP_IS_MENU_ITEM (widget))
else if (GIMP_IS_LIST_ITEM (object))
{
return GIMP_PREVIEW (GIMP_MENU_ITEM (widget)->preview);
return GIMP_PREVIEW (GIMP_LIST_ITEM (object)->preview)->viewable;
}
else if (GIMP_IS_MENU_ITEM (object))
{
return GIMP_PREVIEW (GIMP_MENU_ITEM (object)->preview)->viewable;
}
g_warning ("%s: widget type %s does not contain a GimpPreview",
G_STRLOC, g_type_name (G_TYPE_FROM_INSTANCE (widget)));
g_warning ("%s: can't figure GimpViewable from type %s",
G_STRLOC, g_type_name (G_TYPE_FROM_INSTANCE (object)));
return NULL;
}
static gchar *
gimp_container_view_tool_name_func (GtkWidget *widget,
gchar **tooltip)
gimp_container_view_tool_name_func (GObject *object,
gchar **tooltip)
{
GimpPreview *preview;
GimpViewable *viewable;
preview = gimp_container_view_get_name_func_preview (widget);
viewable = gimp_container_view_get_name_func_viewable (object);
if (preview)
if (viewable)
{
GimpToolInfo *tool_info;
tool_info = GIMP_TOOL_INFO (preview->viewable);
tool_info = GIMP_TOOL_INFO (viewable);
if (tool_info)
{
if (tooltip)
*tooltip = NULL;
if (tooltip)
*tooltip = NULL;
return g_strdup (tool_info->blurb);
}
return g_strdup (tool_info->blurb);
}
return g_strdup ("EEK");
}
static gchar *
gimp_container_view_image_name_func (GtkWidget *widget,
gchar **tooltip)
gimp_container_view_image_name_func (GObject *object,
gchar **tooltip)
{
GimpPreview *preview;
GimpViewable *viewable;
preview = gimp_container_view_get_name_func_preview (widget);
viewable = gimp_container_view_get_name_func_viewable (object);
if (preview)
if (viewable)
{
GimpImage *gimage;
GimpImage *gimage;
const gchar *uri;
gchar *basename;
gchar *retval;
gimage = GIMP_IMAGE (preview->viewable);
gimage = GIMP_IMAGE (viewable);
if (gimage)
{
const gchar *uri;
gchar *basename;
gchar *retval;
uri = gimp_image_get_uri (GIMP_IMAGE (gimage));
uri = gimp_image_get_uri (GIMP_IMAGE (gimage));
basename = file_utils_uri_to_utf8_basename (uri);
basename = file_utils_uri_to_utf8_basename (uri);
if (tooltip)
{
gchar *filename;
if (tooltip)
{
gchar *filename;
filename = file_utils_uri_to_utf8_filename (uri);
filename = file_utils_uri_to_utf8_filename (uri);
*tooltip = filename;
}
*tooltip = filename;
}
retval = g_strdup_printf ("%s-%d",
basename,
gimp_image_get_ID (gimage));
retval = g_strdup_printf ("%s-%d",
basename,
gimp_image_get_ID (gimage));
g_free (basename);
g_free (basename);
return retval;
}
return retval;
}
return g_strdup ("EEK");
}
static gchar *
gimp_container_view_brush_name_func (GtkWidget *widget,
gchar **tooltip)
gimp_container_view_brush_name_func (GObject *object,
gchar **tooltip)
{
GimpPreview *preview;
GimpViewable *viewable;
preview = gimp_container_view_get_name_func_preview (widget);
viewable = gimp_container_view_get_name_func_viewable (object);
if (preview)
if (viewable)
{
GimpBrush *brush;
brush = GIMP_BRUSH (preview->viewable);
brush = GIMP_BRUSH (viewable);
if (brush)
{
if (tooltip)
*tooltip = NULL;
if (tooltip)
*tooltip = NULL;
return g_strdup_printf ("%s (%d x %d)",
GIMP_OBJECT (brush)->name,
brush->mask->width,
brush->mask->height);
}
return g_strdup_printf ("%s (%d x %d)",
GIMP_OBJECT (brush)->name,
brush->mask->width,
brush->mask->height);
}
return g_strdup ("EEK");
}
static gchar *
gimp_container_view_pattern_name_func (GtkWidget *widget,
gchar **tooltip)
gimp_container_view_pattern_name_func (GObject *object,
gchar **tooltip)
{
GimpPreview *preview;
GimpViewable *viewable;
preview = gimp_container_view_get_name_func_preview (widget);
viewable = gimp_container_view_get_name_func_viewable (object);
if (preview)
if (viewable)
{
GimpPattern *pattern;
pattern = GIMP_PATTERN (preview->viewable);
pattern = GIMP_PATTERN (viewable);
if (pattern)
{
if (tooltip)
*tooltip = NULL;
if (tooltip)
*tooltip = NULL;
return g_strdup_printf ("%s (%d x %d)",
GIMP_OBJECT (pattern)->name,
pattern->mask->width,
pattern->mask->height);
}
return g_strdup_printf ("%s (%d x %d)",
GIMP_OBJECT (pattern)->name,
pattern->mask->width,
pattern->mask->height);
}
return g_strdup ("EEK");
}
static gchar *
gimp_container_view_palette_name_func (GtkWidget *widget,
gchar **tooltip)
gimp_container_view_palette_name_func (GObject *object,
gchar **tooltip)
{
GimpPreview *preview;
GimpViewable *viewable;
preview = gimp_container_view_get_name_func_preview (widget);
viewable = gimp_container_view_get_name_func_viewable (object);
if (preview)
if (viewable)
{
GimpPalette *palette;
palette = GIMP_PALETTE (preview->viewable);
palette = GIMP_PALETTE (viewable);
if (palette)
{
if (tooltip)
*tooltip = NULL;
if (tooltip)
*tooltip = NULL;
return g_strdup_printf ("%s (%d)",
GIMP_OBJECT (palette)->name,
palette->n_colors);
}
return g_strdup_printf ("%s (%d)",
GIMP_OBJECT (palette)->name,
palette->n_colors);
}
return g_strdup ("EEK");
}
static gchar *
gimp_container_view_buffer_name_func (GtkWidget *widget,
gchar **tooltip)
gimp_container_view_buffer_name_func (GObject *object,
gchar **tooltip)
{
GimpPreview *preview;
GimpViewable *viewable;
preview = gimp_container_view_get_name_func_preview (widget);
viewable = gimp_container_view_get_name_func_viewable (object);
if (preview)
if (viewable)
{
GimpBuffer *buffer;
buffer = GIMP_BUFFER (preview->viewable);
buffer = GIMP_BUFFER (viewable);
if (buffer)
{
if (tooltip)
*tooltip = NULL;
if (tooltip)
*tooltip = NULL;
return g_strdup_printf ("%s (%d x %d)",
GIMP_OBJECT (buffer)->name,
gimp_buffer_get_width (buffer),
gimp_buffer_get_height (buffer));
}
return g_strdup_printf ("%s (%d x %d)",
GIMP_OBJECT (buffer)->name,
gimp_buffer_get_width (buffer),
gimp_buffer_get_height (buffer));
}
return g_strdup ("EEK");
}
static gchar *
gimp_container_view_imagefile_name_func (GtkWidget *widget,
gchar **tooltip)
gimp_container_view_imagefile_name_func (GObject *object,
gchar **tooltip)
{
GimpPreview *preview;
GimpViewable *viewable;
preview = gimp_container_view_get_name_func_preview (widget);
viewable = gimp_container_view_get_name_func_viewable (object);
if (preview)
if (viewable)
{
GimpImagefile *imagefile;
const gchar *uri;
gchar *basename;
imagefile = GIMP_IMAGEFILE (preview->viewable);
imagefile = GIMP_IMAGEFILE (viewable);
if (imagefile)
{
const gchar *uri;
gchar *basename;
uri = gimp_object_get_name (GIMP_OBJECT (imagefile));
uri = gimp_object_get_name (GIMP_OBJECT (imagefile));
basename = file_utils_uri_to_utf8_basename (uri);
basename = file_utils_uri_to_utf8_basename (uri);
if (tooltip)
{
gchar *filename;
const gchar *desc;
if (tooltip)
filename = file_utils_uri_to_utf8_filename (uri);
desc = gimp_imagefile_get_description (imagefile);
if (desc)
{
gchar *filename;
const gchar *desc;
filename = file_utils_uri_to_utf8_filename (uri);
desc = gimp_imagefile_get_description (imagefile);
if (desc)
{
*tooltip = g_strdup_printf ("%s\n%s", filename, desc);
g_free (filename);
}
else
{
*tooltip = filename;
}
*tooltip = g_strdup_printf ("%s\n%s", filename, desc);
g_free (filename);
}
else
{
*tooltip = filename;
}
}
if (imagefile->width > 0 && imagefile->height > 0)
{
gchar *tmp = basename;
if (imagefile->width > 0 && imagefile->height > 0)
{
gchar *tmp = basename;
basename = g_strdup_printf ("%s (%d x %d)",
tmp,
imagefile->width,
imagefile->height);
g_free (tmp);
}
basename = g_strdup_printf ("%s (%d x %d)",
tmp,
imagefile->width,
imagefile->height);
g_free (tmp);
}
return basename;
}
return basename;
}
return g_strdup ("EEK");

111
app/widgets/gimpdrawablepreview.c
View File

@ -39,10 +39,6 @@ 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);
@ -87,7 +83,6 @@ gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass)
parent_class = g_type_class_peek_parent (klass);
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;
}
@ -96,47 +91,6 @@ 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 = gimp_item_get_image (GIMP_ITEM (drawable));
if (gimage && ! preview->is_popup)
{
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
size,
size,
gimage->xresolution,
gimage->yresolution,
width,
height,
&scaling_up);
}
else
{
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
size,
size,
1.0,
1.0,
width,
height,
&scaling_up);
}
}
static void
gimp_drawable_preview_render (GimpPreview *preview)
{
@ -162,29 +116,31 @@ gimp_drawable_preview_render (GimpPreview *preview)
height = MAX (1, ROUND ((((gdouble) height / (gdouble) gimage->height) *
(gdouble) drawable->height)));
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
width,
height,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
drawable->width,
drawable->height,
width,
height,
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
}
else
{
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
width,
height,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
drawable->width,
drawable->height,
width,
height,
preview->dot_for_dot,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&preview_width,
&preview_height,
&scaling_up);
}
if (scaling_up)
@ -273,16 +229,19 @@ gimp_drawable_preview_create_popup (GimpPreview *preview)
drawable = GIMP_DRAWABLE (preview->viewable);
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
MIN (preview->width * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&popup_width,
&popup_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
drawable->width,
drawable->height,
MIN (preview->width * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
preview->dot_for_dot,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&popup_width,
&popup_height,
&scaling_up);
if (scaling_up)
{

15
app/widgets/gimpgradientpreview.c
View File

@ -36,10 +36,6 @@ 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);
@ -84,7 +80,6 @@ gimp_gradient_preview_class_init (GimpGradientPreviewClass *klass)
parent_class = g_type_class_peek_parent (klass);
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;
@ -95,16 +90,6 @@ gimp_gradient_preview_init (GimpGradientPreview *gradient_preview)
{
}
static void
gimp_gradient_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
*width = size;
*height = size / 2;
}
static void
gimp_gradient_preview_render (GimpPreview *preview)
{

72
app/widgets/gimpimagepreview.c
View File

@ -36,10 +36,6 @@ 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 void gimp_image_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static GtkWidget * gimp_image_preview_create_popup (GimpPreview *preview);
@ -84,7 +80,6 @@ gimp_image_preview_class_init (GimpImagePreviewClass *klass)
parent_class = g_type_class_peek_parent (klass);
preview_class->render = gimp_image_preview_render;
preview_class->get_size = gimp_image_preview_get_size;
preview_class->create_popup = gimp_image_preview_create_popup;
}
@ -94,29 +89,6 @@ gimp_image_preview_init (GimpImagePreview *preview)
preview->channel = -1;
}
static void
gimp_image_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
GimpImage *gimage;
gboolean scaling_up;
gimage = GIMP_IMAGE (preview->viewable);
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
size,
size,
gimage->xresolution,
gimage->yresolution,
width,
height,
&scaling_up);
}
static void
gimp_image_preview_render (GimpPreview *preview)
{
@ -133,16 +105,17 @@ gimp_image_preview_render (GimpPreview *preview)
width = preview->width;
height = preview->height;
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
width,
height,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
gimage->width,
gimage->height,
width,
height,
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
if (scaling_up)
{
@ -215,16 +188,19 @@ gimp_image_preview_create_popup (GimpPreview *preview)
gimage = GIMP_IMAGE (preview->viewable);
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
MIN (preview->width * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
gimage->xresolution,
gimage->yresolution,
&popup_width,
&popup_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
gimage->width,
gimage->height,
MIN (preview->width * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&popup_width,
&popup_height,
&scaling_up);
if (scaling_up)
{

2
app/widgets/gimplistitem.c
View File

@ -601,7 +601,7 @@ gimp_list_item_name_changed (GimpViewable *viewable,
gchar *name = NULL;
gchar *tooltip = NULL;
name = list_item->get_name_func (GTK_WIDGET (list_item), &tooltip);
name = list_item->get_name_func (G_OBJECT (list_item), &tooltip);
gtk_label_set_text (GTK_LABEL (list_item->name_label), name);
gimp_help_set_help_data (GTK_WIDGET (list_item), tooltip, NULL);

2
app/widgets/gimpmenuitem.c
View File

@ -190,7 +190,7 @@ gimp_menu_item_name_changed (GimpViewable *viewable,
gchar *name = NULL;
gchar *tooltip = NULL;
name = menu_item->get_name_func (GTK_WIDGET (menu_item), &tooltip);
name = menu_item->get_name_func (G_OBJECT (menu_item), &tooltip);
gtk_label_set_text (GTK_LABEL (menu_item->name_label), name);
gimp_help_set_help_data (GTK_WIDGET (menu_item), tooltip, NULL);

15
app/widgets/gimppalettepreview.c
View File

@ -35,10 +35,6 @@
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);
@ -84,7 +80,6 @@ gimp_palette_preview_class_init (GimpPalettePreviewClass *klass)
parent_class = g_type_class_peek_parent (klass);
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;
@ -95,16 +90,6 @@ gimp_palette_preview_init (GimpPalettePreview *palette_preview)
{
}
static void
gimp_palette_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
*width = size;
*height = size / 2;
}
static void
gimp_palette_preview_render (GimpPreview *preview)
{

91
app/widgets/gimppreview.c
View File

@ -88,14 +88,6 @@ static gboolean gimp_preview_leave_notify_event (GtkWidget *widget,
static gboolean gimp_preview_idle_update (GimpPreview *preview);
static void gimp_preview_render (GimpPreview *preview);
static void gimp_preview_real_render (GimpPreview *preview);
static void gimp_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static void gimp_preview_real_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static gboolean gimp_preview_needs_popup (GimpPreview *preview);
static gboolean gimp_preview_real_needs_popup (GimpPreview *preview);
static GtkWidget * gimp_preview_create_popup (GimpPreview *preview);
@ -209,7 +201,6 @@ gimp_preview_class_init (GimpPreviewClass *klass)
klass->extended_clicked = NULL;
klass->context = NULL;
klass->render = gimp_preview_real_render;
klass->get_size = gimp_preview_real_get_size;
klass->needs_popup = gimp_preview_real_needs_popup;
klass->create_popup = gimp_preview_real_create_popup;
}
@ -696,7 +687,19 @@ gimp_preview_set_size (GimpPreview *preview,
preview->size = preview_size;
gimp_preview_get_size (preview, preview_size, &width, &height);
if (preview->viewable)
{
gimp_viewable_get_preview_size (preview->viewable,
preview_size,
preview->is_popup,
preview->dot_for_dot,
&width, &height);
}
else
{
width = preview_size;
height = preview_size;
}
gimp_preview_set_size_full (preview,
width,
@ -834,32 +837,6 @@ gimp_preview_real_render (GimpPreview *preview)
}
}
static void
gimp_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
g_return_if_fail (GIMP_IS_PREVIEW (preview));
g_return_if_fail (width != NULL);
g_return_if_fail (height != NULL);
if (preview->viewable)
GIMP_PREVIEW_GET_CLASS (preview)->get_size (preview, size, width, height);
else
gimp_preview_real_get_size (preview, size, width, height);
}
static void
gimp_preview_real_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
*width = size;
*height = size;
}
static gboolean
gimp_preview_needs_popup (GimpPreview *preview)
{
@ -1014,48 +991,6 @@ gimp_preview_drag_viewable (GtkWidget *widget,
/* protected functions */
void
gimp_preview_calc_size (GimpPreview *preview,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up)
{
gdouble xratio;
gdouble yratio;
if (aspect_width > aspect_height)
{
xratio = yratio = (gdouble) width / (gdouble) aspect_width;
}
else
{
xratio = yratio = (gdouble) height / (gdouble) aspect_height;
}
if (! preview->dot_for_dot && xresolution != yresolution)
{
yratio *= xresolution / yresolution;
}
width = RINT (xratio * (gdouble) aspect_width);
height = RINT (yratio * (gdouble) aspect_height);
if (width < 1) width = 1;
if (height < 1) height = 1;
*return_width = width;
*return_height = height;
if (scaling_up)
*scaling_up = (xratio > 1.0) || (yratio > 1.0);
}
void
gimp_preview_render_and_flush (GimpPreview *preview,
TempBuf *temp_buf,

14
app/widgets/gimppreview.h
View File

@ -86,10 +86,6 @@ struct _GimpPreviewClass
/* virtual functions */
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);
};
@ -136,16 +132,6 @@ void gimp_preview_update (GimpPreview *preview);
/* protected */
void gimp_preview_calc_size (GimpPreview *preview,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up);
void gimp_preview_render_and_flush (GimpPreview *preview,
TempBuf *temp_buf,
gint channel);

91
app/widgets/gimppreviewrenderer.c
View File

@ -88,14 +88,6 @@ static gboolean gimp_preview_leave_notify_event (GtkWidget *widget,
static gboolean gimp_preview_idle_update (GimpPreview *preview);
static void gimp_preview_render (GimpPreview *preview);
static void gimp_preview_real_render (GimpPreview *preview);
static void gimp_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static void gimp_preview_real_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static gboolean gimp_preview_needs_popup (GimpPreview *preview);
static gboolean gimp_preview_real_needs_popup (GimpPreview *preview);
static GtkWidget * gimp_preview_create_popup (GimpPreview *preview);
@ -209,7 +201,6 @@ gimp_preview_class_init (GimpPreviewClass *klass)
klass->extended_clicked = NULL;
klass->context = NULL;
klass->render = gimp_preview_real_render;
klass->get_size = gimp_preview_real_get_size;
klass->needs_popup = gimp_preview_real_needs_popup;
klass->create_popup = gimp_preview_real_create_popup;
}
@ -696,7 +687,19 @@ gimp_preview_set_size (GimpPreview *preview,
preview->size = preview_size;
gimp_preview_get_size (preview, preview_size, &width, &height);
if (preview->viewable)
{
gimp_viewable_get_preview_size (preview->viewable,
preview_size,
preview->is_popup,
preview->dot_for_dot,
&width, &height);
}
else
{
width = preview_size;
height = preview_size;
}
gimp_preview_set_size_full (preview,
width,
@ -834,32 +837,6 @@ gimp_preview_real_render (GimpPreview *preview)
}
}
static void
gimp_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
g_return_if_fail (GIMP_IS_PREVIEW (preview));
g_return_if_fail (width != NULL);
g_return_if_fail (height != NULL);
if (preview->viewable)
GIMP_PREVIEW_GET_CLASS (preview)->get_size (preview, size, width, height);
else
gimp_preview_real_get_size (preview, size, width, height);
}
static void
gimp_preview_real_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
*width = size;
*height = size;
}
static gboolean
gimp_preview_needs_popup (GimpPreview *preview)
{
@ -1014,48 +991,6 @@ gimp_preview_drag_viewable (GtkWidget *widget,
/* protected functions */
void
gimp_preview_calc_size (GimpPreview *preview,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up)
{
gdouble xratio;
gdouble yratio;
if (aspect_width > aspect_height)
{
xratio = yratio = (gdouble) width / (gdouble) aspect_width;
}
else
{
xratio = yratio = (gdouble) height / (gdouble) aspect_height;
}
if (! preview->dot_for_dot && xresolution != yresolution)
{
yratio *= xresolution / yresolution;
}
width = RINT (xratio * (gdouble) aspect_width);
height = RINT (yratio * (gdouble) aspect_height);
if (width < 1) width = 1;
if (height < 1) height = 1;
*return_width = width;
*return_height = height;
if (scaling_up)
*scaling_up = (xratio > 1.0) || (yratio > 1.0);
}
void
gimp_preview_render_and_flush (GimpPreview *preview,
TempBuf *temp_buf,

14
app/widgets/gimppreviewrenderer.h
View File

@ -86,10 +86,6 @@ struct _GimpPreviewClass
/* virtual functions */
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);
};
@ -136,16 +132,6 @@ void gimp_preview_update (GimpPreview *preview);
/* protected */
void gimp_preview_calc_size (GimpPreview *preview,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up);
void gimp_preview_render_and_flush (GimpPreview *preview,
TempBuf *temp_buf,
gint channel);

111
app/widgets/gimppreviewrendererdrawable.c
View File

@ -39,10 +39,6 @@ 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);
@ -87,7 +83,6 @@ gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass)
parent_class = g_type_class_peek_parent (klass);
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;
}
@ -96,47 +91,6 @@ 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 = gimp_item_get_image (GIMP_ITEM (drawable));
if (gimage && ! preview->is_popup)
{
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
size,
size,
gimage->xresolution,
gimage->yresolution,
width,
height,
&scaling_up);
}
else
{
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
size,
size,
1.0,
1.0,
width,
height,
&scaling_up);
}
}
static void
gimp_drawable_preview_render (GimpPreview *preview)
{
@ -162,29 +116,31 @@ gimp_drawable_preview_render (GimpPreview *preview)
height = MAX (1, ROUND ((((gdouble) height / (gdouble) gimage->height) *
(gdouble) drawable->height)));
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
width,
height,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
drawable->width,
drawable->height,
width,
height,
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
}
else
{
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
width,
height,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
drawable->width,
drawable->height,
width,
height,
preview->dot_for_dot,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&preview_width,
&preview_height,
&scaling_up);
}
if (scaling_up)
@ -273,16 +229,19 @@ gimp_drawable_preview_create_popup (GimpPreview *preview)
drawable = GIMP_DRAWABLE (preview->viewable);
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
MIN (preview->width * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&popup_width,
&popup_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
drawable->width,
drawable->height,
MIN (preview->width * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
preview->dot_for_dot,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&popup_width,
&popup_height,
&scaling_up);
if (scaling_up)
{

72
app/widgets/gimppreviewrendererimage.c
View File

@ -36,10 +36,6 @@ 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 void gimp_image_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static GtkWidget * gimp_image_preview_create_popup (GimpPreview *preview);
@ -84,7 +80,6 @@ gimp_image_preview_class_init (GimpImagePreviewClass *klass)
parent_class = g_type_class_peek_parent (klass);
preview_class->render = gimp_image_preview_render;
preview_class->get_size = gimp_image_preview_get_size;
preview_class->create_popup = gimp_image_preview_create_popup;
}
@ -94,29 +89,6 @@ gimp_image_preview_init (GimpImagePreview *preview)
preview->channel = -1;
}
static void
gimp_image_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
GimpImage *gimage;
gboolean scaling_up;
gimage = GIMP_IMAGE (preview->viewable);
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
size,
size,
gimage->xresolution,
gimage->yresolution,
width,
height,
&scaling_up);
}
static void
gimp_image_preview_render (GimpPreview *preview)
{
@ -133,16 +105,17 @@ gimp_image_preview_render (GimpPreview *preview)
width = preview->width;
height = preview->height;
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
width,
height,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
gimage->width,
gimage->height,
width,
height,
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
if (scaling_up)
{
@ -215,16 +188,19 @@ gimp_image_preview_create_popup (GimpPreview *preview)
gimage = GIMP_IMAGE (preview->viewable);
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
MIN (preview->width * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
gimage->xresolution,
gimage->yresolution,
&popup_width,
&popup_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
gimage->width,
gimage->height,
MIN (preview->width * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&popup_width,
&popup_height,
&scaling_up);
if (scaling_up)
{

23
app/widgets/gimpselectioneditor.c
View File

@ -273,16 +273,19 @@ gimp_selection_editor_abox_resized (GtkWidget *widget,
gint height;
gboolean dummy;
gimp_preview_calc_size (preview,
image_editor->gimage->width,
image_editor->gimage->height,
MIN (allocation->width, GIMP_PREVIEW_MAX_SIZE),
MIN (allocation->height, GIMP_PREVIEW_MAX_SIZE),
image_editor->gimage->xresolution,
image_editor->gimage->yresolution,
&width,
&height,
&dummy);
gimp_viewable_calc_preview_size (preview->viewable,
image_editor->gimage->width,
image_editor->gimage->height,
MIN (allocation->width,
GIMP_PREVIEW_MAX_SIZE),
MIN (allocation->height,
GIMP_PREVIEW_MAX_SIZE),
preview->dot_for_dot,
image_editor->gimage->xresolution,
image_editor->gimage->yresolution,
&width,
&height,
&dummy);
if (width > allocation->width)
{

19
app/widgets/gimpundopreview.c
View File

@ -108,15 +108,16 @@ gimp_undo_preview_render (GimpPreview *preview)
if (! render_buf)
return;
gimp_preview_calc_size (preview,
render_buf->width,
render_buf->height,
width,
height,
1.0, 1.0,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
render_buf->width,
render_buf->height,
width,
height,
preview->dot_for_dot,
1.0, 1.0,
&preview_width,
&preview_height,
&scaling_up);
if (preview_width != render_buf->width ||
preview_height != render_buf->height)

91
app/widgets/gimpview.c
View File

@ -88,14 +88,6 @@ static gboolean gimp_preview_leave_notify_event (GtkWidget *widget,
static gboolean gimp_preview_idle_update (GimpPreview *preview);
static void gimp_preview_render (GimpPreview *preview);
static void gimp_preview_real_render (GimpPreview *preview);
static void gimp_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static void gimp_preview_real_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static gboolean gimp_preview_needs_popup (GimpPreview *preview);
static gboolean gimp_preview_real_needs_popup (GimpPreview *preview);
static GtkWidget * gimp_preview_create_popup (GimpPreview *preview);
@ -209,7 +201,6 @@ gimp_preview_class_init (GimpPreviewClass *klass)
klass->extended_clicked = NULL;
klass->context = NULL;
klass->render = gimp_preview_real_render;
klass->get_size = gimp_preview_real_get_size;
klass->needs_popup = gimp_preview_real_needs_popup;
klass->create_popup = gimp_preview_real_create_popup;
}
@ -696,7 +687,19 @@ gimp_preview_set_size (GimpPreview *preview,
preview->size = preview_size;
gimp_preview_get_size (preview, preview_size, &width, &height);
if (preview->viewable)
{
gimp_viewable_get_preview_size (preview->viewable,
preview_size,
preview->is_popup,
preview->dot_for_dot,
&width, &height);
}
else
{
width = preview_size;
height = preview_size;
}
gimp_preview_set_size_full (preview,
width,
@ -834,32 +837,6 @@ gimp_preview_real_render (GimpPreview *preview)
}
}
static void
gimp_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
g_return_if_fail (GIMP_IS_PREVIEW (preview));
g_return_if_fail (width != NULL);
g_return_if_fail (height != NULL);
if (preview->viewable)
GIMP_PREVIEW_GET_CLASS (preview)->get_size (preview, size, width, height);
else
gimp_preview_real_get_size (preview, size, width, height);
}
static void
gimp_preview_real_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
*width = size;
*height = size;
}
static gboolean
gimp_preview_needs_popup (GimpPreview *preview)
{
@ -1014,48 +991,6 @@ gimp_preview_drag_viewable (GtkWidget *widget,
/* protected functions */
void
gimp_preview_calc_size (GimpPreview *preview,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up)
{
gdouble xratio;
gdouble yratio;
if (aspect_width > aspect_height)
{
xratio = yratio = (gdouble) width / (gdouble) aspect_width;
}
else
{
xratio = yratio = (gdouble) height / (gdouble) aspect_height;
}
if (! preview->dot_for_dot && xresolution != yresolution)
{
yratio *= xresolution / yresolution;
}
width = RINT (xratio * (gdouble) aspect_width);
height = RINT (yratio * (gdouble) aspect_height);
if (width < 1) width = 1;
if (height < 1) height = 1;
*return_width = width;
*return_height = height;
if (scaling_up)
*scaling_up = (xratio > 1.0) || (yratio > 1.0);
}
void
gimp_preview_render_and_flush (GimpPreview *preview,
TempBuf *temp_buf,

14
app/widgets/gimpview.h
View File

@ -86,10 +86,6 @@ struct _GimpPreviewClass
/* virtual functions */
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);
};
@ -136,16 +132,6 @@ void gimp_preview_update (GimpPreview *preview);
/* protected */
void gimp_preview_calc_size (GimpPreview *preview,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up);
void gimp_preview_render_and_flush (GimpPreview *preview,
TempBuf *temp_buf,
gint channel);

91
app/widgets/gimpviewrenderer.c
View File

@ -88,14 +88,6 @@ static gboolean gimp_preview_leave_notify_event (GtkWidget *widget,
static gboolean gimp_preview_idle_update (GimpPreview *preview);
static void gimp_preview_render (GimpPreview *preview);
static void gimp_preview_real_render (GimpPreview *preview);
static void gimp_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static void gimp_preview_real_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static gboolean gimp_preview_needs_popup (GimpPreview *preview);
static gboolean gimp_preview_real_needs_popup (GimpPreview *preview);
static GtkWidget * gimp_preview_create_popup (GimpPreview *preview);
@ -209,7 +201,6 @@ gimp_preview_class_init (GimpPreviewClass *klass)
klass->extended_clicked = NULL;
klass->context = NULL;
klass->render = gimp_preview_real_render;
klass->get_size = gimp_preview_real_get_size;
klass->needs_popup = gimp_preview_real_needs_popup;
klass->create_popup = gimp_preview_real_create_popup;
}
@ -696,7 +687,19 @@ gimp_preview_set_size (GimpPreview *preview,
preview->size = preview_size;
gimp_preview_get_size (preview, preview_size, &width, &height);
if (preview->viewable)
{
gimp_viewable_get_preview_size (preview->viewable,
preview_size,
preview->is_popup,
preview->dot_for_dot,
&width, &height);
}
else
{
width = preview_size;
height = preview_size;
}
gimp_preview_set_size_full (preview,
width,
@ -834,32 +837,6 @@ gimp_preview_real_render (GimpPreview *preview)
}
}
static void
gimp_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
g_return_if_fail (GIMP_IS_PREVIEW (preview));
g_return_if_fail (width != NULL);
g_return_if_fail (height != NULL);
if (preview->viewable)
GIMP_PREVIEW_GET_CLASS (preview)->get_size (preview, size, width, height);
else
gimp_preview_real_get_size (preview, size, width, height);
}
static void
gimp_preview_real_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
*width = size;
*height = size;
}
static gboolean
gimp_preview_needs_popup (GimpPreview *preview)
{
@ -1014,48 +991,6 @@ gimp_preview_drag_viewable (GtkWidget *widget,
/* protected functions */
void
gimp_preview_calc_size (GimpPreview *preview,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up)
{
gdouble xratio;
gdouble yratio;
if (aspect_width > aspect_height)
{
xratio = yratio = (gdouble) width / (gdouble) aspect_width;
}
else
{
xratio = yratio = (gdouble) height / (gdouble) aspect_height;
}
if (! preview->dot_for_dot && xresolution != yresolution)
{
yratio *= xresolution / yresolution;
}
width = RINT (xratio * (gdouble) aspect_width);
height = RINT (yratio * (gdouble) aspect_height);
if (width < 1) width = 1;
if (height < 1) height = 1;
*return_width = width;
*return_height = height;
if (scaling_up)
*scaling_up = (xratio > 1.0) || (yratio > 1.0);
}
void
gimp_preview_render_and_flush (GimpPreview *preview,
TempBuf *temp_buf,

14
app/widgets/gimpviewrenderer.h
View File

@ -86,10 +86,6 @@ struct _GimpPreviewClass
/* virtual functions */
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);
};
@ -136,16 +132,6 @@ void gimp_preview_update (GimpPreview *preview);
/* protected */
void gimp_preview_calc_size (GimpPreview *preview,
gint aspect_width,
gint aspect_height,
gint width,
gint height,
gdouble xresolution,
gdouble yresolution,
gint *return_width,
gint *return_height,
gboolean *scaling_up);
void gimp_preview_render_and_flush (GimpPreview *preview,
TempBuf *temp_buf,
gint channel);

111
app/widgets/gimpviewrendererdrawable.c
View File

@ -39,10 +39,6 @@ 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);
@ -87,7 +83,6 @@ gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass)
parent_class = g_type_class_peek_parent (klass);
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;
}
@ -96,47 +91,6 @@ 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 = gimp_item_get_image (GIMP_ITEM (drawable));
if (gimage && ! preview->is_popup)
{
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
size,
size,
gimage->xresolution,
gimage->yresolution,
width,
height,
&scaling_up);
}
else
{
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
size,
size,
1.0,
1.0,
width,
height,
&scaling_up);
}
}
static void
gimp_drawable_preview_render (GimpPreview *preview)
{
@ -162,29 +116,31 @@ gimp_drawable_preview_render (GimpPreview *preview)
height = MAX (1, ROUND ((((gdouble) height / (gdouble) gimage->height) *
(gdouble) drawable->height)));
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
width,
height,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
drawable->width,
drawable->height,
width,
height,
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
}
else
{
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
width,
height,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
drawable->width,
drawable->height,
width,
height,
preview->dot_for_dot,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&preview_width,
&preview_height,
&scaling_up);
}
if (scaling_up)
@ -273,16 +229,19 @@ gimp_drawable_preview_create_popup (GimpPreview *preview)
drawable = GIMP_DRAWABLE (preview->viewable);
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
gimp_preview_calc_size (preview,
drawable->width,
drawable->height,
MIN (preview->width * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&popup_width,
&popup_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
drawable->width,
drawable->height,
MIN (preview->width * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
preview->dot_for_dot,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&popup_width,
&popup_height,
&scaling_up);
if (scaling_up)
{

72
app/widgets/gimpviewrendererimage.c
View File

@ -36,10 +36,6 @@ 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 void gimp_image_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height);
static GtkWidget * gimp_image_preview_create_popup (GimpPreview *preview);
@ -84,7 +80,6 @@ gimp_image_preview_class_init (GimpImagePreviewClass *klass)
parent_class = g_type_class_peek_parent (klass);
preview_class->render = gimp_image_preview_render;
preview_class->get_size = gimp_image_preview_get_size;
preview_class->create_popup = gimp_image_preview_create_popup;
}
@ -94,29 +89,6 @@ gimp_image_preview_init (GimpImagePreview *preview)
preview->channel = -1;
}
static void
gimp_image_preview_get_size (GimpPreview *preview,
gint size,
gint *width,
gint *height)
{
GimpImage *gimage;
gboolean scaling_up;
gimage = GIMP_IMAGE (preview->viewable);
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
size,
size,
gimage->xresolution,
gimage->yresolution,
width,
height,
&scaling_up);
}
static void
gimp_image_preview_render (GimpPreview *preview)
{
@ -133,16 +105,17 @@ gimp_image_preview_render (GimpPreview *preview)
width = preview->width;
height = preview->height;
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
width,
height,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
gimage->width,
gimage->height,
width,
height,
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
if (scaling_up)
{
@ -215,16 +188,19 @@ gimp_image_preview_create_popup (GimpPreview *preview)
gimage = GIMP_IMAGE (preview->viewable);
gimp_preview_calc_size (preview,
gimage->width,
gimage->height,
MIN (preview->width * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2, GIMP_PREVIEW_MAX_POPUP_SIZE),
gimage->xresolution,
gimage->yresolution,
&popup_width,
&popup_height,
&scaling_up);
gimp_viewable_calc_preview_size (preview->viewable,
gimage->width,
gimage->height,
MIN (preview->width * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
MIN (preview->height * 2,
GIMP_PREVIEW_MAX_POPUP_SIZE),
preview->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&popup_width,
&popup_height,
&scaling_up);
if (scaling_up)
{

3
app/widgets/widgets-enums.h
View File

@ -66,7 +66,8 @@ typedef enum
typedef enum /*< skip >*/
{
GIMP_VIEW_TYPE_GRID,
GIMP_VIEW_TYPE_LIST
GIMP_VIEW_TYPE_LIST,
GIMP_VIEW_TYPE_TREE
} GimpViewType;
typedef enum /*< skip >*/

3
app/widgets/widgets-types.h
View File

@ -70,6 +70,7 @@ typedef struct _GimpUndoEditor GimpUndoEditor;
typedef struct _GimpContainerView GimpContainerView;
typedef struct _GimpContainerListView GimpContainerListView;
typedef struct _GimpContainerGridView GimpContainerGridView;
typedef struct _GimpContainerTreeView GimpContainerTreeView;
typedef struct _GimpItemListView GimpItemListView;
typedef struct _GimpDrawableListView GimpDrawableListView;
@ -116,7 +117,7 @@ typedef struct _GimpItemFactoryEntry GimpItemFactoryEntry;
typedef void (* GimpItemFactorySetupFunc) (GimpItemFactory *factory);
typedef void (* GimpItemFactoryUpdateFunc) (GtkItemFactory *factory,
gpointer data);
typedef gchar * (* GimpItemGetNameFunc) (GtkWidget *widget,
typedef gchar * (* GimpItemGetNameFunc) (GObject *object,
gchar **tooltip);