callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

app/widgets/gimppreviewrenderer-utils.c

Browse Source 
* app/widgets/gimppreviewrenderer-utils.c
* app/widgets/gimppreviewrenderer-utils.h
* app/widgets/gimppreviewrendererbrush.c
* app/widgets/gimppreviewrendererbrush.h
* app/widgets/gimppreviewrendererdrawable.c
* app/widgets/gimppreviewrendererdrawable.h
* app/widgets/gimppreviewrenderergradient.c
* app/widgets/gimppreviewrenderergradient.h
* app/widgets/gimppreviewrendererimage.c
* app/widgets/gimppreviewrendererimage.h
* app/widgets/gimppreviewrendererimagefile.c
* app/widgets/gimppreviewrendererimagefile.h
* app/widgets/gimppreviewrendererlayer.c
* app/widgets/gimppreviewrendererlayer.h
* app/widgets/gimppreviewrenderervectors.c
* app/widgets/gimppreviewrenderervectors.h: Renamed all these files...

* app/widgets/gimpviewrenderer-utils.c
* app/widgets/gimpviewrenderer-utils.h
* app/widgets/gimpviewrendererbrush.c
* app/widgets/gimpviewrendererbrush.h
* app/widgets/gimpviewrendererdrawable.c
* app/widgets/gimpviewrendererdrawable.h
* app/widgets/gimpviewrenderergradient.c
* app/widgets/gimpviewrenderergradient.h
* app/widgets/gimpviewrendererimage.c
* app/widgets/gimpviewrendererimage.h
* app/widgets/gimpviewrendererimagefile.c
* app/widgets/gimpviewrendererimagefile.h
* app/widgets/gimpviewrendererlayer.c
* app/widgets/gimpviewrendererlayer.h
* app/widgets/gimpviewrenderervectors.c
* app/widgets/gimpviewrenderervectors.h: ... to these names. And also
  changed all the GimpPreviewRenderer* types to GimpViewRenderer* ones.

* app/tools/gimppaintoptions-gui.c

* app/widgets/Makefile.am
* app/widgets/gimpcomponenteditor.c
* app/widgets/gimpfiledialog.c
* app/widgets/gimpgradienteditor.c
* app/widgets/gimpview.c
* app/widgets/widgets-types.h
* app/widgets/gimpviewrenderer.c
* app/widgets/gimpviewrenderer.h: modified accordingly.
This commit is contained in:
David Odin
2004-08-26 14:20:30 +00:00
parent db6dff283f
commit 1622243213
41 changed files with 464 additions and 2351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
ChangeLog
View File

@ -1,3 +1,51 @@
2004-08-26 DindinX <david@dindinx.org>
* app/widgets/gimppreviewrenderer-utils.c
* app/widgets/gimppreviewrenderer-utils.h
* app/widgets/gimppreviewrendererbrush.c
* app/widgets/gimppreviewrendererbrush.h
* app/widgets/gimppreviewrendererdrawable.c
* app/widgets/gimppreviewrendererdrawable.h
* app/widgets/gimppreviewrenderergradient.c
* app/widgets/gimppreviewrenderergradient.h
* app/widgets/gimppreviewrendererimage.c
* app/widgets/gimppreviewrendererimage.h
* app/widgets/gimppreviewrendererimagefile.c
* app/widgets/gimppreviewrendererimagefile.h
* app/widgets/gimppreviewrendererlayer.c
* app/widgets/gimppreviewrendererlayer.h
* app/widgets/gimppreviewrenderervectors.c
* app/widgets/gimppreviewrenderervectors.h: Renamed all these files...
* app/widgets/gimpviewrenderer-utils.c
* app/widgets/gimpviewrenderer-utils.h
* app/widgets/gimpviewrendererbrush.c
* app/widgets/gimpviewrendererbrush.h
* app/widgets/gimpviewrendererdrawable.c
* app/widgets/gimpviewrendererdrawable.h
* app/widgets/gimpviewrenderergradient.c
* app/widgets/gimpviewrenderergradient.h
* app/widgets/gimpviewrendererimage.c
* app/widgets/gimpviewrendererimage.h
* app/widgets/gimpviewrendererimagefile.c
* app/widgets/gimpviewrendererimagefile.h
* app/widgets/gimpviewrendererlayer.c
* app/widgets/gimpviewrendererlayer.h
* app/widgets/gimpviewrenderervectors.c
* app/widgets/gimpviewrenderervectors.h: ... to these names. And also
changed all the GimpPreviewRenderer* types to GimpViewRenderer* ones.
* app/tools/gimppaintoptions-gui.c
* app/widgets/Makefile.am
* app/widgets/gimpcomponenteditor.c
* app/widgets/gimpfiledialog.c
* app/widgets/gimpgradienteditor.c
* app/widgets/gimpview.c
* app/widgets/widgets-types.h
* app/widgets/gimpviewrenderer.c
* app/widgets/gimpviewrenderer.h: modified accordingly.
2004-08-26 Sven Neumann <sven@gimp.org>
* app/sanity.c (sanity_check_filename_encoding): try to convert

14
app/tools/gimppaintoptions-gui.c
View File

@ -36,7 +36,7 @@
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpview.h"
#include "widgets/gimppreviewrenderergradient.h"
#include "widgets/gimpviewrenderergradient.h"
#include "widgets/gimppropwidgets.h"
#include "widgets/gtkhwrapbox.h"
#include "widgets/gimpviewablebutton.h"
@ -131,7 +131,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
gtk_widget_set_sensitive (mode_label, FALSE);
}
/* the brush preview */
/* the brush view */
if (tool_type != GIMP_TYPE_BUCKET_FILL_TOOL &&
tool_type != GIMP_TYPE_BLEND_TOOL &&
tool_type != GIMP_TYPE_INK_TOOL)
@ -149,7 +149,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
button, 2, TRUE);
}
/* the pattern preview */
/* the pattern view */
if (tool_type == GIMP_TYPE_BUCKET_FILL_TOOL ||
tool_type == GIMP_TYPE_CLONE_TOOL)
{
@ -166,7 +166,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
button, 2, TRUE);
}
/* the gradient preview */
/* the gradient view */
if (g_type_is_a (tool_type, GIMP_TYPE_PAINTBRUSH_TOOL) ||
tool_options->tool_info->tool_type == GIMP_TYPE_BLEND_TOOL)
{
@ -495,10 +495,10 @@ gradient_options_reverse_notify (GimpPaintOptions *paint_options,
GParamSpec *pspec,
GimpView *view)
{
GimpPreviewRendererGradient *rendergrad;
GimpViewRendererGradient *rendergrad;
rendergrad = GIMP_PREVIEW_RENDERER_GRADIENT (view->renderer);
rendergrad = GIMP_VIEW_RENDERER_GRADIENT (view->renderer);
gimp_preview_renderer_gradient_set_reverse (rendergrad,
gimp_view_renderer_gradient_set_reverse (rendergrad,
paint_options->gradient_options->gradient_reverse);
}

32
app/widgets/Makefile.am
View File

@ -188,22 +188,6 @@ libappwidgets_a_sources = \
gimppdbdialog.h \
gimppluginaction.c \
gimppluginaction.h \
gimppreviewrenderer-utils.c \
gimppreviewrenderer-utils.h \
gimppreviewrendererbrush.c \
gimppreviewrendererbrush.h \
gimppreviewrendererdrawable.c \
gimppreviewrendererdrawable.h \
gimppreviewrenderergradient.c \
gimppreviewrenderergradient.h \
gimppreviewrendererimage.c \
gimppreviewrendererimage.h \
gimppreviewrendererimagefile.c \
gimppreviewrendererimagefile.h \
gimppreviewrendererlayer.c \
gimppreviewrendererlayer.h \
gimppreviewrenderervectors.c \
gimppreviewrenderervectors.h \
gimpprogressbox.c \
gimpprogressbox.h \
gimpprogressdialog.c \
@ -264,6 +248,22 @@ libappwidgets_a_sources = \
gimpviewabledialog.h \
gimpviewrenderer.c \
gimpviewrenderer.h \
gimpviewrenderer-utils.c \
gimpviewrenderer-utils.h \
gimpviewrendererbrush.c \
gimpviewrendererbrush.h \
gimpviewrendererdrawable.c \
gimpviewrendererdrawable.h \
gimpviewrenderergradient.c \
gimpviewrenderergradient.h \
gimpviewrendererimage.c \
gimpviewrendererimage.h \
gimpviewrendererimagefile.c \
gimpviewrendererimagefile.h \
gimpviewrendererlayer.c \
gimpviewrendererlayer.h \
gimpviewrenderervectors.c \
gimpviewrenderervectors.h \
gimpwidgets-constructors.c \
gimpwidgets-constructors.h \
gimpwidgets-utils.c \

28
app/widgets/gimpcomponenteditor.c
View File

@ -33,7 +33,7 @@
#include "gimpcellrendererviewable.h"
#include "gimpcomponenteditor.h"
#include "gimpmenufactory.h"
#include "gimppreviewrendererimage.h"
#include "gimpviewrendererimage.h"
#include "gimpwidgets-utils.h"
#include "gimp-intl.h"
@ -268,13 +268,13 @@ gimp_component_editor_set_image (GimpImageEditor *editor,
}
GtkWidget *
gimp_component_editor_new (gint preview_size,
gimp_component_editor_new (gint view_size,
GimpMenuFactory *menu_factory)
{
GimpComponentEditor *editor;
g_return_val_if_fail (preview_size > 0 &&
preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);
g_return_val_if_fail (view_size > 0 &&
view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
editor = g_object_new (GIMP_TYPE_COMPONENT_EDITOR,
@ -283,14 +283,14 @@ gimp_component_editor_new (gint preview_size,
"ui-path", "/channels-popup",
NULL);
gimp_component_editor_set_preview_size (editor, preview_size);
gimp_component_editor_set_preview_size (editor, view_size);
return GTK_WIDGET (editor);
}
void
gimp_component_editor_set_preview_size (GimpComponentEditor *editor,
gint preview_size)
gint view_size)
{
GtkWidget *tree_widget;
GtkIconSize icon_size;
@ -298,17 +298,17 @@ gimp_component_editor_set_preview_size (GimpComponentEditor *editor,
gboolean iter_valid;
g_return_if_fail (GIMP_IS_COMPONENT_EDITOR (editor));
g_return_if_fail (preview_size > 0 &&
preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE);
g_return_if_fail (view_size > 0 &&
view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE);
tree_widget = GTK_WIDGET (editor->view);
icon_size = gimp_get_icon_size (tree_widget,
GIMP_STOCK_VISIBLE,
GTK_ICON_SIZE_BUTTON,
preview_size -
view_size -
2 * tree_widget->style->xthickness,
preview_size -
view_size -
2 * tree_widget->style->ythickness);
g_object_set (editor->eye_cell,
@ -325,11 +325,11 @@ gimp_component_editor_set_preview_size (GimpComponentEditor *editor,
COLUMN_RENDERER, &renderer,
-1);
gimp_view_renderer_set_size (renderer, preview_size, 1);
gimp_view_renderer_set_size (renderer, view_size, 1);
g_object_unref (renderer);
}
editor->preview_size = preview_size;
editor->preview_size = view_size;
gtk_tree_view_columns_autosize (editor->view);
}
@ -384,7 +384,7 @@ gimp_component_editor_create_components (GimpComponentEditor *editor)
gimp_view_renderer_set_viewable (renderer, GIMP_VIEWABLE (gimage));
gimp_view_renderer_remove_idle (renderer);
GIMP_PREVIEW_RENDERER_IMAGE (renderer)->channel = components[i];
GIMP_VIEW_RENDERER_IMAGE (renderer)->channel = components[i];
g_signal_connect (renderer, "update",
G_CALLBACK (gimp_component_editor_renderer_update),
@ -553,7 +553,7 @@ gimp_component_editor_renderer_update (GimpViewRenderer *renderer,
gint index;
index = gimp_image_get_component_index (GIMP_IMAGE (renderer->viewable),
GIMP_PREVIEW_RENDERER_IMAGE (renderer)->channel);
GIMP_VIEW_RENDERER_IMAGE (renderer)->channel);
if (gtk_tree_model_iter_nth_child (editor->model, &iter, NULL, index))
{

4
app/widgets/gimpfiledialog.c
View File

@ -44,7 +44,7 @@
#include "gimpfileprocview.h"
#include "gimphelp-ids.h"
#include "gimpview.h"
#include "gimppreviewrendererimagefile.h"
#include "gimpviewrendererimagefile.h"
#include "gimpthumbbox.h"
#include "gimpwidgets-utils.h"
@ -470,7 +470,7 @@ gimp_file_dialog_add_preview (GimpFileDialog *dialog,
gtk_widget_show (dialog->thumb_box);
#ifdef ENABLE_FILE_SYSTEM_ICONS
GIMP_PREVIEW_RENDERER_IMAGEFILE (GIMP_VIEW (GIMP_THUMB_BOX (dialog->thumb_box)->preview)->renderer)->file_system = _gtk_file_chooser_get_file_system (GTK_FILE_CHOOSER (dialog));
GIMP_VIEW_RENDERER_IMAGEFILE (GIMP_VIEW (GIMP_THUMB_BOX (dialog->thumb_box)->preview)->renderer)->file_system = _gtk_file_chooser_get_file_system (GTK_FILE_CHOOSER (dialog));
#endif
}

66
app/widgets/gimpgradienteditor.c
View File

@ -70,7 +70,7 @@
#include "gimpgradienteditor.h"
#include "gimphelp-ids.h"
#include "gimpview.h"
#include "gimppreviewrenderergradient.h"
#include "gimpviewrenderergradient.h"
#include "gimpwidgets-utils.h"
#include "gui/color-notebook.h"
@ -83,14 +83,14 @@
#define GRAD_SCROLLBAR_STEP_SIZE 0.05
#define GRAD_SCROLLBAR_PAGE_SIZE 0.75
#define GRAD_PREVIEW_WIDTH 128
#define GRAD_PREVIEW_HEIGHT 96
#define GRAD_VIEW_WIDTH 128
#define GRAD_VIEW_HEIGHT 96
#define GRAD_CONTROL_HEIGHT 10
#define GRAD_MOVE_TIME 150 /* ms between mouse click and detection of movement in gradient control */
#define GRAD_PREVIEW_EVENT_MASK (GDK_EXPOSURE_MASK | \
#define GRAD_VIEW_EVENT_MASK (GDK_EXPOSURE_MASK | \
GDK_LEAVE_NOTIFY_MASK | \
GDK_POINTER_MOTION_MASK | \
GDK_POINTER_MOTION_HINT_MASK | \
@ -137,17 +137,17 @@ static void gradient_editor_set_hint (GimpGradientEditor *editor,
const gchar *str4);
/* Gradient preview functions */
/* Gradient view functions */
static gint preview_events (GtkWidget *widget,
static gint view_events (GtkWidget *widget,
GdkEvent *event,
GimpGradientEditor *editor);
static void preview_set_hint (GimpGradientEditor *editor,
static void view_set_hint (GimpGradientEditor *editor,
gint x);
static void preview_set_foreground (GimpGradientEditor *editor,
static void view_set_foreground (GimpGradientEditor *editor,
gint x);
static void preview_set_background (GimpGradientEditor *editor,
static void view_set_background (GimpGradientEditor *editor,
gint x);
/* Gradient control functions */
@ -277,7 +277,7 @@ gimp_gradient_editor_init (GimpGradientEditor *editor)
GtkWidget *hbox;
GtkWidget *button;
/* Frame for gradient preview and gradient control */
/* Frame for gradient view and gradient control */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (editor), frame, TRUE, TRUE, 0);
@ -293,18 +293,18 @@ gimp_gradient_editor_init (GimpGradientEditor *editor)
editor->preview = gimp_view_new_full_by_types (GIMP_TYPE_VIEW,
GIMP_TYPE_GRADIENT,
GRAD_PREVIEW_WIDTH,
GRAD_PREVIEW_HEIGHT, 0,
GRAD_VIEW_WIDTH,
GRAD_VIEW_HEIGHT, 0,
FALSE, FALSE, FALSE);
gtk_widget_set_size_request (editor->preview,
GRAD_PREVIEW_WIDTH, GRAD_PREVIEW_HEIGHT);
gtk_widget_set_events (editor->preview, GRAD_PREVIEW_EVENT_MASK);
GRAD_VIEW_WIDTH, GRAD_VIEW_HEIGHT);
gtk_widget_set_events (editor->preview, GRAD_VIEW_EVENT_MASK);
gimp_view_set_expand (GIMP_VIEW (editor->preview), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), editor->preview, TRUE, TRUE, 0);
gtk_widget_show (editor->preview);
g_signal_connect (editor->preview, "event",
G_CALLBACK (preview_events),
G_CALLBACK (view_events),
editor);
gimp_dnd_viewable_dest_add (GTK_WIDGET (editor->preview),
@ -326,7 +326,7 @@ gimp_gradient_editor_init (GimpGradientEditor *editor)
editor->control = gtk_drawing_area_new ();
gtk_widget_set_size_request (editor->control,
GRAD_PREVIEW_WIDTH, GRAD_CONTROL_HEIGHT);
GRAD_VIEW_WIDTH, GRAD_CONTROL_HEIGHT);
gtk_widget_set_events (editor->control, GRAD_CONTROL_EVENT_MASK);
gtk_box_pack_start (GTK_BOX (vbox), editor->control, FALSE, FALSE, 0);
gtk_widget_show (editor->control);
@ -556,7 +556,7 @@ static void
gradient_editor_scrollbar_update (GtkAdjustment *adjustment,
GimpGradientEditor *editor)
{
GimpPreviewRendererGradient *renderer;
GimpViewRendererGradient *renderer;
gchar *str1;
gchar *str2;
@ -572,9 +572,9 @@ gradient_editor_scrollbar_update (GtkAdjustment *adjustment,
g_free (str1);
g_free (str2);
renderer = GIMP_PREVIEW_RENDERER_GRADIENT (GIMP_VIEW (editor->preview)->renderer);
renderer = GIMP_VIEW_RENDERER_GRADIENT (GIMP_VIEW (editor->preview)->renderer);
gimp_preview_renderer_gradient_set_offsets (renderer,
gimp_view_renderer_gradient_set_offsets (renderer,
adjustment->value,
adjustment->value +
adjustment->page_size,
@ -695,10 +695,10 @@ gradient_editor_set_hint (GimpGradientEditor *editor,
}
/***** Gradient preview functions *****/
/***** Gradient view functions *****/
static gboolean
preview_events (GtkWidget *widget,
view_events (GtkWidget *widget,
GdkEvent *event,
GimpGradientEditor *editor)
{
@ -728,13 +728,13 @@ preview_events (GtkWidget *widget,
if (editor->preview_button_down)
{
if (mevent->state & GDK_CONTROL_MASK)
preview_set_background (editor, x);
view_set_background (editor, x);
else
preview_set_foreground (editor, x);
view_set_foreground (editor, x);
}
else
{
preview_set_hint (editor, x);
view_set_hint (editor, x);
}
}
break;
@ -750,9 +750,9 @@ preview_events (GtkWidget *widget,
editor->preview_last_x = x;
editor->preview_button_down = TRUE;
if (bevent->state & GDK_CONTROL_MASK)
preview_set_background (editor, x);
view_set_background (editor, x);
else
preview_set_foreground (editor, x);
view_set_foreground (editor, x);
break;
case 3:
@ -799,9 +799,9 @@ preview_events (GtkWidget *widget,
editor->preview_last_x = x;
editor->preview_button_down = FALSE;
if (bevent->state & GDK_CONTROL_MASK)
preview_set_background (editor, x);
view_set_background (editor, x);
else
preview_set_foreground (editor, x);
view_set_foreground (editor, x);
break;
}
break;
@ -814,7 +814,7 @@ preview_events (GtkWidget *widget,
}
static void
preview_set_hint (GimpGradientEditor *editor,
view_set_hint (GimpGradientEditor *editor,
gint x)
{
GimpDataEditor *data_editor;
@ -855,7 +855,7 @@ preview_set_hint (GimpGradientEditor *editor,
}
static void
preview_set_foreground (GimpGradientEditor *editor,
view_set_foreground (GimpGradientEditor *editor,
gint x)
{
GimpGradient *gradient;
@ -890,7 +890,7 @@ preview_set_foreground (GimpGradientEditor *editor,
}
static void
preview_set_background (GimpGradientEditor *editor,
view_set_background (GimpGradientEditor *editor,
gint x)
{
GimpGradient *gradient;
@ -1585,7 +1585,7 @@ control_update (GimpGradientEditor *editor,
return;
/* See whether we have to re-create the control pixmap
* depending on the preview's width
* depending on the view's width
*/
cwidth = editor->preview->allocation.width;
cheight = GRAD_CONTROL_HEIGHT;
@ -1763,7 +1763,7 @@ control_calc_p_pos (GimpGradientEditor *editor,
/* Calculate the position (in widget's coordinates) of the
* requested point from the gradient. Rounding is done to
* minimize mismatches between the rendered gradient preview
* minimize mismatches between the rendered gradient view
* and the gradient control's handles.
*/

82
app/widgets/gimppreviewrenderer-utils.c
View File

@ -1,82 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderer-utils.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 <gtk/gtk.h>
#include "widgets-types.h"
#include "core/gimpbrush.h"
#include "core/gimpdrawable.h"
#include "core/gimpgradient.h"
#include "core/gimplayer.h"
#include "core/gimpimage.h"
#include "core/gimpimagefile.h"
#include "vectors/gimpvectors.h"
#include "gimppreviewrendererbrush.h"
#include "gimppreviewrendererlayer.h"
#include "gimppreviewrenderergradient.h"
#include "gimppreviewrendererimage.h"
#include "gimppreviewrendererimagefile.h"
#include "gimppreviewrenderervectors.h"
GType
gimp_preview_renderer_type_from_viewable_type (GType viewable_type)
{
GType type = GIMP_TYPE_VIEW_RENDERER;
g_return_val_if_fail (g_type_is_a (viewable_type, GIMP_TYPE_VIEWABLE),
G_TYPE_NONE);
if (g_type_is_a (viewable_type, GIMP_TYPE_BRUSH))
{
type = GIMP_TYPE_PREVIEW_RENDERER_BRUSH;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_IMAGE))
{
type = GIMP_TYPE_PREVIEW_RENDERER_IMAGE;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_LAYER))
{
type = GIMP_TYPE_PREVIEW_RENDERER_LAYER;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_DRAWABLE))
{
type = GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_GRADIENT))
{
type = GIMP_TYPE_PREVIEW_RENDERER_GRADIENT;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_VECTORS))
{
type = GIMP_TYPE_PREVIEW_RENDERER_VECTORS;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_IMAGEFILE))
{
type = GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE;
}
return type;
}

29
app/widgets/gimppreviewrenderer-utils.h
View File

@ -1,29 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderer-utils.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_PREVIEW_RENDERER_UTILS_H__
#define __GIMP_PREVIEW_RENDERER_UTILS_H__
GType gimp_preview_renderer_type_from_viewable_type (GType viewable_type);
#endif /* __GIMP_PREVIEW_RENDERER_UTILS_H__ */

324
app/widgets/gimppreviewrendererbrush.c
View File

@ -1,324 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererbrush.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 <gtk/gtk.h>
#include "widgets-types.h"
#include "base/temp-buf.h"
#include "core/gimpbrush.h"
#include "core/gimpbrushpipe.h"
#include "gimppreviewrendererbrush.h"
static void gimp_preview_renderer_brush_class_init (GimpPreviewRendererBrushClass *klass);
static void gimp_preview_renderer_brush_init (GimpPreviewRendererBrush *renderer);
static void gimp_preview_renderer_brush_finalize (GObject *object);
static void gimp_preview_renderer_brush_render (GimpViewRenderer *renderer,
GtkWidget *widget);
static gboolean gimp_preview_renderer_brush_render_timeout (gpointer data);
static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_brush_get_type (void)
{
static GType renderer_type = 0;
if (! renderer_type)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererBrushClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_brush_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererBrush),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_brush_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererBrush",
&renderer_info, 0);
}
return renderer_type;
}
static void
gimp_preview_renderer_brush_class_init (GimpPreviewRendererBrushClass *klass)
{
GObjectClass *object_class;
GimpViewRendererClass *renderer_class;
object_class = G_OBJECT_CLASS (klass);
renderer_class = GIMP_VIEW_RENDERER_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_preview_renderer_brush_finalize;
renderer_class->render = gimp_preview_renderer_brush_render;
}
static void
gimp_preview_renderer_brush_init (GimpPreviewRendererBrush *renderer)
{
renderer->pipe_timeout_id = 0;
renderer->pipe_animation_index = 0;
}
static void
gimp_preview_renderer_brush_finalize (GObject *object)
{
GimpPreviewRendererBrush *renderer = GIMP_PREVIEW_RENDERER_BRUSH (object);
if (renderer->pipe_timeout_id)
{
g_source_remove (renderer->pipe_timeout_id);
renderer->pipe_timeout_id = 0;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_preview_renderer_brush_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpPreviewRendererBrush *renderbrush;
GimpBrush *brush;
TempBuf *temp_buf;
gint brush_width;
gint brush_height;
renderbrush = GIMP_PREVIEW_RENDERER_BRUSH (renderer);
if (renderbrush->pipe_timeout_id)
{
g_source_remove (renderbrush->pipe_timeout_id);
renderbrush->pipe_timeout_id = 0;
}
brush = GIMP_BRUSH (renderer->viewable);
brush_width = brush->mask->width;
brush_height = brush->mask->height;
temp_buf = gimp_viewable_get_new_preview (renderer->viewable,
renderer->width,
renderer->height);
if (temp_buf->width < renderer->width)
temp_buf->x = (renderer->width - temp_buf->width) / 2;
if (temp_buf->height < renderer->height)
temp_buf->y = (renderer->height - temp_buf->height) / 2;
if (renderer->is_popup)
{
gimp_view_renderer_render_buffer (renderer, temp_buf, -1,
GIMP_VIEW_BG_WHITE,
GIMP_VIEW_BG_WHITE);
temp_buf_free (temp_buf);
if (GIMP_IS_BRUSH_PIPE (brush))
{
renderbrush->pipe_animation_index = 0;
renderbrush->pipe_timeout_id =
g_timeout_add (300, gimp_preview_renderer_brush_render_timeout,
renderbrush);
}
return;
}
gimp_view_renderer_render_buffer (renderer, temp_buf, -1,
GIMP_VIEW_BG_WHITE,
GIMP_VIEW_BG_WHITE);
temp_buf_free (temp_buf);
#define INDICATOR_WIDTH 7
#define INDICATOR_HEIGHT 7
if (renderer->width >= INDICATOR_WIDTH * 2 &&
renderer->height >= INDICATOR_HEIGHT * 2&&
(renderer->width < brush_width ||
renderer->height < brush_height ||
GIMP_IS_BRUSH_PIPE (brush)))
{
#define WHT { 255, 255, 255 }
#define BLK { 0, 0, 0 }
#define RED { 255, 127, 127 }
static const guchar scale_indicator_bits[7][7][3] =
{
{ WHT, WHT, WHT, WHT, WHT, WHT, WHT },
{ WHT, WHT, WHT, BLK, WHT, WHT, WHT },
{ WHT, WHT, WHT, BLK, WHT, WHT, WHT },
{ WHT, BLK, BLK, BLK, BLK, BLK, WHT },
{ WHT, WHT, WHT, BLK, WHT, WHT, WHT },
{ WHT, WHT, WHT, BLK, WHT, WHT, WHT },
{ WHT, WHT, WHT, WHT, WHT, WHT, WHT }
};
static const guchar scale_pipe_indicator_bits[7][7][3] =
{
{ WHT, WHT, WHT, WHT, WHT, WHT, WHT },
{ WHT, WHT, WHT, BLK, WHT, WHT, RED },
{ WHT, WHT, WHT, BLK, WHT, RED, RED },
{ WHT, BLK, BLK, BLK, BLK, BLK, RED },
{ WHT, WHT, WHT, BLK, RED, RED, RED },
{ WHT, WHT, RED, BLK, RED, RED, RED },
{ WHT, RED, RED, RED, RED, RED, RED }
};
static const guchar pipe_indicator_bits[7][7][3] =
{
{ WHT, WHT, WHT, WHT, WHT, WHT, WHT },
{ WHT, WHT, WHT, WHT, WHT, WHT, RED },
{ WHT, WHT, WHT, WHT, WHT, RED, RED },
{ WHT, WHT, WHT, WHT, RED, RED, RED },
{ WHT, WHT, WHT, RED, RED, RED, RED },
{ WHT, WHT, RED, RED, RED, RED, RED },
{ WHT, RED, RED, RED, RED, RED, RED }
};
#undef WHT
#undef BLK
#undef RED
guchar *buf;
guchar *b;
gint x, y;
gint offset_x;
gint offset_y;
gboolean alpha;
gboolean pipe;
gboolean scale;
offset_x = renderer->width - INDICATOR_WIDTH;
offset_y = renderer->height - INDICATOR_HEIGHT;
buf = renderer->buffer + (offset_y * renderer->rowstride +
offset_x * renderer->bytes);
pipe = GIMP_IS_BRUSH_PIPE (brush);
scale = (renderer->width < brush_width ||
renderer->height < brush_height);
alpha = (renderer->bytes == 4);
for (y = 0; y < INDICATOR_HEIGHT; y++)
{
b = buf;
for (x = 0; x < INDICATOR_WIDTH; x++)
{
if (scale)
{
if (pipe)
{
*b++ = scale_pipe_indicator_bits[y][x][0];
*b++ = scale_pipe_indicator_bits[y][x][1];
*b++ = scale_pipe_indicator_bits[y][x][2];
}
else
{
*b++ = scale_indicator_bits[y][x][0];
*b++ = scale_indicator_bits[y][x][1];
*b++ = scale_indicator_bits[y][x][2];
}
}
else if (pipe)
{
*b++ = pipe_indicator_bits[y][x][0];
*b++ = pipe_indicator_bits[y][x][1];
*b++ = pipe_indicator_bits[y][x][2];
}
if (alpha)
*b++ = 255;
}
buf += renderer->rowstride;
}
}
#undef INDICATOR_WIDTH
#undef INDICATOR_HEIGHT
}
static gboolean
gimp_preview_renderer_brush_render_timeout (gpointer data)
{
GimpPreviewRendererBrush *renderbrush;
GimpViewRenderer *renderer;
GimpBrushPipe *brush_pipe;
GimpBrush *brush;
TempBuf *temp_buf;
renderbrush = GIMP_PREVIEW_RENDERER_BRUSH (data);
renderer = GIMP_VIEW_RENDERER (data);
if (! renderer->viewable)
{
renderbrush->pipe_timeout_id = 0;
renderbrush->pipe_animation_index = 0;
return FALSE;
}
brush_pipe = GIMP_BRUSH_PIPE (renderer->viewable);
renderbrush->pipe_animation_index++;
if (renderbrush->pipe_animation_index >= brush_pipe->nbrushes)
renderbrush->pipe_animation_index = 0;
brush =
GIMP_BRUSH (brush_pipe->brushes[renderbrush->pipe_animation_index]);
temp_buf = gimp_viewable_get_new_preview (GIMP_VIEWABLE (brush),
renderer->width,
renderer->height);
gimp_view_renderer_render_buffer (renderer, temp_buf, -1,
GIMP_VIEW_BG_WHITE,
GIMP_VIEW_BG_WHITE);
temp_buf_free (temp_buf);
gimp_view_renderer_update (renderer);
return TRUE;
}

54
app/widgets/gimppreviewrendererbrush.h
View File

@ -1,54 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererbrush.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_PREVIEW_RENDERER_BRUSH_H__
#define __GIMP_PREVIEW_RENDERER_BRUSH_H__
#include "gimpviewrenderer.h"
#define GIMP_TYPE_PREVIEW_RENDERER_BRUSH (gimp_preview_renderer_brush_get_type ())
#define GIMP_PREVIEW_RENDERER_BRUSH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_BRUSH, GimpPreviewRendererBrush))
#define GIMP_PREVIEW_RENDERER_BRUSH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_BRUSH, GimpPreviewRendererBrushClass))
#define GIMP_IS_PREVIEW_RENDERER_BRUSH(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_BRUSH))
#define GIMP_IS_PREVIEW_RENDERER_BRUSH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_BRUSH))
#define GIMP_PREVIEW_RENDERER_BRUSH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_BRUSH, GimpPreviewRendererBrushClass))
typedef struct _GimpPreviewRendererBrushClass GimpPreviewRendererBrushClass;
struct _GimpPreviewRendererBrush
{
GimpViewRenderer parent_instance;
guint pipe_timeout_id;
gint pipe_animation_index;
};
struct _GimpPreviewRendererBrushClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_brush_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_BRUSH_H__ */

205
app/widgets/gimppreviewrendererdrawable.c
View File

@ -1,205 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererdrawable.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 <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "widgets-types.h"
#include "base/temp-buf.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
#include "gimppreviewrendererdrawable.h"
static void gimp_preview_renderer_drawable_class_init (GimpPreviewRendererDrawableClass *klass);
static void gimp_preview_renderer_drawable_init (GimpPreviewRendererDrawable *renderer);
static void gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
GtkWidget *widget);
static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_drawable_get_type (void)
{
static GType renderer_type = 0;
if (! renderer_type)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererDrawableClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_drawable_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererDrawable),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_drawable_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererDrawable",
&renderer_info, 0);
}
return renderer_type;
}
static void
gimp_preview_renderer_drawable_class_init (GimpPreviewRendererDrawableClass *klass)
{
GimpViewRendererClass *renderer_class;
renderer_class = GIMP_VIEW_RENDERER_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
renderer_class->render = gimp_preview_renderer_drawable_render;
}
static void
gimp_preview_renderer_drawable_init (GimpPreviewRendererDrawable *renderer)
{
}
static void
gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpDrawable *drawable;
GimpItem *item;
GimpImage *gimage;
gint width;
gint height;
gint preview_width;
gint preview_height;
gboolean scaling_up;
TempBuf *render_buf = NULL;
drawable = GIMP_DRAWABLE (renderer->viewable);
item = GIMP_ITEM (drawable);
gimage = gimp_item_get_image (item);
width = renderer->width;
height = renderer->height;
if (gimage && ! renderer->is_popup)
{
width = MAX (1, ROUND ((((gdouble) width / (gdouble) gimage->width) *
(gdouble) item->width)));
height = MAX (1, ROUND ((((gdouble) height / (gdouble) gimage->height) *
(gdouble) item->height)));
gimp_viewable_calc_preview_size (item->width,
item->height,
width,
height,
renderer->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
}
else
{
gimp_viewable_calc_preview_size (item->width,
item->height,
width,
height,
renderer->dot_for_dot,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&preview_width,
&preview_height,
&scaling_up);
}
if (scaling_up)
{
TempBuf *temp_buf;
temp_buf = gimp_viewable_get_new_preview (renderer->viewable,
item->width,
item->height);
if (temp_buf)
{
render_buf = temp_buf_scale (temp_buf, preview_width, preview_height);
temp_buf_free (temp_buf);
}
}
else
{
render_buf = gimp_viewable_get_new_preview (renderer->viewable,
preview_width,
preview_height);
}
if (render_buf)
{
if (gimage && ! renderer->is_popup)
{
if (item->offset_x != 0)
render_buf->x =
ROUND ((((gdouble) renderer->width / (gdouble) gimage->width) *
(gdouble) item->offset_x));
if (item->offset_y != 0)
render_buf->y =
ROUND ((((gdouble) renderer->height / (gdouble) gimage->height) *
(gdouble) item->offset_y));
}
else
{
if (preview_width < width)
render_buf->x = (width - preview_width) / 2;
if (preview_height < height)
render_buf->y = (height - preview_height) / 2;
}
gimp_view_renderer_render_buffer (renderer, render_buf, -1,
GIMP_VIEW_BG_CHECKS,
GIMP_VIEW_BG_CHECKS);
temp_buf_free (render_buf);
}
else
{
const gchar *stock_id;
stock_id = gimp_viewable_get_stock_id (renderer->viewable);
gimp_view_renderer_default_render_stock (renderer, widget, stock_id);
}
}

51
app/widgets/gimppreviewrendererdrawable.h
View File

@ -1,51 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererdrawable.h
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PREVIEW_RENDERER_DRAWABLE_H__
#define __GIMP_PREVIEW_RENDERER_DRAWABLE_H__
#include "gimpviewrenderer.h"
#define GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE (gimp_preview_renderer_drawable_get_type ())
#define GIMP_PREVIEW_RENDERER_DRAWABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE, GimpPreviewRendererDrawable))
#define GIMP_PREVIEW_RENDERER_DRAWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE, GimpPreviewRendererDrawableClass))
#define GIMP_IS_PREVIEW_RENDERER_DRAWABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE))
#define GIMP_IS_PREVIEW_RENDERER_DRAWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE))
#define GIMP_PREVIEW_RENDERER_DRAWABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE, GimpPreviewRendererDrawableClass))
typedef struct _GimpPreviewRendererDrawableClass GimpPreviewRendererDrawableClass;
struct _GimpPreviewRendererDrawable
{
GimpViewRenderer parent_instance;
};
struct _GimpPreviewRendererDrawableClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_drawable_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_DRAWABLE_H__ */

260
app/widgets/gimppreviewrenderergradient.c
View File

@ -1,260 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderergradient.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 <string.h>
#include <gtk/gtk.h>
#include "libgimpcolor/gimpcolor.h"
#include "libgimpmath/gimpmath.h"
#include "widgets-types.h"
#ifdef __GNUC__
#warning FIXME #include "display/display-types.h"
#endif
#include "display/display-types.h"
#include "core/gimpgradient.h"
#include "display/gimpdisplayshell-render.h"
#include "gimppreviewrenderergradient.h"
static void gimp_preview_renderer_gradient_class_init (GimpPreviewRendererGradientClass *klass);
static void gimp_preview_renderer_gradient_init (GimpPreviewRendererGradient *renderer);
static void gimp_preview_renderer_gradient_finalize (GObject *object);
static void gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer,
GtkWidget *widget);
static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_gradient_get_type (void)
{
static GType renderer_type = 0;
if (! renderer_type)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererGradientClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_gradient_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererGradient),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_gradient_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererGradient",
&renderer_info, 0);
}
return renderer_type;
}
static void
gimp_preview_renderer_gradient_class_init (GimpPreviewRendererGradientClass *klass)
{
GObjectClass *object_class;
GimpViewRendererClass *renderer_class;
object_class = G_OBJECT_CLASS (klass);
renderer_class = GIMP_VIEW_RENDERER_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_preview_renderer_gradient_finalize;
renderer_class->render = gimp_preview_renderer_gradient_render;
}
static void
gimp_preview_renderer_gradient_init (GimpPreviewRendererGradient *renderer)
{
renderer->even = NULL;
renderer->odd = NULL;
renderer->width = -1;
renderer->left = 0.0;
renderer->right = 1.0;
renderer->reverse = FALSE;
}
static void
gimp_preview_renderer_gradient_finalize (GObject *object)
{
GimpPreviewRendererGradient *renderer;
renderer = GIMP_PREVIEW_RENDERER_GRADIENT (object);
if (renderer->even)
{
g_free (renderer->even);
renderer->even = NULL;
}
if (renderer->odd)
{
g_free (renderer->odd);
renderer->odd = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpPreviewRendererGradient *rendergrad;
GimpGradient *gradient;
guchar *even;
guchar *odd;
guchar *buf;
gint x;
gint y;
gint a;
gdouble dx, cur_x;
GimpRGB color;
rendergrad = GIMP_PREVIEW_RENDERER_GRADIENT (renderer);
gradient = GIMP_GRADIENT (renderer->viewable);
if (renderer->width != rendergrad->width)
{
if (rendergrad->even)
g_free (rendergrad->even);
if (rendergrad->odd)
g_free (rendergrad->odd);
rendergrad->even = g_new (guchar, renderer->rowstride);
rendergrad->odd = g_new (guchar, renderer->rowstride);
rendergrad->width = renderer->width;
}
even = rendergrad->even;
odd = rendergrad->odd;
dx = (rendergrad->right - rendergrad->left) / (renderer->width - 1);
cur_x = rendergrad->left;
for (x = 0; x < renderer->width; x++)
{
guchar r, g, b;
gimp_gradient_get_color_at (gradient, cur_x, rendergrad->reverse, &color);
cur_x += dx;
a = ((gint) (color.a * 255.0)) << 8;
gimp_rgb_get_uchar (&color, &r, &g, &b);
if (x & 0x4)
{
*even++ = render_blend_dark_check[a | r];
*even++ = render_blend_dark_check[a | g];
*even++ = render_blend_dark_check[a | b];
*odd++ = render_blend_light_check[a | r];
*odd++ = render_blend_light_check[a | g];
*odd++ = render_blend_light_check[a | b];
}
else
{
*even++ = render_blend_light_check[a | r];
*even++ = render_blend_light_check[a | g];
*even++ = render_blend_light_check[a | b];
*odd++ = render_blend_dark_check[a | r];
*odd++ = render_blend_dark_check[a | g];
*odd++ = render_blend_dark_check[a | b];
}
}
if (! renderer->buffer)
renderer->buffer = g_new (guchar, renderer->height * renderer->rowstride);
buf = renderer->buffer;
for (y = 0; y < renderer->height; y++)
{
if (y & 0x4)
memcpy (buf, rendergrad->even, renderer->rowstride);
else
memcpy (buf, rendergrad->odd, renderer->rowstride);
buf += renderer->rowstride;
}
renderer->needs_render = FALSE;
}
void
gimp_preview_renderer_gradient_set_offsets (GimpPreviewRendererGradient *renderer,
gdouble left,
gdouble right,
gboolean instant_update)
{
g_return_if_fail (GIMP_IS_PREVIEW_RENDERER_GRADIENT (renderer));
left = CLAMP (left, 0.0, 1.0);
right = CLAMP (right, left, 1.0);
if (left != renderer->left || right != renderer->right)
{
renderer->left = left;
renderer->right = right;
gimp_view_renderer_invalidate (GIMP_VIEW_RENDERER (renderer));
if (instant_update)
gimp_view_renderer_update (GIMP_VIEW_RENDERER (renderer));
}
}
void
gimp_preview_renderer_gradient_set_reverse (GimpPreviewRendererGradient *renderer,
gboolean reverse)
{
g_return_if_fail (GIMP_IS_PREVIEW_RENDERER_GRADIENT (renderer));
if (reverse != renderer->reverse)
{
renderer->reverse = reverse ? TRUE : FALSE;
gimp_view_renderer_invalidate (GIMP_VIEW_RENDERER (renderer));
gimp_view_renderer_update (GIMP_VIEW_RENDERER (renderer));
}
}

66
app/widgets/gimppreviewrenderergradient.h
View File

@ -1,66 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderergradient.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_PREVIEW_RENDERER_GRADIENT_H__
#define __GIMP_PREVIEW_RENDERER_GRADIENT_H__
#include "gimpviewrenderer.h"
#define GIMP_TYPE_PREVIEW_RENDERER_GRADIENT (gimp_preview_renderer_gradient_get_type ())
#define GIMP_PREVIEW_RENDERER_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_GRADIENT, GimpPreviewRendererGradient))
#define GIMP_PREVIEW_RENDERER_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_GRADIENT, GimpPreviewRendererGradientClass))
#define GIMP_IS_PREVIEW_RENDERER_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_GRADIENT))
#define GIMP_IS_PREVIEW_RENDERER_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_GRADIENT))
#define GIMP_PREVIEW_RENDERER_GRADIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_GRADIENT, GimpPreviewRendererGradientClass))
typedef struct _GimpPreviewRendererGradientClass GimpPreviewRendererGradientClass;
struct _GimpPreviewRendererGradient
{
GimpViewRenderer parent_instance;
guchar *even;
guchar *odd;
gint width;
gdouble left;
gdouble right;
gboolean reverse;
};
struct _GimpPreviewRendererGradientClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_gradient_get_type (void) G_GNUC_CONST;
void gimp_preview_renderer_gradient_set_offsets (GimpPreviewRendererGradient *renderer,
gdouble left,
gdouble right,
gboolean instant_update);
void gimp_preview_renderer_gradient_set_reverse (GimpPreviewRendererGradient *renderer,
gboolean reverse);
#endif /* __GIMP_PREVIEW_RENDERER_GRADIENT_H__ */

194
app/widgets/gimppreviewrendererimage.c
View File

@ -1,194 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererimage.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 <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "base/temp-buf.h"
#include "core/gimpimage.h"
#include "gimppreviewrendererimage.h"
static void gimp_preview_renderer_image_class_init (GimpPreviewRendererImageClass *klass);
static void gimp_preview_renderer_image_init (GimpPreviewRendererImage *renderer);
static void gimp_preview_renderer_image_render (GimpViewRenderer *renderer,
GtkWidget *widget);
static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_image_get_type (void)
{
static GType renderer_type = 0;
if (! renderer_type)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererImageClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_image_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererImage),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_image_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererImage",
&renderer_info, 0);
}
return renderer_type;
}
static void
gimp_preview_renderer_image_class_init (GimpPreviewRendererImageClass *klass)
{
GimpViewRendererClass *renderer_class;
renderer_class = GIMP_VIEW_RENDERER_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
renderer_class->render = gimp_preview_renderer_image_render;
}
static void
gimp_preview_renderer_image_init (GimpPreviewRendererImage *renderer)
{
renderer->channel = -1;
}
static void
gimp_preview_renderer_image_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpPreviewRendererImage *rendererimage;
GimpImage *gimage;
gint preview_width;
gint preview_height;
gboolean scaling_up;
TempBuf *render_buf = NULL;
rendererimage = GIMP_PREVIEW_RENDERER_IMAGE (renderer);
gimage = GIMP_IMAGE (renderer->viewable);
gimp_viewable_calc_preview_size (gimage->width,
gimage->height,
renderer->width,
renderer->height,
renderer->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&scaling_up);
if (scaling_up)
{
TempBuf *temp_buf;
temp_buf = gimp_viewable_get_new_preview (renderer->viewable,
gimage->width, gimage->height);
if (temp_buf)
{
render_buf = temp_buf_scale (temp_buf,
preview_width, preview_height);
temp_buf_free (temp_buf);
}
}
else
{
render_buf = gimp_viewable_get_new_preview (renderer->viewable,
preview_width,
preview_height);
}
if (render_buf)
{
gint component_index = -1;
/* xresolution != yresolution */
if (preview_width > renderer->width || preview_height > renderer->height)
{
TempBuf *temp_buf;
temp_buf = temp_buf_scale (render_buf,
renderer->width, renderer->height);
temp_buf_free (render_buf);
render_buf = temp_buf;
}
if (preview_width < renderer->width)
render_buf->x = (renderer->width - preview_width) / 2;
if (preview_height < renderer->height)
render_buf->y = (renderer->height - preview_height) / 2;
if (rendererimage->channel != -1)
component_index =
gimp_image_get_component_index (gimage, rendererimage->channel);
gimp_view_renderer_render_buffer (renderer, render_buf,
component_index,
GIMP_VIEW_BG_CHECKS,
GIMP_VIEW_BG_WHITE);
temp_buf_free (render_buf);
}
else
{
const gchar *stock_id;
switch (rendererimage->channel)
{
case GIMP_RED_CHANNEL: stock_id = GIMP_STOCK_CHANNEL_RED; break;
case GIMP_GREEN_CHANNEL: stock_id = GIMP_STOCK_CHANNEL_GREEN; break;
case GIMP_BLUE_CHANNEL: stock_id = GIMP_STOCK_CHANNEL_BLUE; break;
case GIMP_GRAY_CHANNEL: stock_id = GIMP_STOCK_CHANNEL_GRAY; break;
case GIMP_INDEXED_CHANNEL: stock_id = GIMP_STOCK_CHANNEL_INDEXED; break;
case GIMP_ALPHA_CHANNEL: stock_id = GIMP_STOCK_CHANNEL_ALPHA; break;
default:
stock_id = gimp_viewable_get_stock_id (renderer->viewable);
break;
}
gimp_view_renderer_default_render_stock (renderer, widget, stock_id);
}
}

53
app/widgets/gimppreviewrendererimage.h
View File

@ -1,53 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererimage.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_PREVIEW_RENDERER_IMAGE_H__
#define __GIMP_PREVIEW_RENDERER_IMAGE_H__
#include "gimpviewrenderer.h"
#define GIMP_TYPE_PREVIEW_RENDERER_IMAGE (gimp_preview_renderer_image_get_type ())
#define GIMP_PREVIEW_RENDERER_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_IMAGE, GimpPreviewRendererImage))
#define GIMP_PREVIEW_RENDERER_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_IMAGE, GimpPreviewRendererImageClass))
#define GIMP_IS_PREVIEW_RENDERER_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_IMAGE))
#define GIMP_IS_PREVIEW_RENDERER_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_IMAGE))
#define GIMP_PREVIEW_RENDERER_IMAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_IMAGE, GimpPreviewRendererImageClass))
typedef struct _GimpPreviewRendererImageClass GimpPreviewRendererImageClass;
struct _GimpPreviewRendererImage
{
GimpViewRenderer parent_instance;
GimpChannelType channel;
};
struct _GimpPreviewRendererImageClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_image_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_IMAGE_H__ */

191
app/widgets/gimppreviewrendererimagefile.c
View File

@ -1,191 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererimagefile.c
* Copyright (C) 2004 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 <string.h>
#include <gtk/gtk.h>
#include "libgimpthumb/gimpthumb.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "base/temp-buf.h"
#include "core/gimpimagefile.h"
#include "gimppreviewrendererimagefile.h"
#ifdef ENABLE_FILE_SYSTEM_ICONS
#define GTK_FILE_SYSTEM_ENABLE_UNSUPPORTED
#include <gtk/gtkfilesystem.h>
#endif
static void gimp_preview_renderer_imagefile_class_init (GimpPreviewRendererImagefileClass *klass);
static void gimp_preview_renderer_imagefile_init (GimpPreviewRendererImagefile *renderer);
static void gimp_preview_renderer_imagefile_render (GimpViewRenderer *renderer,
GtkWidget *widget);
static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_imagefile_get_type (void)
{
static GType renderer_type = 0;
if (! renderer_type)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererImagefileClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_imagefile_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererImagefile),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_imagefile_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererImagefile",
&renderer_info, 0);
}
return renderer_type;
}
static void
gimp_preview_renderer_imagefile_class_init (GimpPreviewRendererImagefileClass *klass)
{
GimpViewRendererClass *renderer_class;
renderer_class = GIMP_VIEW_RENDERER_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
renderer_class->render = gimp_preview_renderer_imagefile_render;
}
static void
gimp_preview_renderer_imagefile_init (GimpPreviewRendererImagefile *renderer)
{
#ifdef ENABLE_FILE_SYSTEM_ICONS
renderer->file_system = NULL;
#endif
}
static void
gimp_preview_renderer_imagefile_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
TempBuf *temp_buf = gimp_viewable_get_preview (renderer->viewable,
renderer->width,
renderer->height);
if (temp_buf)
{
gimp_view_renderer_default_render_buffer (renderer, widget, temp_buf);
}
else
{
GdkPixbuf *pixbuf = NULL;
#ifdef ENABLE_FILE_SYSTEM_ICONS
if (GIMP_PREVIEW_RENDERER_IMAGEFILE (renderer)->file_system)
{
GtkFileSystem *file_system;
const gchar *uri;
file_system = GIMP_PREVIEW_RENDERER_IMAGEFILE (renderer)->file_system;
uri = gimp_object_get_name (GIMP_OBJECT (renderer->viewable));
if (uri)
{
GtkFilePath *path;
path = gtk_file_system_uri_to_path (file_system, uri);
pixbuf = gtk_file_system_render_icon (file_system, path, widget,
MIN (renderer->width,
renderer->height),
NULL);
gtk_file_path_free (path);
}
}
#endif /* ENABLE_FILE_SYSTEM_ICONS */
if (pixbuf)
{
gint width;
gint height;
gint bytes;
guchar *src;
guchar *dest;
gint y;
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
bytes = gdk_pixbuf_get_n_channels (pixbuf);
temp_buf = temp_buf_new (width, height, bytes, 0, 0, NULL);
dest = temp_buf_data (temp_buf);
src = gdk_pixbuf_get_pixels (pixbuf);
for (y = 0; y < height; y++)
{
memcpy (dest, src, width * bytes);
dest += width * bytes;
src += gdk_pixbuf_get_rowstride (pixbuf);
}
if (temp_buf->width < renderer->width)
temp_buf->x = (renderer->width - temp_buf->width) / 2;
if (temp_buf->height < renderer->height)
temp_buf->y = (renderer->height - temp_buf->height) / 2;
gimp_view_renderer_render_buffer (renderer, temp_buf, -1,
GIMP_VIEW_BG_WHITE,
GIMP_VIEW_BG_WHITE);
temp_buf_free (temp_buf);
g_object_unref (pixbuf);
}
else
{
const gchar *stock_id;
stock_id = gimp_viewable_get_stock_id (renderer->viewable);
gimp_view_renderer_default_render_stock (renderer, widget,
stock_id);
}
}
}

59
app/widgets/gimppreviewrendererimagefile.h
View File

@ -1,59 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererimagefile.h
* Copyright (C) 2004 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_PREVIEW_RENDERER_IMAGEFILE_H__
#define __GIMP_PREVIEW_RENDERER_IMAGEFILE_H__
#include "gimpviewrenderer.h"
/* #define ENABLE_FILE_SYSTEM_ICONS 1 */
#define GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE (gimp_preview_renderer_imagefile_get_type ())
#define GIMP_PREVIEW_RENDERER_IMAGEFILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE, GimpPreviewRendererImagefile))
#define GIMP_PREVIEW_RENDERER_IMAGEFILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE, GimpPreviewRendererImagefileClass))
#define GIMP_IS_PREVIEW_RENDERER_IMAGEFILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE))
#define GIMP_IS_PREVIEW_RENDERER_IMAGEFILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE))
#define GIMP_PREVIEW_RENDERER_IMAGEFILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE, GimpPreviewRendererImagefileClass))
typedef struct _GimpPreviewRendererImagefileClass GimpPreviewRendererImagefileClass;
struct _GimpPreviewRendererImagefile
{
GimpViewRenderer parent_instance;
#ifdef ENABLE_FILE_SYSTEM_ICONS
gpointer file_system;
#endif
};
struct _GimpPreviewRendererImagefileClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_imagefile_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_IMAGEFILE_H__ */

103
app/widgets/gimppreviewrendererlayer.c
View File

@ -1,103 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererlayer.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 <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "text/gimptextlayer.h"
#include "gimppreviewrendererlayer.h"
static void gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass);
static void gimp_preview_renderer_layer_render (GimpViewRenderer *renderer,
GtkWidget *widget);
static GimpPreviewRendererDrawableClass *parent_class = NULL;
GType
gimp_preview_renderer_layer_get_type (void)
{
static GType renderer_type = 0;
if (! renderer_type)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererLayerClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_layer_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererLayer),
0, /* n_preallocs */
NULL, /* instance_init */
};
renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE,
"GimpPreviewRendererLayer",
&renderer_info, 0);
}
return renderer_type;
}
static void
gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass)
{
GimpViewRendererClass *renderer_class;
renderer_class = GIMP_VIEW_RENDERER_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
renderer_class->render = gimp_preview_renderer_layer_render;
}
static void
gimp_preview_renderer_layer_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
const gchar *stock_id = NULL;
if (gimp_layer_is_floating_sel (GIMP_LAYER (renderer->viewable)))
{
stock_id = GIMP_STOCK_FLOATING_SELECTION;
}
else if (gimp_drawable_is_text_layer (GIMP_DRAWABLE (renderer->viewable)))
{
stock_id = gimp_viewable_get_stock_id (renderer->viewable);
}
if (stock_id)
gimp_view_renderer_default_render_stock (renderer, widget, stock_id);
else
GIMP_VIEW_RENDERER_CLASS (parent_class)->render (renderer, widget);
}

51
app/widgets/gimppreviewrendererlayer.h
View File

@ -1,51 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererlayer.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_PREVIEW_RENDERER_LAYER_H__
#define __GIMP_PREVIEW_RENDERER_LAYER_H__
#include "gimppreviewrendererdrawable.h"
#define GIMP_TYPE_PREVIEW_RENDERER_LAYER (gimp_preview_renderer_layer_get_type ())
#define GIMP_PREVIEW_RENDERER_LAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_LAYER, GimpPreviewRendererLayer))
#define GIMP_PREVIEW_RENDERER_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_LAYER, GimpPreviewRendererLayerClass))
#define GIMP_IS_PREVIEW_RENDERER_LAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_LAYER))
#define GIMP_IS_PREVIEW_RENDERER_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_LAYER))
#define GIMP_PREVIEW_RENDERER_LAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_LAYER, GimpPreviewRendererLayerClass))
typedef struct _GimpPreviewRendererLayerClass GimpPreviewRendererLayerClass;
struct _GimpPreviewRendererLayer
{
GimpPreviewRendererDrawable parent_instance;
};
struct _GimpPreviewRendererLayerClass
{
GimpPreviewRendererDrawableClass parent_class;
};
GType gimp_preview_renderer_layer_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_LAYER_H__ */

160
app/widgets/gimppreviewrenderervectors.c
View File

@ -1,160 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderervectors.c
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
* Simon Budig <simon@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "core/gimpimage.h"
#include "core/gimpitem.h"
#include "vectors/gimpstroke.h"
#include "vectors/gimpvectors.h"
#include "gimppreviewrenderervectors.h"
static void gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass);
static void gimp_preview_renderer_vectors_draw (GimpViewRenderer *renderer,
GdkWindow *window,
GtkWidget *widget,
const GdkRectangle *draw_area,
const GdkRectangle *expose_area);
static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_vectors_get_type (void)
{
static GType renderer_type = 0;
if (! renderer_type)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererVectorsClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_vectors_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererVectors),
0, /* n_preallocs */
NULL, /* instance_init */
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererVectors",
&renderer_info, 0);
}
return renderer_type;
}
static void
gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass)
{
GimpViewRendererClass *renderer_class;
renderer_class = GIMP_VIEW_RENDERER_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
renderer_class->draw = gimp_preview_renderer_vectors_draw;
}
static void
gimp_preview_renderer_vectors_draw (GimpViewRenderer *renderer,
GdkWindow *window,
GtkWidget *widget,
const GdkRectangle *draw_area,
const GdkRectangle *expose_area)
{
GimpVectors *vectors;
GimpStroke *stroke;
GdkRectangle rect, area;
gdouble xscale, yscale;
rect.width = renderer->width;
rect.height = renderer->height;
rect.x = draw_area->x + (draw_area->width - rect.width) / 2;
rect.y = draw_area->y + (draw_area->height - rect.height) / 2;
if (! gdk_rectangle_intersect (&rect, (GdkRectangle *) expose_area, &area))
return;
gdk_draw_rectangle (window, widget->style->white_gc, TRUE,
area.x, area.y, area.width, area.height);
vectors = GIMP_VECTORS (renderer->viewable);
xscale = (gdouble) GIMP_ITEM (vectors)->width / (gdouble) rect.width;
yscale = (gdouble) GIMP_ITEM (vectors)->height / (gdouble) rect.height;
gdk_gc_set_clip_rectangle (widget->style->black_gc, &area);
for (stroke = gimp_vectors_stroke_get_next (vectors, NULL);
stroke != NULL;
stroke = gimp_vectors_stroke_get_next (vectors, stroke))
{
GArray *coordinates;
GdkPoint *points;
gint i;
coordinates = gimp_stroke_interpolate (stroke,
MIN (xscale, yscale) / 2,
NULL);
if (!coordinates)
continue;
if (coordinates->len > 0)
{
points = g_new (GdkPoint, coordinates->len);
for (i = 0; i < coordinates->len; i++)
{
GimpCoords *coords;
coords = &(g_array_index (coordinates, GimpCoords, i));
points[i].x = rect.x + ROUND (coords->x / xscale);
points[i].y = rect.y + ROUND (coords->y / yscale);
}
gdk_draw_lines (window, widget->style->black_gc,
points, coordinates->len);
g_free (points);
}
g_array_free (coordinates, TRUE);
}
gdk_gc_set_clip_rectangle (widget->style->black_gc, NULL);
}

52
app/widgets/gimppreviewrenderervectors.h
View File

@ -1,52 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderervectors.h
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
* Simon Budig <simon@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_PREVIEW_RENDERER_VECTORS_H__
#define __GIMP_PREVIEW_RENDERER_VECTORS_H__
#include "gimppreviewrendererdrawable.h"
#define GIMP_TYPE_PREVIEW_RENDERER_VECTORS (gimp_preview_renderer_vectors_get_type ())
#define GIMP_PREVIEW_RENDERER_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_VECTORS, GimpPreviewRendererVectors))
#define GIMP_PREVIEW_RENDERER_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_VECTORS, GimpPreviewRendererVectorsClass))
#define GIMP_IS_PREVIEW_RENDERER_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_VECTORS))
#define GIMP_IS_PREVIEW_RENDERER_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_VECTORS))
#define GIMP_PREVIEW_RENDERER_VECTORS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_VECTORS, GimpPreviewRendererVectorsClass))
typedef struct _GimpPreviewRendererVectorsClass GimpPreviewRendererVectorsClass;
struct _GimpPreviewRendererVectors
{
GimpPreviewRendererDrawable parent_instance;
};
struct _GimpPreviewRendererVectorsClass
{
GimpPreviewRendererDrawableClass parent_class;
};
GType gimp_preview_renderer_vectors_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_VECTORS_H__ */

2
app/widgets/gimpview.c
View File

@ -39,7 +39,7 @@
#include "gimpview.h"
#include "gimpview-popup.h"
#include "gimpviewrenderer.h"
#include "gimppreviewrenderer-utils.h"
#include "gimpviewrenderer-utils.h"
#define VIEW_EVENT_MASK (GDK_BUTTON_PRESS_MASK | \

30
app/widgets/gimpviewrenderer-utils.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderer-utils.c
* gimpviewrenderer-utils.c
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -33,16 +33,16 @@
#include "core/gimpimagefile.h"
#include "vectors/gimpvectors.h"
#include "gimppreviewrendererbrush.h"
#include "gimppreviewrendererlayer.h"
#include "gimppreviewrenderergradient.h"
#include "gimppreviewrendererimage.h"
#include "gimppreviewrendererimagefile.h"
#include "gimppreviewrenderervectors.h"
#include "gimpviewrendererbrush.h"
#include "gimpviewrendererlayer.h"
#include "gimpviewrenderergradient.h"
#include "gimpviewrendererimage.h"
#include "gimpviewrendererimagefile.h"
#include "gimpviewrenderervectors.h"
GType
gimp_preview_renderer_type_from_viewable_type (GType viewable_type)
gimp_view_renderer_type_from_viewable_type (GType viewable_type)
{
GType type = GIMP_TYPE_VIEW_RENDERER;
@ -51,31 +51,31 @@ gimp_preview_renderer_type_from_viewable_type (GType viewable_type)
if (g_type_is_a (viewable_type, GIMP_TYPE_BRUSH))
{
type = GIMP_TYPE_PREVIEW_RENDERER_BRUSH;
type = GIMP_TYPE_VIEW_RENDERER_BRUSH;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_IMAGE))
{
type = GIMP_TYPE_PREVIEW_RENDERER_IMAGE;
type = GIMP_TYPE_VIEW_RENDERER_IMAGE;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_LAYER))
{
type = GIMP_TYPE_PREVIEW_RENDERER_LAYER;
type = GIMP_TYPE_VIEW_RENDERER_LAYER;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_DRAWABLE))
{
type = GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE;
type = GIMP_TYPE_VIEW_RENDERER_DRAWABLE;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_GRADIENT))
{
type = GIMP_TYPE_PREVIEW_RENDERER_GRADIENT;
type = GIMP_TYPE_VIEW_RENDERER_GRADIENT;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_VECTORS))
{
type = GIMP_TYPE_PREVIEW_RENDERER_VECTORS;
type = GIMP_TYPE_VIEW_RENDERER_VECTORS;
}
else if (g_type_is_a (viewable_type, GIMP_TYPE_IMAGEFILE))
{
type = GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE;
type = GIMP_TYPE_VIEW_RENDERER_IMAGEFILE;
}
return type;

10
app/widgets/gimpviewrenderer-utils.h
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderer-utils.h
* gimpviewrenderer-utils.h
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -19,11 +19,11 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PREVIEW_RENDERER_UTILS_H__
#define __GIMP_PREVIEW_RENDERER_UTILS_H__
#ifndef __GIMP_VIEW_RENDERER_UTILS_H__
#define __GIMP_VIEW_RENDERER_UTILS_H__
GType gimp_preview_renderer_type_from_viewable_type (GType viewable_type);
GType gimp_view_renderer_type_from_viewable_type (GType viewable_type);
#endif /* __GIMP_PREVIEW_RENDERER_UTILS_H__ */
#endif /* __GIMP_VIEW_RENDERER_UTILS_H__ */

4
app/widgets/gimpviewrenderer.c
View File

@ -45,7 +45,7 @@
#include "display/gimpdisplayshell-render.h"
#include "gimpviewrenderer.h"
#include "gimppreviewrenderer-utils.h"
#include "gimpviewrenderer-utils.h"
#include "gimpwidgets-utils.h"
@ -222,7 +222,7 @@ gimp_view_renderer_new_internal (GType viewable_type,
{
GimpViewRenderer *renderer;
renderer = g_object_new (gimp_preview_renderer_type_from_viewable_type (viewable_type),
renderer = g_object_new (gimp_view_renderer_type_from_viewable_type (viewable_type),
NULL);
renderer->viewable_type = viewable_type;

52
app/widgets/gimpviewrendererbrush.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererbrush.c
* gimpviewrendererbrush.c
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -30,24 +30,24 @@
#include "core/gimpbrush.h"
#include "core/gimpbrushpipe.h"
#include "gimppreviewrendererbrush.h"
#include "gimpviewrendererbrush.h"
static void gimp_preview_renderer_brush_class_init (GimpPreviewRendererBrushClass *klass);
static void gimp_preview_renderer_brush_init (GimpPreviewRendererBrush *renderer);
static void gimp_view_renderer_brush_class_init (GimpViewRendererBrushClass *klass);
static void gimp_view_renderer_brush_init (GimpViewRendererBrush *renderer);
static void gimp_preview_renderer_brush_finalize (GObject *object);
static void gimp_preview_renderer_brush_render (GimpViewRenderer *renderer,
static void gimp_view_renderer_brush_finalize (GObject *object);
static void gimp_view_renderer_brush_render (GimpViewRenderer *renderer,
GtkWidget *widget);
static gboolean gimp_preview_renderer_brush_render_timeout (gpointer data);
static gboolean gimp_view_renderer_brush_render_timeout (gpointer data);
static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_brush_get_type (void)
gimp_view_renderer_brush_get_type (void)
{
static GType renderer_type = 0;
@ -55,19 +55,19 @@ gimp_preview_renderer_brush_get_type (void)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererBrushClass),
sizeof (GimpViewRendererBrushClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_brush_class_init,
(GClassInitFunc) gimp_view_renderer_brush_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererBrush),
sizeof (GimpViewRendererBrush),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_brush_init,
(GInstanceInitFunc) gimp_view_renderer_brush_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererBrush",
"GimpViewRendererBrush",
&renderer_info, 0);
}
@ -75,7 +75,7 @@ gimp_preview_renderer_brush_get_type (void)
}
static void
gimp_preview_renderer_brush_class_init (GimpPreviewRendererBrushClass *klass)
gimp_view_renderer_brush_class_init (GimpViewRendererBrushClass *klass)
{
GObjectClass *object_class;
GimpViewRendererClass *renderer_class;
@ -85,22 +85,22 @@ gimp_preview_renderer_brush_class_init (GimpPreviewRendererBrushClass *klass)
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_preview_renderer_brush_finalize;
object_class->finalize = gimp_view_renderer_brush_finalize;
renderer_class->render = gimp_preview_renderer_brush_render;
renderer_class->render = gimp_view_renderer_brush_render;
}
static void
gimp_preview_renderer_brush_init (GimpPreviewRendererBrush *renderer)
gimp_view_renderer_brush_init (GimpViewRendererBrush *renderer)
{
renderer->pipe_timeout_id = 0;
renderer->pipe_animation_index = 0;
}
static void
gimp_preview_renderer_brush_finalize (GObject *object)
gimp_view_renderer_brush_finalize (GObject *object)
{
GimpPreviewRendererBrush *renderer = GIMP_PREVIEW_RENDERER_BRUSH (object);
GimpViewRendererBrush *renderer = GIMP_VIEW_RENDERER_BRUSH (object);
if (renderer->pipe_timeout_id)
{
@ -112,16 +112,16 @@ gimp_preview_renderer_brush_finalize (GObject *object)
}
static void
gimp_preview_renderer_brush_render (GimpViewRenderer *renderer,
gimp_view_renderer_brush_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpPreviewRendererBrush *renderbrush;
GimpViewRendererBrush *renderbrush;
GimpBrush *brush;
TempBuf *temp_buf;
gint brush_width;
gint brush_height;
renderbrush = GIMP_PREVIEW_RENDERER_BRUSH (renderer);
renderbrush = GIMP_VIEW_RENDERER_BRUSH (renderer);
if (renderbrush->pipe_timeout_id)
{
@ -155,7 +155,7 @@ gimp_preview_renderer_brush_render (GimpViewRenderer *renderer,
{
renderbrush->pipe_animation_index = 0;
renderbrush->pipe_timeout_id =
g_timeout_add (300, gimp_preview_renderer_brush_render_timeout,
g_timeout_add (300, gimp_view_renderer_brush_render_timeout,
renderbrush);
}
@ -279,15 +279,15 @@ gimp_preview_renderer_brush_render (GimpViewRenderer *renderer,
}
static gboolean
gimp_preview_renderer_brush_render_timeout (gpointer data)
gimp_view_renderer_brush_render_timeout (gpointer data)
{
GimpPreviewRendererBrush *renderbrush;
GimpViewRendererBrush *renderbrush;
GimpViewRenderer *renderer;
GimpBrushPipe *brush_pipe;
GimpBrush *brush;
TempBuf *temp_buf;
renderbrush = GIMP_PREVIEW_RENDERER_BRUSH (data);
renderbrush = GIMP_VIEW_RENDERER_BRUSH (data);
renderer = GIMP_VIEW_RENDERER (data);
if (! renderer->viewable)

28
app/widgets/gimpviewrendererbrush.h
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererbrush.h
* gimpviewrendererbrush.h
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -19,22 +19,22 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PREVIEW_RENDERER_BRUSH_H__
#define __GIMP_PREVIEW_RENDERER_BRUSH_H__
#ifndef __GIMP_VIEW_RENDERER_BRUSH_H__
#define __GIMP_VIEW_RENDERER_BRUSH_H__
#include "gimpviewrenderer.h"
#define GIMP_TYPE_PREVIEW_RENDERER_BRUSH (gimp_preview_renderer_brush_get_type ())
#define GIMP_PREVIEW_RENDERER_BRUSH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_BRUSH, GimpPreviewRendererBrush))
#define GIMP_PREVIEW_RENDERER_BRUSH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_BRUSH, GimpPreviewRendererBrushClass))
#define GIMP_IS_PREVIEW_RENDERER_BRUSH(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_BRUSH))
#define GIMP_IS_PREVIEW_RENDERER_BRUSH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_BRUSH))
#define GIMP_PREVIEW_RENDERER_BRUSH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_BRUSH, GimpPreviewRendererBrushClass))
#define GIMP_TYPE_VIEW_RENDERER_BRUSH (gimp_view_renderer_brush_get_type ())
#define GIMP_VIEW_RENDERER_BRUSH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VIEW_RENDERER_BRUSH, GimpViewRendererBrush))
#define GIMP_VIEW_RENDERER_BRUSH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEW_RENDERER_BRUSH, GimpViewRendererBrushClass))
#define GIMP_IS_VIEW_RENDERER_BRUSH(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_VIEW_RENDERER_BRUSH))
#define GIMP_IS_VIEW_RENDERER_BRUSH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEW_RENDERER_BRUSH))
#define GIMP_VIEW_RENDERER_BRUSH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VIEW_RENDERER_BRUSH, GimpViewRendererBrushClass))
typedef struct _GimpPreviewRendererBrushClass GimpPreviewRendererBrushClass;
typedef struct _GimpViewRendererBrushClass GimpViewRendererBrushClass;
struct _GimpPreviewRendererBrush
struct _GimpViewRendererBrush
{
GimpViewRenderer parent_instance;
@ -42,13 +42,13 @@ struct _GimpPreviewRendererBrush
gint pipe_animation_index;
};
struct _GimpPreviewRendererBrushClass
struct _GimpViewRendererBrushClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_brush_get_type (void) G_GNUC_CONST;
GType gimp_view_renderer_brush_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_BRUSH_H__ */
#endif /* __GIMP_VIEW_RENDERER_BRUSH_H__ */

56
app/widgets/gimpviewrendererdrawable.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererdrawable.c
* gimpviewrendererdrawable.c
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -32,13 +32,13 @@
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
#include "gimppreviewrendererdrawable.h"
#include "gimpviewrendererdrawable.h"
static void gimp_preview_renderer_drawable_class_init (GimpPreviewRendererDrawableClass *klass);
static void gimp_preview_renderer_drawable_init (GimpPreviewRendererDrawable *renderer);
static void gimp_view_renderer_drawable_class_init (GimpViewRendererDrawableClass *klass);
static void gimp_view_renderer_drawable_init (GimpViewRendererDrawable *renderer);
static void gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
static void gimp_view_renderer_drawable_render (GimpViewRenderer *renderer,
GtkWidget *widget);
@ -46,7 +46,7 @@ static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_drawable_get_type (void)
gimp_view_renderer_drawable_get_type (void)
{
static GType renderer_type = 0;
@ -54,19 +54,19 @@ gimp_preview_renderer_drawable_get_type (void)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererDrawableClass),
sizeof (GimpViewRendererDrawableClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_drawable_class_init,
(GClassInitFunc) gimp_view_renderer_drawable_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererDrawable),
sizeof (GimpViewRendererDrawable),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_drawable_init,
(GInstanceInitFunc) gimp_view_renderer_drawable_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererDrawable",
"GimpViewRendererDrawable",
&renderer_info, 0);
}
@ -74,7 +74,7 @@ gimp_preview_renderer_drawable_get_type (void)
}
static void
gimp_preview_renderer_drawable_class_init (GimpPreviewRendererDrawableClass *klass)
gimp_view_renderer_drawable_class_init (GimpViewRendererDrawableClass *klass)
{
GimpViewRendererClass *renderer_class;
@ -82,16 +82,16 @@ gimp_preview_renderer_drawable_class_init (GimpPreviewRendererDrawableClass *kla
parent_class = g_type_class_peek_parent (klass);
renderer_class->render = gimp_preview_renderer_drawable_render;
renderer_class->render = gimp_view_renderer_drawable_render;
}
static void
gimp_preview_renderer_drawable_init (GimpPreviewRendererDrawable *renderer)
gimp_view_renderer_drawable_init (GimpViewRendererDrawable *renderer)
{
}
static void
gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
gimp_view_renderer_drawable_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpDrawable *drawable;
@ -99,8 +99,8 @@ gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
GimpImage *gimage;
gint width;
gint height;
gint preview_width;
gint preview_height;
gint view_width;
gint view_height;
gboolean scaling_up;
TempBuf *render_buf = NULL;
@ -125,8 +125,8 @@ gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
renderer->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&view_width,
&view_height,
&scaling_up);
}
else
@ -138,8 +138,8 @@ gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
renderer->dot_for_dot,
gimage ? gimage->xresolution : 1.0,
gimage ? gimage->yresolution : 1.0,
&preview_width,
&preview_height,
&view_width,
&view_height,
&scaling_up);
}
@ -153,7 +153,7 @@ gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
if (temp_buf)
{
render_buf = temp_buf_scale (temp_buf, preview_width, preview_height);
render_buf = temp_buf_scale (temp_buf, view_width, view_height);
temp_buf_free (temp_buf);
}
@ -161,8 +161,8 @@ gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
else
{
render_buf = gimp_viewable_get_new_preview (renderer->viewable,
preview_width,
preview_height);
view_width,
view_height);
}
if (render_buf)
@ -181,11 +181,11 @@ gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer,
}
else
{
if (preview_width < width)
render_buf->x = (width - preview_width) / 2;
if (view_width < width)
render_buf->x = (width - view_width) / 2;
if (preview_height < height)
render_buf->y = (height - preview_height) / 2;
if (view_height < height)
render_buf->y = (height - view_height) / 2;
}
gimp_view_renderer_render_buffer (renderer, render_buf, -1,

28
app/widgets/gimpviewrendererdrawable.h
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererdrawable.h
* gimpviewrendererdrawable.h
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -19,33 +19,33 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PREVIEW_RENDERER_DRAWABLE_H__
#define __GIMP_PREVIEW_RENDERER_DRAWABLE_H__
#ifndef __GIMP_VIEW_RENDERER_DRAWABLE_H__
#define __GIMP_VIEW_RENDERER_DRAWABLE_H__
#include "gimpviewrenderer.h"
#define GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE (gimp_preview_renderer_drawable_get_type ())
#define GIMP_PREVIEW_RENDERER_DRAWABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE, GimpPreviewRendererDrawable))
#define GIMP_PREVIEW_RENDERER_DRAWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE, GimpPreviewRendererDrawableClass))
#define GIMP_IS_PREVIEW_RENDERER_DRAWABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE))
#define GIMP_IS_PREVIEW_RENDERER_DRAWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE))
#define GIMP_PREVIEW_RENDERER_DRAWABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE, GimpPreviewRendererDrawableClass))
#define GIMP_TYPE_VIEW_RENDERER_DRAWABLE (gimp_view_renderer_drawable_get_type ())
#define GIMP_VIEW_RENDERER_DRAWABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VIEW_RENDERER_DRAWABLE, GimpViewRendererDrawable))
#define GIMP_VIEW_RENDERER_DRAWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEW_RENDERER_DRAWABLE, GimpViewRendererDrawableClass))
#define GIMP_IS_VIEW_RENDERER_DRAWABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_VIEW_RENDERER_DRAWABLE))
#define GIMP_IS_VIEW_RENDERER_DRAWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEW_RENDERER_DRAWABLE))
#define GIMP_VIEW_RENDERER_DRAWABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VIEW_RENDERER_DRAWABLE, GimpViewRendererDrawableClass))
typedef struct _GimpPreviewRendererDrawableClass GimpPreviewRendererDrawableClass;
typedef struct _GimpViewRendererDrawableClass GimpViewRendererDrawableClass;
struct _GimpPreviewRendererDrawable
struct _GimpViewRendererDrawable
{
GimpViewRenderer parent_instance;
};
struct _GimpPreviewRendererDrawableClass
struct _GimpViewRendererDrawableClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_drawable_get_type (void) G_GNUC_CONST;
GType gimp_view_renderer_drawable_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_DRAWABLE_H__ */
#endif /* __GIMP_VIEW_RENDERER_DRAWABLE_H__ */

52
app/widgets/gimpviewrenderergradient.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderergradient.c
* gimpviewrenderergradient.c
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -39,15 +39,15 @@
#include "display/gimpdisplayshell-render.h"
#include "gimppreviewrenderergradient.h"
#include "gimpviewrenderergradient.h"
static void gimp_preview_renderer_gradient_class_init (GimpPreviewRendererGradientClass *klass);
static void gimp_preview_renderer_gradient_init (GimpPreviewRendererGradient *renderer);
static void gimp_view_renderer_gradient_class_init (GimpViewRendererGradientClass *klass);
static void gimp_view_renderer_gradient_init (GimpViewRendererGradient *renderer);
static void gimp_preview_renderer_gradient_finalize (GObject *object);
static void gimp_view_renderer_gradient_finalize (GObject *object);
static void gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer,
static void gimp_view_renderer_gradient_render (GimpViewRenderer *renderer,
GtkWidget *widget);
@ -55,7 +55,7 @@ static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_gradient_get_type (void)
gimp_view_renderer_gradient_get_type (void)
{
static GType renderer_type = 0;
@ -63,19 +63,19 @@ gimp_preview_renderer_gradient_get_type (void)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererGradientClass),
sizeof (GimpViewRendererGradientClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_gradient_class_init,
(GClassInitFunc) gimp_view_renderer_gradient_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererGradient),
sizeof (GimpViewRendererGradient),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_gradient_init,
(GInstanceInitFunc) gimp_view_renderer_gradient_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererGradient",
"GimpViewRendererGradient",
&renderer_info, 0);
}
@ -83,7 +83,7 @@ gimp_preview_renderer_gradient_get_type (void)
}
static void
gimp_preview_renderer_gradient_class_init (GimpPreviewRendererGradientClass *klass)
gimp_view_renderer_gradient_class_init (GimpViewRendererGradientClass *klass)
{
GObjectClass *object_class;
GimpViewRendererClass *renderer_class;
@ -93,13 +93,13 @@ gimp_preview_renderer_gradient_class_init (GimpPreviewRendererGradientClass *kla
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_preview_renderer_gradient_finalize;
object_class->finalize = gimp_view_renderer_gradient_finalize;
renderer_class->render = gimp_preview_renderer_gradient_render;
renderer_class->render = gimp_view_renderer_gradient_render;
}
static void
gimp_preview_renderer_gradient_init (GimpPreviewRendererGradient *renderer)
gimp_view_renderer_gradient_init (GimpViewRendererGradient *renderer)
{
renderer->even = NULL;
renderer->odd = NULL;
@ -110,11 +110,11 @@ gimp_preview_renderer_gradient_init (GimpPreviewRendererGradient *renderer)
}
static void
gimp_preview_renderer_gradient_finalize (GObject *object)
gimp_view_renderer_gradient_finalize (GObject *object)
{
GimpPreviewRendererGradient *renderer;
GimpViewRendererGradient *renderer;
renderer = GIMP_PREVIEW_RENDERER_GRADIENT (object);
renderer = GIMP_VIEW_RENDERER_GRADIENT (object);
if (renderer->even)
{
@ -132,10 +132,10 @@ gimp_preview_renderer_gradient_finalize (GObject *object)
}
static void
gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer,
gimp_view_renderer_gradient_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpPreviewRendererGradient *rendergrad;
GimpViewRendererGradient *rendergrad;
GimpGradient *gradient;
guchar *even;
guchar *odd;
@ -146,7 +146,7 @@ gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer,
gdouble dx, cur_x;
GimpRGB color;
rendergrad = GIMP_PREVIEW_RENDERER_GRADIENT (renderer);
rendergrad = GIMP_VIEW_RENDERER_GRADIENT (renderer);
gradient = GIMP_GRADIENT (renderer->viewable);
@ -222,12 +222,12 @@ gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer,
}
void
gimp_preview_renderer_gradient_set_offsets (GimpPreviewRendererGradient *renderer,
gimp_view_renderer_gradient_set_offsets (GimpViewRendererGradient *renderer,
gdouble left,
gdouble right,
gboolean instant_update)
{
g_return_if_fail (GIMP_IS_PREVIEW_RENDERER_GRADIENT (renderer));
g_return_if_fail (GIMP_IS_VIEW_RENDERER_GRADIENT (renderer));
left = CLAMP (left, 0.0, 1.0);
right = CLAMP (right, left, 1.0);
@ -245,10 +245,10 @@ gimp_preview_renderer_gradient_set_offsets (GimpPreviewRendererGradient *rendere
}
void
gimp_preview_renderer_gradient_set_reverse (GimpPreviewRendererGradient *renderer,
gimp_view_renderer_gradient_set_reverse (GimpViewRendererGradient *renderer,
gboolean reverse)
{
g_return_if_fail (GIMP_IS_PREVIEW_RENDERER_GRADIENT (renderer));
g_return_if_fail (GIMP_IS_VIEW_RENDERER_GRADIENT (renderer));
if (reverse != renderer->reverse)
{

32
app/widgets/gimpviewrenderergradient.h
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderergradient.h
* gimpviewrenderergradient.h
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -19,22 +19,22 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PREVIEW_RENDERER_GRADIENT_H__
#define __GIMP_PREVIEW_RENDERER_GRADIENT_H__
#ifndef __GIMP_VIEW_RENDERER_GRADIENT_H__
#define __GIMP_VIEW_RENDERER_GRADIENT_H__
#include "gimpviewrenderer.h"
#define GIMP_TYPE_PREVIEW_RENDERER_GRADIENT (gimp_preview_renderer_gradient_get_type ())
#define GIMP_PREVIEW_RENDERER_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_GRADIENT, GimpPreviewRendererGradient))
#define GIMP_PREVIEW_RENDERER_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_GRADIENT, GimpPreviewRendererGradientClass))
#define GIMP_IS_PREVIEW_RENDERER_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_GRADIENT))
#define GIMP_IS_PREVIEW_RENDERER_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_GRADIENT))
#define GIMP_PREVIEW_RENDERER_GRADIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_GRADIENT, GimpPreviewRendererGradientClass))
#define GIMP_TYPE_VIEW_RENDERER_GRADIENT (gimp_view_renderer_gradient_get_type ())
#define GIMP_VIEW_RENDERER_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VIEW_RENDERER_GRADIENT, GimpViewRendererGradient))
#define GIMP_VIEW_RENDERER_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEW_RENDERER_GRADIENT, GimpViewRendererGradientClass))
#define GIMP_IS_VIEW_RENDERER_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_VIEW_RENDERER_GRADIENT))
#define GIMP_IS_VIEW_RENDERER_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEW_RENDERER_GRADIENT))
#define GIMP_VIEW_RENDERER_GRADIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VIEW_RENDERER_GRADIENT, GimpViewRendererGradientClass))
typedef struct _GimpPreviewRendererGradientClass GimpPreviewRendererGradientClass;
typedef struct _GimpViewRendererGradientClass GimpViewRendererGradientClass;
struct _GimpPreviewRendererGradient
struct _GimpViewRendererGradient
{
GimpViewRenderer parent_instance;
@ -47,20 +47,20 @@ struct _GimpPreviewRendererGradient
gboolean reverse;
};
struct _GimpPreviewRendererGradientClass
struct _GimpViewRendererGradientClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_gradient_get_type (void) G_GNUC_CONST;
GType gimp_view_renderer_gradient_get_type (void) G_GNUC_CONST;
void gimp_preview_renderer_gradient_set_offsets (GimpPreviewRendererGradient *renderer,
void gimp_view_renderer_gradient_set_offsets (GimpViewRendererGradient *renderer,
gdouble left,
gdouble right,
gboolean instant_update);
void gimp_preview_renderer_gradient_set_reverse (GimpPreviewRendererGradient *renderer,
void gimp_view_renderer_gradient_set_reverse (GimpViewRendererGradient *renderer,
gboolean reverse);
#endif /* __GIMP_PREVIEW_RENDERER_GRADIENT_H__ */
#endif /* __GIMP_VIEW_RENDERER_GRADIENT_H__ */

59
app/widgets/gimpviewrendererimage.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererimage.c
* gimpviewrendererimage.c
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -31,13 +31,13 @@
#include "core/gimpimage.h"
#include "gimppreviewrendererimage.h"
#include "gimpviewrendererimage.h"
static void gimp_preview_renderer_image_class_init (GimpPreviewRendererImageClass *klass);
static void gimp_preview_renderer_image_init (GimpPreviewRendererImage *renderer);
static void gimp_view_renderer_image_class_init (GimpViewRendererImageClass *klass);
static void gimp_view_renderer_image_init (GimpViewRendererImage *renderer);
static void gimp_preview_renderer_image_render (GimpViewRenderer *renderer,
static void gimp_view_renderer_image_render (GimpViewRenderer *renderer,
GtkWidget *widget);
@ -45,7 +45,7 @@ static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_image_get_type (void)
gimp_view_renderer_image_get_type (void)
{
static GType renderer_type = 0;
@ -53,19 +53,19 @@ gimp_preview_renderer_image_get_type (void)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererImageClass),
sizeof (GimpViewRendererImageClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_image_class_init,
(GClassInitFunc) gimp_view_renderer_image_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererImage),
sizeof (GimpViewRendererImage),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_image_init,
(GInstanceInitFunc) gimp_view_renderer_image_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererImage",
"GimpViewRendererImage",
&renderer_info, 0);
}
@ -73,7 +73,7 @@ gimp_preview_renderer_image_get_type (void)
}
static void
gimp_preview_renderer_image_class_init (GimpPreviewRendererImageClass *klass)
gimp_view_renderer_image_class_init (GimpViewRendererImageClass *klass)
{
GimpViewRendererClass *renderer_class;
@ -81,27 +81,27 @@ gimp_preview_renderer_image_class_init (GimpPreviewRendererImageClass *klass)
parent_class = g_type_class_peek_parent (klass);
renderer_class->render = gimp_preview_renderer_image_render;
renderer_class->render = gimp_view_renderer_image_render;
}
static void
gimp_preview_renderer_image_init (GimpPreviewRendererImage *renderer)
gimp_view_renderer_image_init (GimpViewRendererImage *renderer)
{
renderer->channel = -1;
}
static void
gimp_preview_renderer_image_render (GimpViewRenderer *renderer,
gimp_view_renderer_image_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpPreviewRendererImage *rendererimage;
GimpViewRendererImage *rendererimage;
GimpImage *gimage;
gint preview_width;
gint preview_height;
gint view_width;
gint view_height;
gboolean scaling_up;
TempBuf *render_buf = NULL;
rendererimage = GIMP_PREVIEW_RENDERER_IMAGE (renderer);
rendererimage = GIMP_VIEW_RENDERER_IMAGE (renderer);
gimage = GIMP_IMAGE (renderer->viewable);
@ -112,8 +112,8 @@ gimp_preview_renderer_image_render (GimpViewRenderer *renderer,
renderer->dot_for_dot,
gimage->xresolution,
gimage->yresolution,
&preview_width,
&preview_height,
&view_width,
&view_height,
&scaling_up);
if (scaling_up)
@ -125,8 +125,7 @@ gimp_preview_renderer_image_render (GimpViewRenderer *renderer,
if (temp_buf)
{
render_buf = temp_buf_scale (temp_buf,
preview_width, preview_height);
render_buf = temp_buf_scale (temp_buf, view_width, view_height);
temp_buf_free (temp_buf);
}
@ -134,8 +133,8 @@ gimp_preview_renderer_image_render (GimpViewRenderer *renderer,
else
{
render_buf = gimp_viewable_get_new_preview (renderer->viewable,
preview_width,
preview_height);
view_width,
view_height);
}
if (render_buf)
@ -143,7 +142,7 @@ gimp_preview_renderer_image_render (GimpViewRenderer *renderer,
gint component_index = -1;
/* xresolution != yresolution */
if (preview_width > renderer->width || preview_height > renderer->height)
if (view_width > renderer->width || view_height > renderer->height)
{
TempBuf *temp_buf;
@ -154,11 +153,11 @@ gimp_preview_renderer_image_render (GimpViewRenderer *renderer,
render_buf = temp_buf;
}
if (preview_width < renderer->width)
render_buf->x = (renderer->width - preview_width) / 2;
if (view_width < renderer->width)
render_buf->x = (renderer->width - view_width) / 2;
if (preview_height < renderer->height)
render_buf->y = (renderer->height - preview_height) / 2;
if (view_height < renderer->height)
render_buf->y = (renderer->height - view_height) / 2;
if (rendererimage->channel != -1)
component_index =

28
app/widgets/gimpviewrendererimage.h
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererimage.h
* gimpviewrendererimage.h
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -19,35 +19,35 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PREVIEW_RENDERER_IMAGE_H__
#define __GIMP_PREVIEW_RENDERER_IMAGE_H__
#ifndef __GIMP_VIEW_RENDERER_IMAGE_H__
#define __GIMP_VIEW_RENDERER_IMAGE_H__
#include "gimpviewrenderer.h"
#define GIMP_TYPE_PREVIEW_RENDERER_IMAGE (gimp_preview_renderer_image_get_type ())
#define GIMP_PREVIEW_RENDERER_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_IMAGE, GimpPreviewRendererImage))
#define GIMP_PREVIEW_RENDERER_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_IMAGE, GimpPreviewRendererImageClass))
#define GIMP_IS_PREVIEW_RENDERER_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_IMAGE))
#define GIMP_IS_PREVIEW_RENDERER_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_IMAGE))
#define GIMP_PREVIEW_RENDERER_IMAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_IMAGE, GimpPreviewRendererImageClass))
#define GIMP_TYPE_VIEW_RENDERER_IMAGE (gimp_view_renderer_image_get_type ())
#define GIMP_VIEW_RENDERER_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VIEW_RENDERER_IMAGE, GimpViewRendererImage))
#define GIMP_VIEW_RENDERER_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEW_RENDERER_IMAGE, GimpViewRendererImageClass))
#define GIMP_IS_VIEW_RENDERER_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_VIEW_RENDERER_IMAGE))
#define GIMP_IS_VIEW_RENDERER_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEW_RENDERER_IMAGE))
#define GIMP_VIEW_RENDERER_IMAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VIEW_RENDERER_IMAGE, GimpViewRendererImageClass))
typedef struct _GimpPreviewRendererImageClass GimpPreviewRendererImageClass;
typedef struct _GimpViewRendererImageClass GimpViewRendererImageClass;
struct _GimpPreviewRendererImage
struct _GimpViewRendererImage
{
GimpViewRenderer parent_instance;
GimpChannelType channel;
};
struct _GimpPreviewRendererImageClass
struct _GimpViewRendererImageClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_image_get_type (void) G_GNUC_CONST;
GType gimp_view_renderer_image_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_IMAGE_H__ */
#endif /* __GIMP_VIEW_RENDERER_IMAGE_H__ */

34
app/widgets/gimpviewrendererimagefile.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererimagefile.c
* gimpviewrendererimagefile.c
* Copyright (C) 2004 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -34,7 +34,7 @@
#include "core/gimpimagefile.h"
#include "gimppreviewrendererimagefile.h"
#include "gimpviewrendererimagefile.h"
#ifdef ENABLE_FILE_SYSTEM_ICONS
#define GTK_FILE_SYSTEM_ENABLE_UNSUPPORTED
@ -42,10 +42,10 @@
#endif
static void gimp_preview_renderer_imagefile_class_init (GimpPreviewRendererImagefileClass *klass);
static void gimp_preview_renderer_imagefile_init (GimpPreviewRendererImagefile *renderer);
static void gimp_view_renderer_imagefile_class_init (GimpViewRendererImagefileClass *klass);
static void gimp_view_renderer_imagefile_init (GimpViewRendererImagefile *renderer);
static void gimp_preview_renderer_imagefile_render (GimpViewRenderer *renderer,
static void gimp_view_renderer_imagefile_render (GimpViewRenderer *renderer,
GtkWidget *widget);
@ -53,7 +53,7 @@ static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_imagefile_get_type (void)
gimp_view_renderer_imagefile_get_type (void)
{
static GType renderer_type = 0;
@ -61,19 +61,19 @@ gimp_preview_renderer_imagefile_get_type (void)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererImagefileClass),
sizeof (GimpViewRendererImagefileClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_imagefile_class_init,
(GClassInitFunc) gimp_view_renderer_imagefile_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererImagefile),
sizeof (GimpViewRendererImagefile),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_renderer_imagefile_init,
(GInstanceInitFunc) gimp_view_renderer_imagefile_init,
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererImagefile",
"GimpViewRendererImagefile",
&renderer_info, 0);
}
@ -81,7 +81,7 @@ gimp_preview_renderer_imagefile_get_type (void)
}
static void
gimp_preview_renderer_imagefile_class_init (GimpPreviewRendererImagefileClass *klass)
gimp_view_renderer_imagefile_class_init (GimpViewRendererImagefileClass *klass)
{
GimpViewRendererClass *renderer_class;
@ -89,11 +89,11 @@ gimp_preview_renderer_imagefile_class_init (GimpPreviewRendererImagefileClass *k
parent_class = g_type_class_peek_parent (klass);
renderer_class->render = gimp_preview_renderer_imagefile_render;
renderer_class->render = gimp_view_renderer_imagefile_render;
}
static void
gimp_preview_renderer_imagefile_init (GimpPreviewRendererImagefile *renderer)
gimp_view_renderer_imagefile_init (GimpViewRendererImagefile *renderer)
{
#ifdef ENABLE_FILE_SYSTEM_ICONS
renderer->file_system = NULL;
@ -101,7 +101,7 @@ gimp_preview_renderer_imagefile_init (GimpPreviewRendererImagefile *renderer)
}
static void
gimp_preview_renderer_imagefile_render (GimpViewRenderer *renderer,
gimp_view_renderer_imagefile_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
TempBuf *temp_buf = gimp_viewable_get_preview (renderer->viewable,
@ -117,12 +117,12 @@ gimp_preview_renderer_imagefile_render (GimpViewRenderer *renderer,
GdkPixbuf *pixbuf = NULL;
#ifdef ENABLE_FILE_SYSTEM_ICONS
if (GIMP_PREVIEW_RENDERER_IMAGEFILE (renderer)->file_system)
if (GIMP_VIEW_RENDERER_IMAGEFILE (renderer)->file_system)
{
GtkFileSystem *file_system;
const gchar *uri;
file_system = GIMP_PREVIEW_RENDERER_IMAGEFILE (renderer)->file_system;
file_system = GIMP_VIEW_RENDERER_IMAGEFILE (renderer)->file_system;
uri = gimp_object_get_name (GIMP_OBJECT (renderer->viewable));

28
app/widgets/gimpviewrendererimagefile.h
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererimagefile.h
* gimpviewrendererimagefile.h
* Copyright (C) 2004 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -19,8 +19,8 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PREVIEW_RENDERER_IMAGEFILE_H__
#define __GIMP_PREVIEW_RENDERER_IMAGEFILE_H__
#ifndef __GIMP_VIEW_RENDERER_IMAGEFILE_H__
#define __GIMP_VIEW_RENDERER_IMAGEFILE_H__
#include "gimpviewrenderer.h"
@ -28,17 +28,17 @@
/* #define ENABLE_FILE_SYSTEM_ICONS 1 */
#define GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE (gimp_preview_renderer_imagefile_get_type ())
#define GIMP_PREVIEW_RENDERER_IMAGEFILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE, GimpPreviewRendererImagefile))
#define GIMP_PREVIEW_RENDERER_IMAGEFILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE, GimpPreviewRendererImagefileClass))
#define GIMP_IS_PREVIEW_RENDERER_IMAGEFILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE))
#define GIMP_IS_PREVIEW_RENDERER_IMAGEFILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE))
#define GIMP_PREVIEW_RENDERER_IMAGEFILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_IMAGEFILE, GimpPreviewRendererImagefileClass))
#define GIMP_TYPE_VIEW_RENDERER_IMAGEFILE (gimp_view_renderer_imagefile_get_type ())
#define GIMP_VIEW_RENDERER_IMAGEFILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VIEW_RENDERER_IMAGEFILE, GimpViewRendererImagefile))
#define GIMP_VIEW_RENDERER_IMAGEFILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEW_RENDERER_IMAGEFILE, GimpViewRendererImagefileClass))
#define GIMP_IS_VIEW_RENDERER_IMAGEFILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_VIEW_RENDERER_IMAGEFILE))
#define GIMP_IS_VIEW_RENDERER_IMAGEFILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEW_RENDERER_IMAGEFILE))
#define GIMP_VIEW_RENDERER_IMAGEFILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VIEW_RENDERER_IMAGEFILE, GimpViewRendererImagefileClass))
typedef struct _GimpPreviewRendererImagefileClass GimpPreviewRendererImagefileClass;
typedef struct _GimpViewRendererImagefileClass GimpViewRendererImagefileClass;
struct _GimpPreviewRendererImagefile
struct _GimpViewRendererImagefile
{
GimpViewRenderer parent_instance;
@ -47,13 +47,13 @@ struct _GimpPreviewRendererImagefile
#endif
};
struct _GimpPreviewRendererImagefileClass
struct _GimpViewRendererImagefileClass
{
GimpViewRendererClass parent_class;
};
GType gimp_preview_renderer_imagefile_get_type (void) G_GNUC_CONST;
GType gimp_view_renderer_imagefile_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_IMAGEFILE_H__ */
#endif /* __GIMP_VIEW_RENDERER_IMAGEFILE_H__ */

28
app/widgets/gimpviewrendererlayer.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererlayer.c
* gimpviewrendererlayer.c
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -29,20 +29,20 @@
#include "text/gimptextlayer.h"
#include "gimppreviewrendererlayer.h"
#include "gimpviewrendererlayer.h"
static void gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass);
static void gimp_view_renderer_layer_class_init (GimpViewRendererLayerClass *klass);
static void gimp_preview_renderer_layer_render (GimpViewRenderer *renderer,
static void gimp_view_renderer_layer_render (GimpViewRenderer *renderer,
GtkWidget *widget);
static GimpPreviewRendererDrawableClass *parent_class = NULL;
static GimpViewRendererDrawableClass *parent_class = NULL;
GType
gimp_preview_renderer_layer_get_type (void)
gimp_view_renderer_layer_get_type (void)
{
static GType renderer_type = 0;
@ -50,19 +50,19 @@ gimp_preview_renderer_layer_get_type (void)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererLayerClass),
sizeof (GimpViewRendererLayerClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_layer_class_init,
(GClassInitFunc) gimp_view_renderer_layer_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererLayer),
sizeof (GimpViewRendererLayer),
0, /* n_preallocs */
NULL, /* instance_init */
};
renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER_DRAWABLE,
"GimpPreviewRendererLayer",
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER_DRAWABLE,
"GimpViewRendererLayer",
&renderer_info, 0);
}
@ -70,7 +70,7 @@ gimp_preview_renderer_layer_get_type (void)
}
static void
gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass)
gimp_view_renderer_layer_class_init (GimpViewRendererLayerClass *klass)
{
GimpViewRendererClass *renderer_class;
@ -78,11 +78,11 @@ gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass)
parent_class = g_type_class_peek_parent (klass);
renderer_class->render = gimp_preview_renderer_layer_render;
renderer_class->render = gimp_view_renderer_layer_render;
}
static void
gimp_preview_renderer_layer_render (GimpViewRenderer *renderer,
gimp_view_renderer_layer_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
const gchar *stock_id = NULL;

34
app/widgets/gimpviewrendererlayer.h
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrendererlayer.h
* gimpviewrendererlayer.h
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -19,33 +19,33 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PREVIEW_RENDERER_LAYER_H__
#define __GIMP_PREVIEW_RENDERER_LAYER_H__
#ifndef __GIMP_VIEW_RENDERER_LAYER_H__
#define __GIMP_VIEW_RENDERER_LAYER_H__
#include "gimppreviewrendererdrawable.h"
#include "gimpviewrendererdrawable.h"
#define GIMP_TYPE_PREVIEW_RENDERER_LAYER (gimp_preview_renderer_layer_get_type ())
#define GIMP_PREVIEW_RENDERER_LAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_LAYER, GimpPreviewRendererLayer))
#define GIMP_PREVIEW_RENDERER_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_LAYER, GimpPreviewRendererLayerClass))
#define GIMP_IS_PREVIEW_RENDERER_LAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_LAYER))
#define GIMP_IS_PREVIEW_RENDERER_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_LAYER))
#define GIMP_PREVIEW_RENDERER_LAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_LAYER, GimpPreviewRendererLayerClass))
#define GIMP_TYPE_VIEW_RENDERER_LAYER (gimp_view_renderer_layer_get_type ())
#define GIMP_VIEW_RENDERER_LAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VIEW_RENDERER_LAYER, GimpViewRendererLayer))
#define GIMP_VIEW_RENDERER_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEW_RENDERER_LAYER, GimpViewRendererLayerClass))
#define GIMP_IS_VIEW_RENDERER_LAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_VIEW_RENDERER_LAYER))
#define GIMP_IS_VIEW_RENDERER_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEW_RENDERER_LAYER))
#define GIMP_VIEW_RENDERER_LAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VIEW_RENDERER_LAYER, GimpViewRendererLayerClass))
typedef struct _GimpPreviewRendererLayerClass GimpPreviewRendererLayerClass;
typedef struct _GimpViewRendererLayerClass GimpViewRendererLayerClass;
struct _GimpPreviewRendererLayer
struct _GimpViewRendererLayer
{
GimpPreviewRendererDrawable parent_instance;
GimpViewRendererDrawable parent_instance;
};
struct _GimpPreviewRendererLayerClass
struct _GimpViewRendererLayerClass
{
GimpPreviewRendererDrawableClass parent_class;
GimpViewRendererDrawableClass parent_class;
};
GType gimp_preview_renderer_layer_get_type (void) G_GNUC_CONST;
GType gimp_view_renderer_layer_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_LAYER_H__ */
#endif /* __GIMP_VIEW_RENDERER_LAYER_H__ */

24
app/widgets/gimpviewrenderervectors.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderervectors.c
* gimpviewrenderervectors.c
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
* Simon Budig <simon@gimp.org>
*
@ -34,12 +34,12 @@
#include "vectors/gimpstroke.h"
#include "vectors/gimpvectors.h"
#include "gimppreviewrenderervectors.h"
#include "gimpviewrenderervectors.h"
static void gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass);
static void gimp_view_renderer_vectors_class_init (GimpViewRendererVectorsClass *klass);
static void gimp_preview_renderer_vectors_draw (GimpViewRenderer *renderer,
static void gimp_view_renderer_vectors_draw (GimpViewRenderer *renderer,
GdkWindow *window,
GtkWidget *widget,
const GdkRectangle *draw_area,
@ -50,7 +50,7 @@ static GimpViewRendererClass *parent_class = NULL;
GType
gimp_preview_renderer_vectors_get_type (void)
gimp_view_renderer_vectors_get_type (void)
{
static GType renderer_type = 0;
@ -58,19 +58,19 @@ gimp_preview_renderer_vectors_get_type (void)
{
static const GTypeInfo renderer_info =
{
sizeof (GimpPreviewRendererVectorsClass),
sizeof (GimpViewRendererVectorsClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_renderer_vectors_class_init,
(GClassInitFunc) gimp_view_renderer_vectors_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewRendererVectors),
sizeof (GimpViewRendererVectors),
0, /* n_preallocs */
NULL, /* instance_init */
};
renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER,
"GimpPreviewRendererVectors",
"GimpViewRendererVectors",
&renderer_info, 0);
}
@ -78,7 +78,7 @@ gimp_preview_renderer_vectors_get_type (void)
}
static void
gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass)
gimp_view_renderer_vectors_class_init (GimpViewRendererVectorsClass *klass)
{
GimpViewRendererClass *renderer_class;
@ -86,11 +86,11 @@ gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass
parent_class = g_type_class_peek_parent (klass);
renderer_class->draw = gimp_preview_renderer_vectors_draw;
renderer_class->draw = gimp_view_renderer_vectors_draw;
}
static void
gimp_preview_renderer_vectors_draw (GimpViewRenderer *renderer,
gimp_view_renderer_vectors_draw (GimpViewRenderer *renderer,
GdkWindow *window,
GtkWidget *widget,
const GdkRectangle *draw_area,

34
app/widgets/gimpviewrenderervectors.h
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppreviewrenderervectors.h
* gimpviewrenderervectors.h
* Copyright (C) 2003 Michael Natterer <mitch@gimp.org>
* Simon Budig <simon@gimp.org>
*
@ -20,33 +20,33 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PREVIEW_RENDERER_VECTORS_H__
#define __GIMP_PREVIEW_RENDERER_VECTORS_H__
#ifndef __GIMP_VIEW_RENDERER_VECTORS_H__
#define __GIMP_VIEW_RENDERER_VECTORS_H__
#include "gimppreviewrendererdrawable.h"
#include "gimpviewrendererdrawable.h"
#define GIMP_TYPE_PREVIEW_RENDERER_VECTORS (gimp_preview_renderer_vectors_get_type ())
#define GIMP_PREVIEW_RENDERER_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER_VECTORS, GimpPreviewRendererVectors))
#define GIMP_PREVIEW_RENDERER_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER_VECTORS, GimpPreviewRendererVectorsClass))
#define GIMP_IS_PREVIEW_RENDERER_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER_VECTORS))
#define GIMP_IS_PREVIEW_RENDERER_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER_VECTORS))
#define GIMP_PREVIEW_RENDERER_VECTORS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER_VECTORS, GimpPreviewRendererVectorsClass))
#define GIMP_TYPE_VIEW_RENDERER_VECTORS (gimp_view_renderer_vectors_get_type ())
#define GIMP_VIEW_RENDERER_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VIEW_RENDERER_VECTORS, GimpViewRendererVectors))
#define GIMP_VIEW_RENDERER_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEW_RENDERER_VECTORS, GimpViewRendererVectorsClass))
#define GIMP_IS_VIEW_RENDERER_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_VIEW_RENDERER_VECTORS))
#define GIMP_IS_VIEW_RENDERER_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEW_RENDERER_VECTORS))
#define GIMP_VIEW_RENDERER_VECTORS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VIEW_RENDERER_VECTORS, GimpViewRendererVectorsClass))
typedef struct _GimpPreviewRendererVectorsClass GimpPreviewRendererVectorsClass;
typedef struct _GimpViewRendererVectorsClass GimpViewRendererVectorsClass;
struct _GimpPreviewRendererVectors
struct _GimpViewRendererVectors
{
GimpPreviewRendererDrawable parent_instance;
GimpViewRendererDrawable parent_instance;
};
struct _GimpPreviewRendererVectorsClass
struct _GimpViewRendererVectorsClass
{
GimpPreviewRendererDrawableClass parent_class;
GimpViewRendererDrawableClass parent_class;
};
GType gimp_preview_renderer_vectors_get_type (void) G_GNUC_CONST;
GType gimp_view_renderer_vectors_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_PREVIEW_RENDERER_VECTORS_H__ */
#endif /* __GIMP_VIEW_RENDERER_VECTORS_H__ */

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

@ -168,16 +168,16 @@ typedef struct _GimpView GimpView;
typedef struct _GimpNavigationPreview GimpNavigationPreview;
/* preview renderers */
/* view renderers */
typedef struct _GimpViewRenderer GimpViewRenderer;
typedef struct _GimpPreviewRendererBrush GimpPreviewRendererBrush;
typedef struct _GimpPreviewRendererDrawable GimpPreviewRendererDrawable;
typedef struct _GimpPreviewRendererGradient GimpPreviewRendererGradient;
typedef struct _GimpPreviewRendererLayer GimpPreviewRendererLayer;
typedef struct _GimpPreviewRendererImage GimpPreviewRendererImage;
typedef struct _GimpPreviewRendererImagefile GimpPreviewRendererImagefile;
typedef struct _GimpPreviewRendererVectors GimpPreviewRendererVectors;
typedef struct _GimpViewRendererBrush GimpViewRendererBrush;
typedef struct _GimpViewRendererDrawable GimpViewRendererDrawable;
typedef struct _GimpViewRendererGradient GimpViewRendererGradient;
typedef struct _GimpViewRendererLayer GimpViewRendererLayer;
typedef struct _GimpViewRendererImage GimpViewRendererImage;
typedef struct _GimpViewRendererImagefile GimpViewRendererImagefile;
typedef struct _GimpViewRendererVectors GimpViewRendererVectors;
/* cell renderers */