diff --git a/ChangeLog b/ChangeLog index 4ee2b9e286..a4e2e9b485 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,67 @@ +2004-08-26 DindinX + + * app/widgets/gimppreview-popup.c + * app/widgets/gimppreview-popup.h: renamed these files... + + * app/widgets/gimpview-popup.c + * app/widgets/gimpview-popup.h: .. to these files, and changed the + GimpPreviewPopup type to GimpViewPopup. + + * app/widgets/gimppreviewrenderer.c + * app/widgets/gimppreviewrenderer.h: renamed these files... + + * app/widgets/gimpviewrenderer.c + * app/widgets/gimpviewrenderer.h: .. to these files, and changed + GimpPreviewRenderer to GimpViewRenderer. + + This is the second step of the great Preview->View renaming process. + + * app/display/gimpdisplayshell-layer-select.c + * app/display/gimpnavigationeditor.c + + * app/widgets/Makefile.am + * app/widgets/gimpbrushfactoryview.c + * app/widgets/gimpbufferview.c + * app/widgets/gimpcellrendererviewable.c + * app/widgets/gimpcellrendererviewable.h + * app/widgets/gimpcomponenteditor.c + * app/widgets/gimpcontainerbox.c + * app/widgets/gimpcontainercombobox.c + * app/widgets/gimpcontainereditor.c + * app/widgets/gimpcontainerentry.c + * app/widgets/gimpcontainergridview.c + * app/widgets/gimpcontainerpopup.c + * app/widgets/gimpcontainertreeview-dnd.c + * app/widgets/gimpcontainertreeview.c + * app/widgets/gimpcontainerview.c + * app/widgets/gimpdatafactoryview.c + * app/widgets/gimpitemtreeview.c + * app/widgets/gimplayertreeview.c + * app/widgets/gimpnavigationpreview.c + * app/widgets/gimppatternfactoryview.c + * app/widgets/gimppreviewrenderer-utils.c + * 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/gimppreviewrenderervectors.c + * app/widgets/gimpselectioneditor.c + * app/widgets/gimptemplateview.c + * app/widgets/gimptooloptionseditor.c + * app/widgets/gimptoolview.c + * app/widgets/gimpview.c + * app/widgets/gimpview.h + * app/widgets/gimpviewablebutton.c + * app/widgets/widgets-enums.h + * app/widgets/widgets-types.h: Modified accordingly. + 2004-08-25 Sven Neumann * app/widgets/gimperrordialog.[ch] (gimp_error_dialog_add): stop diff --git a/app/display/gimpdisplayshell-layer-select.c b/app/display/gimpdisplayshell-layer-select.c index 9c7dcfe205..e759009416 100644 --- a/app/display/gimpdisplayshell-layer-select.c +++ b/app/display/gimpdisplayshell-layer-select.c @@ -31,7 +31,6 @@ #include "core/gimplayer.h" #include "widgets/gimpview.h" -#include "widgets/gimppreviewrenderer.h" #include "gimpdisplay.h" #include "gimpdisplayshell.h" diff --git a/app/display/gimpnavigationeditor.c b/app/display/gimpnavigationeditor.c index 12fab922c4..e7e4b1acf8 100644 --- a/app/display/gimpnavigationeditor.c +++ b/app/display/gimpnavigationeditor.c @@ -39,7 +39,7 @@ #include "widgets/gimpdocked.h" #include "widgets/gimphelp-ids.h" #include "widgets/gimpnavigationpreview.h" -#include "widgets/gimppreviewrenderer.h" +#include "widgets/gimpviewrenderer.h" #include "gimpdisplay.h" #include "gimpdisplayshell.h" @@ -431,9 +431,9 @@ gimp_navigation_editor_new_private (GimpDisplayShell *shell, { GimpView *view = GIMP_VIEW (editor->view); - gimp_preview_renderer_set_size (view->renderer, - config->nav_preview_size * 3, - view->renderer->border_width); + gimp_view_renderer_set_size (view->renderer, + config->nav_preview_size * 3, + view->renderer->border_width); } else { @@ -530,8 +530,8 @@ gimp_navigation_editor_new_private (GimpDisplayShell *shell, if (shell) gimp_navigation_editor_set_shell (editor, shell); - gimp_preview_renderer_set_background (GIMP_VIEW (editor->view)->renderer, - GIMP_STOCK_TEXTURE); + gimp_view_renderer_set_background (GIMP_VIEW (editor->view)->renderer, + GIMP_STOCK_TEXTURE); return GTK_WIDGET (editor); } @@ -741,9 +741,9 @@ gimp_navigation_editor_shell_reconnect (GimpDisplayShell *shell, static void gimp_navigation_editor_update_marker (GimpNavigationEditor *editor) { - GimpPreviewRenderer *renderer; - gdouble xratio; - gdouble yratio; + GimpViewRenderer *renderer; + gdouble xratio; + gdouble yratio; renderer = GIMP_VIEW (editor->view)->renderer; @@ -751,8 +751,8 @@ gimp_navigation_editor_update_marker (GimpNavigationEditor *editor) yratio = SCALEFACTOR_Y (editor->shell); if (renderer->dot_for_dot != editor->shell->dot_for_dot) - gimp_preview_renderer_set_dot_for_dot (renderer, - editor->shell->dot_for_dot); + gimp_view_renderer_set_dot_for_dot (renderer, + editor->shell->dot_for_dot); gimp_navigation_preview_set_marker (GIMP_NAVIGATION_PREVIEW (editor->view), editor->shell->offset_x / xratio, diff --git a/app/widgets/Makefile.am b/app/widgets/Makefile.am index 4574e1c1f9..9f6450eec0 100644 --- a/app/widgets/Makefile.am +++ b/app/widgets/Makefile.am @@ -188,10 +188,6 @@ libappwidgets_a_sources = \ gimppdbdialog.h \ gimppluginaction.c \ gimppluginaction.h \ - gimppreview-popup.c \ - gimppreview-popup.h \ - gimppreviewrenderer.c \ - gimppreviewrenderer.h \ gimppreviewrenderer-utils.c \ gimppreviewrenderer-utils.h \ gimppreviewrendererbrush.c \ @@ -260,10 +256,14 @@ libappwidgets_a_sources = \ gimpvectorstreeview.h \ gimpview.c \ gimpview.h \ + gimpview-popup.c \ + gimpview-popup.h \ gimpviewablebutton.c \ gimpviewablebutton.h \ gimpviewabledialog.c \ gimpviewabledialog.h \ + gimpviewrenderer.c \ + gimpviewrenderer.h \ gimpwidgets-constructors.c \ gimpwidgets-constructors.h \ gimpwidgets-utils.c \ diff --git a/app/widgets/gimpbrushfactoryview.c b/app/widgets/gimpbrushfactoryview.c index 0ca501325e..0a578ace77 100644 --- a/app/widgets/gimpbrushfactoryview.c +++ b/app/widgets/gimpbrushfactoryview.c @@ -35,7 +35,7 @@ #include "gimpcontainerview.h" #include "gimpbrushfactoryview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimp-intl.h" @@ -45,12 +45,12 @@ static void gimp_brush_factory_view_init (GimpBrushFactoryView *vie static void gimp_brush_factory_view_destroy (GtkObject *object); static void gimp_brush_factory_view_select_item (GimpContainerEditor *editor, - GimpViewable *viewable); + GimpViewable *viewable); static void gimp_brush_factory_view_spacing_changed (GimpBrush *brush, - GimpBrushFactoryView *view); + GimpBrushFactoryView *view); static void gimp_brush_factory_view_spacing_update (GtkAdjustment *adjustment, - GimpBrushFactoryView *view); + GimpBrushFactoryView *view); static GimpDataFactoryViewClass *parent_class = NULL; @@ -120,8 +120,8 @@ gimp_brush_factory_view_init (GimpBrushFactoryView *view) view->spacing_scale = GIMP_SCALE_ENTRY_SCALE (view->spacing_adjustment); g_signal_connect (view->spacing_adjustment, "value_changed", - G_CALLBACK (gimp_brush_factory_view_spacing_update), - view); + G_CALLBACK (gimp_brush_factory_view_spacing_update), + view); view->spacing_changed_handler_id = 0; } @@ -149,22 +149,22 @@ gimp_brush_factory_view_destroy (GtkObject *object) GtkWidget * gimp_brush_factory_view_new (GimpViewType view_type, - GimpDataFactory *factory, - GimpDataEditFunc edit_func, - GimpContext *context, - gboolean change_brush_spacing, - gint preview_size, - gint preview_border_width, - GimpMenuFactory *menu_factory) + GimpDataFactory *factory, + GimpDataEditFunc edit_func, + GimpContext *context, + gboolean change_brush_spacing, + gint view_size, + gint view_border_width, + GimpMenuFactory *menu_factory) { GimpBrushFactoryView *factory_view; GimpContainerEditor *editor; g_return_val_if_fail (GIMP_IS_DATA_FACTORY (factory), NULL); - g_return_val_if_fail (preview_size > 0 && - preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); - g_return_val_if_fail (preview_border_width >= 0 && - preview_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, + g_return_val_if_fail (view_size > 0 && + view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); + g_return_val_if_fail (view_border_width >= 0 && + view_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); factory_view = g_object_new (GIMP_TYPE_BRUSH_FACTORY_VIEW, NULL); @@ -172,12 +172,12 @@ gimp_brush_factory_view_new (GimpViewType view_type, factory_view->change_brush_spacing = change_brush_spacing; if (! gimp_data_factory_view_construct (GIMP_DATA_FACTORY_VIEW (factory_view), - view_type, - factory, - edit_func, - context, - preview_size, preview_border_width, - menu_factory, "", + view_type, + factory, + edit_func, + context, + view_size, view_border_width, + menu_factory, "", "/brushes-popup", "brushes")) { @@ -202,7 +202,7 @@ gimp_brush_factory_view_new (GimpViewType view_type, static void gimp_brush_factory_view_select_item (GimpContainerEditor *editor, - GimpViewable *viewable) + GimpViewable *viewable) { GimpBrushFactoryView *view = GIMP_BRUSH_FACTORY_VIEW (editor); GimpContainer *container; @@ -220,15 +220,15 @@ gimp_brush_factory_view_select_item (GimpContainerEditor *editor, spacing_sensitive = TRUE; g_signal_handlers_block_by_func (view->spacing_adjustment, - gimp_brush_factory_view_spacing_update, - view); + gimp_brush_factory_view_spacing_update, + view); gtk_adjustment_set_value (view->spacing_adjustment, - gimp_brush_get_spacing (brush)); + gimp_brush_get_spacing (brush)); g_signal_handlers_unblock_by_func (view->spacing_adjustment, - gimp_brush_factory_view_spacing_update, - view); + gimp_brush_factory_view_spacing_update, + view); } gtk_widget_set_sensitive (view->spacing_scale, spacing_sensitive); @@ -236,7 +236,7 @@ gimp_brush_factory_view_select_item (GimpContainerEditor *editor, static void gimp_brush_factory_view_spacing_changed (GimpBrush *brush, - GimpBrushFactoryView *view) + GimpBrushFactoryView *view) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view); GimpContext *context; @@ -246,21 +246,21 @@ gimp_brush_factory_view_spacing_changed (GimpBrush *brush, if (brush == gimp_context_get_brush (context)) { g_signal_handlers_block_by_func (view->spacing_adjustment, - gimp_brush_factory_view_spacing_update, - view); + gimp_brush_factory_view_spacing_update, + view); gtk_adjustment_set_value (view->spacing_adjustment, - gimp_brush_get_spacing (brush)); + gimp_brush_get_spacing (brush)); g_signal_handlers_unblock_by_func (view->spacing_adjustment, - gimp_brush_factory_view_spacing_update, - view); + gimp_brush_factory_view_spacing_update, + view); } } static void gimp_brush_factory_view_spacing_update (GtkAdjustment *adjustment, - GimpBrushFactoryView *view) + GimpBrushFactoryView *view) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view); GimpContext *context; @@ -273,13 +273,13 @@ gimp_brush_factory_view_spacing_update (GtkAdjustment *adjustment, if (brush && view->change_brush_spacing) { g_signal_handlers_block_by_func (brush, - gimp_brush_factory_view_spacing_changed, - view); + gimp_brush_factory_view_spacing_changed, + view); gimp_brush_set_spacing (brush, adjustment->value); g_signal_handlers_unblock_by_func (brush, - gimp_brush_factory_view_spacing_changed, - view); + gimp_brush_factory_view_spacing_changed, + view); } } diff --git a/app/widgets/gimpbufferview.c b/app/widgets/gimpbufferview.c index 6bbab75515..6cfc5a39cf 100644 --- a/app/widgets/gimpbufferview.c +++ b/app/widgets/gimpbufferview.c @@ -38,7 +38,7 @@ #include "gimpdnd.h" #include "gimphelp-ids.h" #include "gimpview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpuimanager.h" #include "gimp-intl.h" @@ -262,8 +262,8 @@ gimp_buffer_view_preview_notify (GimpContainerView *container_view, view_size = gimp_container_view_get_preview_size (container_view, &view_border_width); - gimp_preview_renderer_set_size (view->renderer, - view_size, view_border_width); + gimp_view_renderer_set_size (view->renderer, + view_size, view_border_width); gtk_widget_set_size_request (buffer_view->global_preview, view_size + 2 * view_border_width, view_size + 2 * view_border_width); diff --git a/app/widgets/gimpcellrendererviewable.c b/app/widgets/gimpcellrendererviewable.c index c3a1f8cf40..536278c7e7 100644 --- a/app/widgets/gimpcellrendererviewable.c +++ b/app/widgets/gimpcellrendererviewable.c @@ -29,8 +29,8 @@ #include "core/gimpviewable.h" #include "gimpcellrendererviewable.h" -#include "gimppreview-popup.h" -#include "gimppreviewrenderer.h" +#include "gimpview-popup.h" +#include "gimpviewrenderer.h" enum @@ -147,7 +147,7 @@ gimp_cell_renderer_viewable_class_init (GimpCellRendererViewableClass *klass) PROP_RENDERER, g_param_spec_object ("renderer", NULL, NULL, - GIMP_TYPE_PREVIEW_RENDERER, + GIMP_TYPE_VIEW_RENDERER, G_PARAM_READWRITE)); } @@ -203,9 +203,9 @@ gimp_cell_renderer_viewable_set_property (GObject *object, { case PROP_RENDERER: { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; - renderer = (GimpPreviewRenderer *) g_value_dup_object (value); + renderer = (GimpViewRenderer *) g_value_dup_object (value); if (cell->renderer) g_object_unref (cell->renderer); cell->renderer = renderer; @@ -228,8 +228,8 @@ gimp_cell_renderer_viewable_get_size (GtkCellRenderer *cell, gint *height) { GimpCellRendererViewable *cellviewable; - gint preview_width = 0; - gint preview_height = 0; + gint view_width = 0; + gint view_height = 0; gint calc_width; gint calc_height; @@ -237,19 +237,19 @@ gimp_cell_renderer_viewable_get_size (GtkCellRenderer *cell, if (cellviewable->renderer) { - preview_width = (cellviewable->renderer->width + - 2 * cellviewable->renderer->border_width); - preview_height = (cellviewable->renderer->height + - 2 * cellviewable->renderer->border_width); + view_width = (cellviewable->renderer->width + + 2 * cellviewable->renderer->border_width); + view_height = (cellviewable->renderer->height + + 2 * cellviewable->renderer->border_width); } - calc_width = (gint) cell->xpad * 2 + preview_width; - calc_height = (gint) cell->ypad * 2 + preview_height; + calc_width = (gint) cell->xpad * 2 + view_width; + calc_height = (gint) cell->ypad * 2 + view_height; if (x_offset) *x_offset = 0; if (y_offset) *y_offset = 0; - if (cell_area && preview_width > 0 && preview_height > 0) + if (cell_area && view_width > 0 && view_height > 0) { if (x_offset) { @@ -288,17 +288,17 @@ gimp_cell_renderer_viewable_render (GtkCellRenderer *cell, if (! (flags & GTK_CELL_RENDERER_SELECTED)) { /* this is an ugly hack. The cell state should be passed to - * the preview renderer, so that it can adjust its border. + * the view renderer, so that it can adjust its border. * (or something like this) */ - if (cellviewable->renderer->border_type == GIMP_PREVIEW_BORDER_WHITE) - gimp_preview_renderer_set_border_type (cellviewable->renderer, - GIMP_PREVIEW_BORDER_BLACK); + if (cellviewable->renderer->border_type == GIMP_VIEW_BORDER_WHITE) + gimp_view_renderer_set_border_type (cellviewable->renderer, + GIMP_VIEW_BORDER_BLACK); - gimp_preview_renderer_remove_idle (cellviewable->renderer); + gimp_view_renderer_remove_idle (cellviewable->renderer); } - gimp_preview_renderer_draw (cellviewable->renderer, window, widget, - cell_area, expose_area); + gimp_view_renderer_draw (cellviewable->renderer, window, widget, + cell_area, expose_area); } } @@ -362,12 +362,12 @@ gimp_cell_renderer_viewable_clicked (GimpCellRendererViewable *cell, if (bevent->type == GDK_BUTTON_PRESS && (bevent->button == 1 || bevent->button == 2)) { - gimp_preview_popup_show (gtk_get_event_widget (event), - bevent, - cell->renderer->viewable, - cell->renderer->width, - cell->renderer->height, - cell->renderer->dot_for_dot); + gimp_view_popup_show (gtk_get_event_widget (event), + bevent, + cell->renderer->viewable, + cell->renderer->width, + cell->renderer->height, + cell->renderer->dot_for_dot); } gdk_event_free (event); diff --git a/app/widgets/gimpcellrendererviewable.h b/app/widgets/gimpcellrendererviewable.h index fe0d3ec393..5e158e4fa9 100644 --- a/app/widgets/gimpcellrendererviewable.h +++ b/app/widgets/gimpcellrendererviewable.h @@ -38,9 +38,9 @@ typedef struct _GimpCellRendererViewableClass GimpCellRendererViewableClass; struct _GimpCellRendererViewable { - GtkCellRenderer parent_instance; + GtkCellRenderer parent_instance; - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; }; struct _GimpCellRendererViewableClass diff --git a/app/widgets/gimpcomponenteditor.c b/app/widgets/gimpcomponenteditor.c index bd433c750f..2d121e80fb 100644 --- a/app/widgets/gimpcomponenteditor.c +++ b/app/widgets/gimpcomponenteditor.c @@ -71,10 +71,10 @@ static gboolean gimp_component_editor_select (GtkTreeSelection *select static gboolean gimp_component_editor_button_press (GtkWidget *widget, GdkEventButton *bevent, GimpComponentEditor *editor); -static void gimp_component_editor_renderer_update (GimpPreviewRenderer *renderer, +static void gimp_component_editor_renderer_update (GimpViewRenderer *renderer, GimpComponentEditor *editor); static void gimp_component_editor_mode_changed (GimpImage *gimage, - GimpComponentEditor *editor); + GimpComponentEditor *editor); static void gimp_component_editor_alpha_changed (GimpImage *gimage, GimpComponentEditor *editor); static void gimp_component_editor_visibility_changed(GimpImage *gimage, @@ -146,7 +146,7 @@ gimp_component_editor_init (GimpComponentEditor *editor) list = gtk_list_store_new (NUM_COLUMNS, G_TYPE_INT, G_TYPE_BOOLEAN, - GIMP_TYPE_PREVIEW_RENDERER, + GIMP_TYPE_VIEW_RENDERER, G_TYPE_STRING); editor->model = GTK_TREE_MODEL (list); @@ -207,13 +207,13 @@ gimp_component_editor_unrealize (GtkWidget *widget) iter_valid; iter_valid = gtk_tree_model_iter_next (editor->model, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (editor->model, &iter, COLUMN_RENDERER, &renderer, -1); - gimp_preview_renderer_unrealize (renderer); + gimp_view_renderer_unrealize (renderer); g_object_unref (renderer); } @@ -233,17 +233,17 @@ gimp_component_editor_set_image (GimpImageEditor *editor, gimp_component_editor_clear_components (component_editor); g_signal_handlers_disconnect_by_func (editor->gimage, - gimp_component_editor_mode_changed, - component_editor); + gimp_component_editor_mode_changed, + component_editor); g_signal_handlers_disconnect_by_func (editor->gimage, - gimp_component_editor_alpha_changed, - component_editor); + gimp_component_editor_alpha_changed, + component_editor); g_signal_handlers_disconnect_by_func (editor->gimage, - gimp_component_editor_visibility_changed, - component_editor); + gimp_component_editor_visibility_changed, + component_editor); g_signal_handlers_disconnect_by_func (editor->gimage, - gimp_component_editor_active_changed, - component_editor); + gimp_component_editor_active_changed, + component_editor); } GIMP_IMAGE_EDITOR_CLASS (parent_class)->set_image (editor, gimage); @@ -253,17 +253,17 @@ gimp_component_editor_set_image (GimpImageEditor *editor, gimp_component_editor_create_components (component_editor); g_signal_connect (editor->gimage, "mode_changed", - G_CALLBACK (gimp_component_editor_mode_changed), - component_editor); + G_CALLBACK (gimp_component_editor_mode_changed), + component_editor); g_signal_connect (editor->gimage, "alpha_changed", - G_CALLBACK (gimp_component_editor_alpha_changed), - component_editor); + G_CALLBACK (gimp_component_editor_alpha_changed), + component_editor); g_signal_connect (editor->gimage, "component_visibility_changed", - G_CALLBACK (gimp_component_editor_visibility_changed), - component_editor); + G_CALLBACK (gimp_component_editor_visibility_changed), + component_editor); g_signal_connect (editor->gimage, "component_active_changed", - G_CALLBACK (gimp_component_editor_active_changed), - component_editor); + G_CALLBACK (gimp_component_editor_active_changed), + component_editor); } } @@ -274,7 +274,7 @@ gimp_component_editor_new (gint preview_size, GimpComponentEditor *editor; g_return_val_if_fail (preview_size > 0 && - preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); + preview_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, @@ -319,13 +319,13 @@ gimp_component_editor_set_preview_size (GimpComponentEditor *editor, iter_valid; iter_valid = gtk_tree_model_iter_next (editor->model, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (editor->model, &iter, COLUMN_RENDERER, &renderer, -1); - gimp_preview_renderer_set_size (renderer, preview_size, 1); + gimp_view_renderer_set_size (renderer, preview_size, 1); g_object_unref (renderer); } @@ -372,17 +372,17 @@ gimp_component_editor_create_components (GimpComponentEditor *editor) for (i = 0; i < n_components; i++) { - GimpPreviewRenderer *renderer; - gboolean visible; - GEnumValue *enum_value; - GtkTreeIter iter; + GimpViewRenderer *renderer; + gboolean visible; + GEnumValue *enum_value; + GtkTreeIter iter; visible = gimp_image_get_component_visible (gimage, components[i]); - renderer = gimp_preview_renderer_new (G_TYPE_FROM_INSTANCE (gimage), - editor->preview_size, 1, FALSE); - gimp_preview_renderer_set_viewable (renderer, GIMP_VIEWABLE (gimage)); - gimp_preview_renderer_remove_idle (renderer); + renderer = gimp_view_renderer_new (G_TYPE_FROM_INSTANCE (gimage), + editor->preview_size, 1, FALSE); + gimp_view_renderer_set_viewable (renderer, GIMP_VIEWABLE (gimage)); + gimp_view_renderer_remove_idle (renderer); GIMP_PREVIEW_RENDERER_IMAGE (renderer)->channel = components[i]; @@ -546,7 +546,7 @@ gimp_component_editor_get_iter (GimpComponentEditor *editor, } static void -gimp_component_editor_renderer_update (GimpPreviewRenderer *renderer, +gimp_component_editor_renderer_update (GimpViewRenderer *renderer, GimpComponentEditor *editor) { GtkTreeIter iter; diff --git a/app/widgets/gimpcontainerbox.c b/app/widgets/gimpcontainerbox.c index 6c492f826f..a90ec8b985 100644 --- a/app/widgets/gimpcontainerbox.c +++ b/app/widgets/gimpcontainerbox.c @@ -37,7 +37,7 @@ #include "gimpdnd.h" #include "gimpdocked.h" #include "gimpview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimppropwidgets.h" @@ -237,8 +237,8 @@ gimp_container_box_get_preview (GimpDocked *docked, preview = gimp_prop_preview_new (G_OBJECT (context), prop_name, height); GIMP_VIEW (preview)->renderer->size = -1; - gimp_preview_renderer_set_size_full (GIMP_VIEW (preview)->renderer, - width, height, border_width); + gimp_view_renderer_set_size_full (GIMP_VIEW (preview)->renderer, + width, height, border_width); return preview; } diff --git a/app/widgets/gimpcontainercombobox.c b/app/widgets/gimpcontainercombobox.c index 414941e311..3972c2888e 100644 --- a/app/widgets/gimpcontainercombobox.c +++ b/app/widgets/gimpcontainercombobox.c @@ -34,7 +34,7 @@ #include "gimpcellrendererviewable.h" #include "gimpcontainercombobox.h" #include "gimpcontainerview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" enum @@ -51,27 +51,27 @@ static void gimp_container_combo_box_init (GimpContainerComboBox *v static void gimp_container_combo_box_view_iface_init (GimpContainerViewInterface *view_iface); static gpointer gimp_container_combo_box_insert_item (GimpContainerView *view, - GimpViewable *viewable, - gint index); + GimpViewable *viewable, + gint index); static void gimp_container_combo_box_remove_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data); + GimpViewable *viewable, + gpointer insert_data); static void gimp_container_combo_box_reorder_item (GimpContainerView *view, - GimpViewable *viewable, - gint new_index, - gpointer insert_data); + GimpViewable *viewable, + gint new_index, + gpointer insert_data); static void gimp_container_combo_box_rename_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data); + GimpViewable *viewable, + gpointer insert_data); static gboolean gimp_container_combo_box_select_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data); + GimpViewable *viewable, + gpointer insert_data); static void gimp_container_combo_box_clear_items (GimpContainerView *view); static void gimp_container_combo_box_set_preview_size (GimpContainerView *view); static void gimp_container_combo_box_changed (GtkComboBox *combo_box, GimpContainerView *view); -static void gimp_container_combo_box_renderer_update (GimpPreviewRenderer *renderer, +static void gimp_container_combo_box_renderer_update (GimpViewRenderer *renderer, GimpContainerView *view); @@ -152,7 +152,7 @@ gimp_container_combo_box_init (GimpContainerComboBox *combo_box) GtkCellRenderer *cell; store = gtk_list_store_new (NUM_COLUMNS, - GIMP_TYPE_PREVIEW_RENDERER, + GIMP_TYPE_VIEW_RENDERER, G_TYPE_STRING); gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store)); @@ -235,12 +235,12 @@ gimp_container_combo_box_set (GimpContainerComboBox *combo_box, GtkTreeIter *iter, GimpViewable *viewable) { - GimpContainerView *view = GIMP_CONTAINER_VIEW (combo_box); - GtkTreeModel *model; - GimpPreviewRenderer *renderer; - gchar *name; - gint preview_size; - gint border_width; + GimpContainerView *view = GIMP_CONTAINER_VIEW (combo_box); + GtkTreeModel *model; + GimpViewRenderer *renderer; + gchar *name; + gint preview_size; + gint border_width; model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)); @@ -248,11 +248,11 @@ gimp_container_combo_box_set (GimpContainerComboBox *combo_box, name = gimp_viewable_get_description (viewable, NULL); - renderer = gimp_preview_renderer_new (G_TYPE_FROM_INSTANCE (viewable), - preview_size, border_width, - FALSE); - gimp_preview_renderer_set_viewable (renderer, viewable); - gimp_preview_renderer_remove_idle (renderer); + renderer = gimp_view_renderer_new (G_TYPE_FROM_INSTANCE (viewable), + preview_size, border_width, + FALSE); + gimp_view_renderer_set_viewable (renderer, viewable); + gimp_view_renderer_remove_idle (renderer); g_signal_connect (renderer, "update", G_CALLBACK (gimp_container_combo_box_renderer_update), @@ -271,8 +271,8 @@ gimp_container_combo_box_set (GimpContainerComboBox *combo_box, static gpointer gimp_container_combo_box_insert_item (GimpContainerView *view, - GimpViewable *viewable, - gint index) + GimpViewable *viewable, + gint index) { GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (view)); GtkTreeIter *iter; @@ -292,8 +292,8 @@ gimp_container_combo_box_insert_item (GimpContainerView *view, static void gimp_container_combo_box_remove_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data) + GimpViewable *viewable, + gpointer insert_data) { GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (view)); GtkTreeIter *iter = insert_data; @@ -317,9 +317,9 @@ gimp_container_combo_box_remove_item (GimpContainerView *view, static void gimp_container_combo_box_reorder_item (GimpContainerView *view, - GimpViewable *viewable, - gint new_index, - gpointer insert_data) + GimpViewable *viewable, + gint new_index, + gpointer insert_data) { GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (view)); GimpContainer *container = gimp_container_view_get_container (view); @@ -363,8 +363,8 @@ gimp_container_combo_box_reorder_item (GimpContainerView *view, static void gimp_container_combo_box_rename_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data) + GimpViewable *viewable, + gpointer insert_data) { GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (view)); GtkTreeIter *iter = insert_data; @@ -383,8 +383,8 @@ gimp_container_combo_box_rename_item (GimpContainerView *view, static gboolean gimp_container_combo_box_select_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data) + GimpViewable *viewable, + gpointer insert_data) { GtkComboBox *combo_box = GTK_COMBO_BOX (view); GtkTreeIter *iter = insert_data; @@ -434,13 +434,13 @@ gimp_container_combo_box_set_preview_size (GimpContainerView *view) iter_valid; iter_valid = gtk_tree_model_iter_next (model, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (model, &iter, COLUMN_RENDERER, &renderer, -1); - gimp_preview_renderer_set_size (renderer, preview_size, border_width); + gimp_view_renderer_set_size (renderer, preview_size, border_width); g_object_unref (renderer); } } @@ -456,7 +456,7 @@ gimp_container_combo_box_changed (GtkComboBox *combo_box, if (gtk_combo_box_get_active_iter (combo_box, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (gtk_combo_box_get_model (combo_box), &iter, COLUMN_RENDERER, &renderer, @@ -468,8 +468,8 @@ gimp_container_combo_box_changed (GtkComboBox *combo_box, } static void -gimp_container_combo_box_renderer_update (GimpPreviewRenderer *renderer, - GimpContainerView *view) +gimp_container_combo_box_renderer_update (GimpViewRenderer *renderer, + GimpContainerView *view) { GtkTreeIter *iter = gimp_container_view_lookup (view, renderer->viewable); diff --git a/app/widgets/gimpcontainereditor.c b/app/widgets/gimpcontainereditor.c index 218ef9dce2..7e75d521d0 100644 --- a/app/widgets/gimpcontainereditor.c +++ b/app/widgets/gimpcontainereditor.c @@ -37,7 +37,7 @@ #include "gimpcontainerview.h" #include "gimpdocked.h" #include "gimpmenufactory.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpuimanager.h" @@ -46,19 +46,19 @@ static void gimp_container_editor_init (GimpContainerEditor static void gimp_container_editor_docked_iface_init (GimpDockedInterface *docked_iface); static gboolean gimp_container_editor_select_item (GtkWidget *widget, - GimpViewable *viewable, - gpointer insert_data, - GimpContainerEditor *editor); + GimpViewable *viewable, + gpointer insert_data, + GimpContainerEditor *editor); static void gimp_container_editor_activate_item (GtkWidget *widget, - GimpViewable *viewable, - gpointer insert_data, - GimpContainerEditor *editor); + GimpViewable *viewable, + gpointer insert_data, + GimpContainerEditor *editor); static void gimp_container_editor_context_item (GtkWidget *widget, - GimpViewable *viewable, - gpointer insert_data, - GimpContainerEditor *editor); + GimpViewable *viewable, + gpointer insert_data, + GimpContainerEditor *editor); static void gimp_container_editor_real_context_item(GimpContainerEditor *editor, - GimpViewable *viewable); + GimpViewable *viewable); static GtkWidget * gimp_container_editor_get_preview (GimpDocked *docked, GimpContext *context, @@ -137,12 +137,12 @@ gimp_container_editor_docked_iface_init (GimpDockedInterface *docked_iface) gboolean gimp_container_editor_construct (GimpContainerEditor *editor, - GimpViewType view_type, - GimpContainer *container, - GimpContext *context, - gint preview_size, + GimpViewType view_type, + GimpContainer *container, + GimpContext *context, + gint preview_size, gint preview_border_width, - GimpMenuFactory *menu_factory, + GimpMenuFactory *menu_factory, const gchar *menu_identifier, const gchar *ui_identifier) { @@ -150,9 +150,9 @@ gimp_container_editor_construct (GimpContainerEditor *editor, g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE); g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE); g_return_val_if_fail (preview_size > 0 && - preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, FALSE); + preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, FALSE); g_return_val_if_fail (preview_border_width >= 0 && - preview_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, + preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, FALSE); g_return_val_if_fail (menu_factory == NULL || GIMP_IS_MENU_FACTORY (menu_factory), FALSE); @@ -161,7 +161,7 @@ gimp_container_editor_construct (GimpContainerEditor *editor, { case GIMP_VIEW_TYPE_GRID: editor->view = - GIMP_CONTAINER_VIEW (gimp_container_grid_view_new (container, + GIMP_CONTAINER_VIEW (gimp_container_grid_view_new (container, context, preview_size, preview_border_width)); @@ -169,7 +169,7 @@ gimp_container_editor_construct (GimpContainerEditor *editor, case GIMP_VIEW_TYPE_LIST: editor->view = - GIMP_CONTAINER_VIEW (gimp_container_tree_view_new (container, + GIMP_CONTAINER_VIEW (gimp_container_tree_view_new (container, context, preview_size, preview_border_width)); @@ -210,9 +210,9 @@ gimp_container_editor_construct (GimpContainerEditor *editor, static gboolean gimp_container_editor_select_item (GtkWidget *widget, - GimpViewable *viewable, - gpointer insert_data, - GimpContainerEditor *editor) + GimpViewable *viewable, + gpointer insert_data, + GimpContainerEditor *editor) { GimpContainerEditorClass *klass = GIMP_CONTAINER_EDITOR_GET_CLASS (editor); @@ -227,9 +227,9 @@ gimp_container_editor_select_item (GtkWidget *widget, static void gimp_container_editor_activate_item (GtkWidget *widget, - GimpViewable *viewable, - gpointer insert_data, - GimpContainerEditor *editor) + GimpViewable *viewable, + gpointer insert_data, + GimpContainerEditor *editor) { GimpContainerEditorClass *klass = GIMP_CONTAINER_EDITOR_GET_CLASS (editor); @@ -239,9 +239,9 @@ gimp_container_editor_activate_item (GtkWidget *widget, static void gimp_container_editor_context_item (GtkWidget *widget, - GimpViewable *viewable, - gpointer insert_data, - GimpContainerEditor *editor) + GimpViewable *viewable, + gpointer insert_data, + GimpContainerEditor *editor) { GimpContainerEditorClass *klass = GIMP_CONTAINER_EDITOR_GET_CLASS (editor); @@ -251,7 +251,7 @@ gimp_container_editor_context_item (GtkWidget *widget, static void gimp_container_editor_real_context_item (GimpContainerEditor *editor, - GimpViewable *viewable) + GimpViewable *viewable) { GimpContainer *container = gimp_container_view_get_container (editor->view); diff --git a/app/widgets/gimpcontainerentry.c b/app/widgets/gimpcontainerentry.c index 2fba09747a..b808aa297a 100644 --- a/app/widgets/gimpcontainerentry.c +++ b/app/widgets/gimpcontainerentry.c @@ -34,7 +34,7 @@ #include "gimpcellrendererviewable.h" #include "gimpcontainerentry.h" #include "gimpcontainerview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #define gimp_container_entry_get_model(entry) \ @@ -67,7 +67,7 @@ static void gimp_container_entry_set_preview_size (GimpContainerView *view) static void gimp_container_entry_changed (GtkEntry *entry, GimpContainerView *view); -static void gimp_container_entry_renderer_update (GimpPreviewRenderer *renderer, +static void gimp_container_entry_renderer_update (GimpViewRenderer *renderer, GimpContainerView *view); @@ -150,7 +150,7 @@ gimp_container_entry_init (GimpContainerEntry *entry) completion = gtk_entry_completion_new (); store = gtk_list_store_new (GIMP_CONTAINER_ENTRY_NUM_COLUMNS, - GIMP_TYPE_PREVIEW_RENDERER, + GIMP_TYPE_VIEW_RENDERER, G_TYPE_STRING); gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (store)); @@ -230,19 +230,19 @@ gimp_container_entry_set (GimpContainerEntry *entry, GtkTreeIter *iter, GimpViewable *viewable) { - GimpContainerView *view = GIMP_CONTAINER_VIEW (entry); - GtkTreeModel *model = gimp_container_entry_get_model (entry); - GimpPreviewRenderer *renderer; - gint preview_size; - gint border_width; + GimpContainerView *view = GIMP_CONTAINER_VIEW (entry); + GtkTreeModel *model = gimp_container_entry_get_model (entry); + GimpViewRenderer *renderer; + gint preview_size; + gint border_width; preview_size = gimp_container_view_get_preview_size (view, &border_width); - renderer = gimp_preview_renderer_new (G_TYPE_FROM_INSTANCE (viewable), - preview_size, border_width, - FALSE); - gimp_preview_renderer_set_viewable (renderer, viewable); - gimp_preview_renderer_remove_idle (renderer); + renderer = gimp_view_renderer_new (G_TYPE_FROM_INSTANCE (viewable), + preview_size, border_width, + FALSE); + gimp_view_renderer_set_viewable (renderer, viewable); + gimp_view_renderer_remove_idle (renderer); g_signal_connect (renderer, "update", G_CALLBACK (gimp_container_entry_renderer_update), @@ -401,13 +401,13 @@ gimp_container_entry_set_preview_size (GimpContainerView *view) iter_valid; iter_valid = gtk_tree_model_iter_next (model, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (model, &iter, GIMP_CONTAINER_ENTRY_COLUMN_RENDERER, &renderer, -1); - gimp_preview_renderer_set_size (renderer, preview_size, border_width); + gimp_view_renderer_set_size (renderer, preview_size, border_width); g_object_unref (renderer); } } @@ -432,8 +432,8 @@ gimp_container_entry_changed (GtkEntry *entry, } static void -gimp_container_entry_renderer_update (GimpPreviewRenderer *renderer, - GimpContainerView *view) +gimp_container_entry_renderer_update (GimpViewRenderer *renderer, + GimpContainerView *view) { GtkTreeIter *iter = gimp_container_view_lookup (view, renderer->viewable); diff --git a/app/widgets/gimpcontainergridview.c b/app/widgets/gimpcontainergridview.c index 6f4a2b6db5..c91465eb8b 100644 --- a/app/widgets/gimpcontainergridview.c +++ b/app/widgets/gimpcontainergridview.c @@ -37,7 +37,7 @@ #include "gimpcontainergridview.h" #include "gimpcontainerview.h" #include "gimpview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpwidgets-utils.h" #include "gtkhwrapbox.h" @@ -254,7 +254,7 @@ gimp_container_grid_view_new (GimpContainer *container, g_return_val_if_fail (view_size > 0 && view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); g_return_val_if_fail (view_border_width >= 0 && - view_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, + view_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); grid_view = g_object_new (GIMP_TYPE_CONTAINER_GRID_VIEW, NULL); @@ -429,9 +429,9 @@ gimp_container_grid_view_insert_item (GimpContainerView *view, preview_size, 1, FALSE, TRUE, TRUE); - gimp_preview_renderer_set_border_type (GIMP_VIEW (preview)->renderer, - GIMP_PREVIEW_BORDER_WHITE); - gimp_preview_renderer_remove_idle (GIMP_VIEW (preview)->renderer); + gimp_view_renderer_set_border_type (GIMP_VIEW (preview)->renderer, + GIMP_VIEW_BORDER_WHITE); + gimp_view_renderer_remove_idle (GIMP_VIEW (preview)->renderer); gtk_wrap_box_pack (GTK_WRAP_BOX (grid_view->wrap_box), preview, FALSE, FALSE, FALSE, FALSE); @@ -539,9 +539,9 @@ gimp_container_grid_view_set_preview_size (GimpContainerView *view) { GimpView *view = GIMP_VIEW (child->widget); - gimp_preview_renderer_set_size (view->renderer, - preview_size, - view->renderer->border_width); + gimp_view_renderer_set_size (view->renderer, + preview_size, + view->renderer->border_width); } gtk_widget_queue_resize (grid_view->wrap_box); @@ -608,9 +608,9 @@ gimp_container_grid_view_highlight_item (GimpContainerView *view, if (grid_view->selected_item && grid_view->selected_item != preview) { - gimp_preview_renderer_set_border_type (grid_view->selected_item->renderer, - GIMP_PREVIEW_BORDER_WHITE); - gimp_preview_renderer_update (grid_view->selected_item->renderer); + gimp_view_renderer_set_border_type (grid_view->selected_item->renderer, + GIMP_VIEW_BORDER_WHITE); + gimp_view_renderer_update (grid_view->selected_item->renderer); } if (preview) @@ -644,8 +644,9 @@ gimp_container_grid_view_highlight_item (GimpContainerView *view, (row + 1) * item_height - adj->page_size); } - gimp_preview_renderer_set_border_type (preview->renderer, GIMP_PREVIEW_BORDER_BLACK); - gimp_preview_renderer_update (preview->renderer); + gimp_view_renderer_set_border_type (preview->renderer, + GIMP_VIEW_BORDER_BLACK); + gimp_view_renderer_update (preview->renderer); name = gimp_viewable_get_description (preview->renderer->viewable, NULL); gtk_label_set_text (GTK_LABEL (grid_view->name_label), name); diff --git a/app/widgets/gimpcontainerpopup.c b/app/widgets/gimpcontainerpopup.c index b1798cb3f5..b2d98a01ab 100644 --- a/app/widgets/gimpcontainerpopup.c +++ b/app/widgets/gimpcontainerpopup.c @@ -39,7 +39,7 @@ #include "gimpcontainertreeview.h" #include "gimpcontainerview.h" #include "gimpdialogfactory.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimp-intl.h" @@ -369,7 +369,7 @@ gimp_container_popup_new (GimpContainer *container, g_return_val_if_fail (preview_size > 0 && preview_size <= GIMP_VIEWABLE_MAX_POPUP_SIZE, NULL); g_return_val_if_fail (preview_border_width >= 0 && - preview_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, + preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); g_return_val_if_fail (dialog_factory == NULL || GIMP_IS_DIALOG_FACTORY (dialog_factory), NULL); diff --git a/app/widgets/gimpcontainertreeview-dnd.c b/app/widgets/gimpcontainertreeview-dnd.c index 1724f326b3..0457c37b7f 100644 --- a/app/widgets/gimpcontainertreeview-dnd.c +++ b/app/widgets/gimpcontainertreeview-dnd.c @@ -32,7 +32,7 @@ #include "gimpcontainertreeview-dnd.h" #include "gimpcontainerview.h" #include "gimpdnd.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpselectiondata.h" @@ -94,7 +94,7 @@ gimp_container_tree_view_drop_status (GimpContainerTreeView *tree_view, if (gtk_tree_view_get_path_at_pos (tree_view->view, x, y, &path, NULL, NULL, NULL)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; GimpViewable *dest_viewable; GtkTreeIter iter; GdkRectangle cell_area; diff --git a/app/widgets/gimpcontainertreeview.c b/app/widgets/gimpcontainertreeview.c index 1d57e526d7..462918d7ca 100644 --- a/app/widgets/gimpcontainertreeview.c +++ b/app/widgets/gimpcontainertreeview.c @@ -40,7 +40,7 @@ #include "gimpcontainertreeview-dnd.h" #include "gimpcontainerview.h" #include "gimpdnd.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpwidgets-utils.h" @@ -69,21 +69,21 @@ static void gimp_container_tree_view_set_container (GimpContainerView *v GimpContainer *container); static gpointer gimp_container_tree_view_insert_item (GimpContainerView *view, - GimpViewable *viewable, - gint index); + GimpViewable *viewable, + gint index); static void gimp_container_tree_view_remove_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data); + GimpViewable *viewable, + gpointer insert_data); static void gimp_container_tree_view_reorder_item (GimpContainerView *view, - GimpViewable *viewable, - gint new_index, - gpointer insert_data); + GimpViewable *viewable, + gint new_index, + gpointer insert_data); static void gimp_container_tree_view_rename_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data); + GimpViewable *viewable, + gpointer insert_data); static gboolean gimp_container_tree_view_select_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data); + GimpViewable *viewable, + gpointer insert_data); static void gimp_container_tree_view_clear_items (GimpContainerView *view); static void gimp_container_tree_view_set_preview_size (GimpContainerView *view); @@ -93,9 +93,9 @@ static void gimp_container_tree_view_name_canceled (GtkCellRendererText *c static void gimp_container_tree_view_selection_changed (GtkTreeSelection *sel, GimpContainerTreeView *tree_view); static gboolean gimp_container_tree_view_button_press (GtkWidget *widget, - GdkEventButton *bevent, - GimpContainerTreeView *tree_view); -static void gimp_container_tree_view_renderer_update (GimpPreviewRenderer *renderer, + GdkEventButton *bevent, + GimpContainerTreeView *tree_view); +static void gimp_container_tree_view_renderer_update (GimpViewRenderer *renderer, GimpContainerTreeView *tree_view); static GimpViewable * gimp_container_tree_view_drag_viewable (GtkWidget *widget, @@ -172,7 +172,7 @@ gimp_container_tree_view_init (GimpContainerTreeView *tree_view) tree_view->n_model_columns = NUM_COLUMNS; - tree_view->model_columns[COLUMN_RENDERER] = GIMP_TYPE_PREVIEW_RENDERER; + tree_view->model_columns[COLUMN_RENDERER] = GIMP_TYPE_VIEW_RENDERER; tree_view->model_columns[COLUMN_NAME] = G_TYPE_STRING; tree_view->model_columns[COLUMN_NAME_ATTRIBUTES] = PANGO_TYPE_ATTR_LIST; @@ -303,13 +303,13 @@ gimp_container_tree_view_unrealize (GtkWidget *widget) iter_valid; iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (tree_view->model, &iter, COLUMN_RENDERER, &renderer, -1); - gimp_preview_renderer_unrealize (renderer); + gimp_view_renderer_unrealize (renderer); g_object_unref (renderer); } @@ -401,7 +401,7 @@ gimp_container_tree_view_new (GimpContainer *container, g_return_val_if_fail (preview_size > 0 && preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); g_return_val_if_fail (preview_border_width >= 0 && - preview_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, + preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); tree_view = g_object_new (GIMP_TYPE_CONTAINER_TREE_VIEW, NULL); @@ -425,19 +425,19 @@ gimp_container_tree_view_set (GimpContainerTreeView *tree_view, GtkTreeIter *iter, GimpViewable *viewable) { - GimpContainerView *view = GIMP_CONTAINER_VIEW (tree_view); - GimpPreviewRenderer *renderer; - gchar *name; - gint preview_size; - gint border_width; + GimpContainerView *view = GIMP_CONTAINER_VIEW (tree_view); + GimpViewRenderer *renderer; + gchar *name; + gint preview_size; + gint border_width; preview_size = gimp_container_view_get_preview_size (view, &border_width); - renderer = gimp_preview_renderer_new (G_TYPE_FROM_INSTANCE (viewable), - preview_size, border_width, - FALSE); - gimp_preview_renderer_set_viewable (renderer, viewable); - gimp_preview_renderer_remove_idle (renderer); + renderer = gimp_view_renderer_new (G_TYPE_FROM_INSTANCE (viewable), + preview_size, border_width, + FALSE); + gimp_view_renderer_set_viewable (renderer, viewable); + gimp_view_renderer_remove_idle (renderer); g_signal_connect (renderer, "update", G_CALLBACK (gimp_container_tree_view_renderer_update), @@ -506,8 +506,8 @@ gimp_container_tree_view_set_container (GimpContainerView *view, static gpointer gimp_container_tree_view_insert_item (GimpContainerView *view, - GimpViewable *viewable, - gint index) + GimpViewable *viewable, + gint index) { GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view); GtkTreeIter *iter; @@ -526,8 +526,8 @@ gimp_container_tree_view_insert_item (GimpContainerView *view, static void gimp_container_tree_view_remove_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data) + GimpViewable *viewable, + gpointer insert_data) { GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view); GtkTreeIter *iter = (GtkTreeIter *) insert_data; @@ -554,9 +554,9 @@ gimp_container_tree_view_remove_item (GimpContainerView *view, static void gimp_container_tree_view_reorder_item (GimpContainerView *view, - GimpViewable *viewable, - gint new_index, - gpointer insert_data) + GimpViewable *viewable, + gint new_index, + gpointer insert_data) { GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view); GtkTreeIter *iter = (GtkTreeIter *) insert_data; @@ -575,7 +575,7 @@ gimp_container_tree_view_reorder_item (GimpContainerView *view, if (selected) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (tree_view->model, &selected_iter, COLUMN_RENDERER, &renderer, @@ -628,8 +628,8 @@ gimp_container_tree_view_reorder_item (GimpContainerView *view, static void gimp_container_tree_view_rename_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data) + GimpViewable *viewable, + gpointer insert_data) { GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view); GtkTreeIter *iter = (GtkTreeIter *) insert_data; @@ -648,8 +648,8 @@ gimp_container_tree_view_rename_item (GimpContainerView *view, static gboolean gimp_container_tree_view_select_item (GimpContainerView *view, - GimpViewable *viewable, - gpointer insert_data) + GimpViewable *viewable, + gpointer insert_data) { GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view); GtkTreeIter *iter = (GtkTreeIter *) insert_data; @@ -661,14 +661,14 @@ gimp_container_tree_view_select_item (GimpContainerView *view, path = gtk_tree_model_get_path (tree_view->model, iter); g_signal_handlers_block_by_func (tree_view->selection, - gimp_container_tree_view_selection_changed, - tree_view); + gimp_container_tree_view_selection_changed, + tree_view); gtk_tree_view_set_cursor (tree_view->view, path, NULL, FALSE); g_signal_handlers_unblock_by_func (tree_view->selection, - gimp_container_tree_view_selection_changed, - tree_view); + gimp_container_tree_view_selection_changed, + tree_view); gtk_tree_view_scroll_to_cell (tree_view->view, path, NULL, FALSE, 0.0, 0.0); @@ -735,13 +735,13 @@ gimp_container_tree_view_set_preview_size (GimpContainerView *view) iter_valid; iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (tree_view->model, &iter, COLUMN_RENDERER, &renderer, -1); - gimp_preview_renderer_set_size (renderer, preview_size, border_width); + gimp_view_renderer_set_size (renderer, preview_size, border_width); g_object_unref (renderer); } @@ -761,8 +761,8 @@ gimp_container_tree_view_name_canceled (GtkCellRendererText *cell, if (gtk_tree_selection_get_selected (tree_view->selection, NULL, &iter)) { - GimpPreviewRenderer *renderer; - gchar *name; + GimpViewRenderer *renderer; + gchar *name; gtk_tree_model_get (tree_view->model, &iter, tree_view->model_column_renderer, &renderer, @@ -789,7 +789,7 @@ gimp_container_tree_view_selection_changed (GtkTreeSelection *selection, if (gtk_tree_selection_get_selected (selection, NULL, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (tree_view->model, &iter, COLUMN_RENDERER, &renderer, @@ -854,7 +854,7 @@ gimp_container_tree_view_button_press (GtkWidget *widget, bevent->y, &path, &column, NULL, NULL)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; GimpCellRendererToggle *toggled_cell = NULL; GimpCellRendererViewable *clicked_cell = NULL; GtkCellRenderer *edit_cell = NULL; @@ -1024,7 +1024,7 @@ gimp_container_tree_view_button_press (GtkWidget *widget, } static void -gimp_container_tree_view_renderer_update (GimpPreviewRenderer *renderer, +gimp_container_tree_view_renderer_update (GimpViewRenderer *renderer, GimpContainerTreeView *tree_view) { GimpContainerView *view = GIMP_CONTAINER_VIEW (tree_view); diff --git a/app/widgets/gimpcontainerview.c b/app/widgets/gimpcontainerview.c index 124e4d1578..65565bb7e0 100644 --- a/app/widgets/gimpcontainerview.c +++ b/app/widgets/gimpcontainerview.c @@ -36,7 +36,7 @@ #include "gimpcontainerview.h" #include "gimpdnd.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" enum @@ -77,7 +77,7 @@ static GimpContainerViewPrivate * gimp_container_view_get_private (GimpContainerView *view); static void gimp_container_view_real_set_container (GimpContainerView *view, - GimpContainer *container); + GimpContainer *container); static void gimp_container_view_clear_items (GimpContainerView *view); static void gimp_container_view_real_clear_items (GimpContainerView *view); @@ -103,14 +103,14 @@ static void gimp_container_view_name_changed (GimpViewable *viewable GimpContainerView *view); static void gimp_container_view_context_changed (GimpContext *context, - GimpViewable *viewable, - GimpContainerView *view); + GimpViewable *viewable, + GimpContainerView *view); static void gimp_container_view_viewable_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data); + GimpViewable *viewable, + gpointer data); static void gimp_container_view_button_viewable_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data); + GimpViewable *viewable, + gpointer data); static guint view_signals[LAST_SIGNAL] = { 0 }; @@ -222,7 +222,7 @@ gimp_container_view_iface_base_init (GimpContainerViewInterface *view_iface) g_object_interface_install_property (view_iface, g_param_spec_int ("preview-border_width", NULL, NULL, - 0, GIMP_PREVIEW_MAX_BORDER_WIDTH, + 0, GIMP_VIEW_MAX_BORDER_WIDTH, 1, G_PARAM_READWRITE)); } @@ -299,7 +299,7 @@ gimp_container_view_get_container (GimpContainerView *view) void gimp_container_view_set_container (GimpContainerView *view, - GimpContainer *container) + GimpContainer *container) { GimpContainerViewPrivate *private; @@ -318,7 +318,7 @@ gimp_container_view_set_container (GimpContainerView *view, static void gimp_container_view_real_set_container (GimpContainerView *view, - GimpContainer *container) + GimpContainer *container) { GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view); @@ -331,34 +331,34 @@ gimp_container_view_real_set_container (GimpContainerView *view, private->name_changed_handler_id); g_signal_handlers_disconnect_by_func (private->container, - gimp_container_view_add, - view); + gimp_container_view_add, + view); g_signal_handlers_disconnect_by_func (private->container, - gimp_container_view_remove, - view); + gimp_container_view_remove, + view); g_signal_handlers_disconnect_by_func (private->container, - gimp_container_view_reorder, - view); + gimp_container_view_reorder, + view); g_signal_handlers_disconnect_by_func (private->container, - gimp_container_view_freeze, - view); + gimp_container_view_freeze, + view); g_signal_handlers_disconnect_by_func (private->container, - gimp_container_view_thaw, - view); + gimp_container_view_thaw, + view); if (private->context) - { - g_signal_handlers_disconnect_by_func (private->context, - gimp_container_view_context_changed, - view); + { + g_signal_handlers_disconnect_by_func (private->context, + gimp_container_view_context_changed, + view); - if (private->dnd_widget) - { - gtk_drag_dest_unset (private->dnd_widget); - gimp_dnd_viewable_dest_remove (private->dnd_widget, + if (private->dnd_widget) + { + gtk_drag_dest_unset (private->dnd_widget); + gimp_dnd_viewable_dest_remove (private->dnd_widget, private->container->children_type); - } - } + } + } } private->container = container; @@ -370,8 +370,8 @@ gimp_container_view_real_set_container (GimpContainerView *view, viewable_class = g_type_class_ref (container->children_type); gimp_container_foreach (private->container, - (GFunc) gimp_container_view_add_foreach, - view); + (GFunc) gimp_container_view_add_foreach, + view); private->name_changed_handler_id = gimp_container_add_handler (private->container, @@ -382,50 +382,50 @@ gimp_container_view_real_set_container (GimpContainerView *view, g_type_class_unref (viewable_class); g_signal_connect_object (private->container, "add", - G_CALLBACK (gimp_container_view_add), - view, - G_CONNECT_SWAPPED); + G_CALLBACK (gimp_container_view_add), + view, + G_CONNECT_SWAPPED); g_signal_connect_object (private->container, "remove", - G_CALLBACK (gimp_container_view_remove), - view, - G_CONNECT_SWAPPED); + G_CALLBACK (gimp_container_view_remove), + view, + G_CONNECT_SWAPPED); g_signal_connect_object (private->container, "reorder", - G_CALLBACK (gimp_container_view_reorder), - view, - G_CONNECT_SWAPPED); + G_CALLBACK (gimp_container_view_reorder), + view, + G_CONNECT_SWAPPED); g_signal_connect_object (private->container, "freeze", - G_CALLBACK (gimp_container_view_freeze), - view, - G_CONNECT_SWAPPED); + G_CALLBACK (gimp_container_view_freeze), + view, + G_CONNECT_SWAPPED); g_signal_connect_object (private->container, "thaw", - G_CALLBACK (gimp_container_view_thaw), - view, - G_CONNECT_SWAPPED); + G_CALLBACK (gimp_container_view_thaw), + view, + G_CONNECT_SWAPPED); if (private->context) - { - GimpObject *object; - const gchar *signal_name; + { + GimpObject *object; + const gchar *signal_name; - signal_name = - gimp_context_type_to_signal_name (private->container->children_type); + signal_name = + gimp_context_type_to_signal_name (private->container->children_type); - g_signal_connect_object (private->context, signal_name, - G_CALLBACK (gimp_container_view_context_changed), - view, - 0); + g_signal_connect_object (private->context, signal_name, + G_CALLBACK (gimp_container_view_context_changed), + view, + 0); - object = gimp_context_get_by_type (private->context, - private->container->children_type); + object = gimp_context_get_by_type (private->context, + private->container->children_type); - gimp_container_view_select_item (view, (GimpViewable *) object); + gimp_container_view_select_item (view, (GimpViewable *) object); - if (private->dnd_widget) + if (private->dnd_widget) gimp_dnd_viewable_dest_add (private->dnd_widget, private->container->children_type, gimp_container_view_viewable_dropped, view); - } + } } } @@ -443,7 +443,7 @@ gimp_container_view_get_context (GimpContainerView *view) void gimp_container_view_set_context (GimpContainerView *view, - GimpContext *context) + GimpContext *context) { GimpContainerViewPrivate *private; @@ -527,7 +527,7 @@ gimp_container_view_get_preview_size (GimpContainerView *view, void gimp_container_view_set_preview_size (GimpContainerView *view, - gint preview_size, + gint preview_size, gint preview_border_width) { GimpContainerViewPrivate *private; @@ -536,7 +536,7 @@ gimp_container_view_set_preview_size (GimpContainerView *view, g_return_if_fail (preview_size > 0 && preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE); g_return_if_fail (preview_border_width >= 0 && - preview_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH); + preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH); private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view); @@ -609,21 +609,21 @@ gimp_container_view_set_dnd_widget (GimpContainerView *view, void gimp_container_view_enable_dnd (GimpContainerView *view, - GtkButton *button, - GType children_type) + GtkButton *button, + GType children_type) { g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view)); g_return_if_fail (GTK_IS_BUTTON (button)); gimp_dnd_viewable_dest_add (GTK_WIDGET (button), - children_type, - gimp_container_view_button_viewable_dropped, - view); + children_type, + gimp_container_view_button_viewable_dropped, + view); } gboolean gimp_container_view_select_item (GimpContainerView *view, - GimpViewable *viewable) + GimpViewable *viewable) { GimpContainerViewPrivate *private; gboolean success = FALSE; @@ -647,7 +647,7 @@ gimp_container_view_select_item (GimpContainerView *view, void gimp_container_view_activate_item (GimpContainerView *view, - GimpViewable *viewable) + GimpViewable *viewable) { GimpContainerViewPrivate *private; gpointer insert_data; @@ -668,7 +668,7 @@ gimp_container_view_activate_item (GimpContainerView *view, void gimp_container_view_context_item (GimpContainerView *view, - GimpViewable *viewable) + GimpViewable *viewable) { GimpContainerViewPrivate *private; gpointer insert_data; @@ -706,7 +706,7 @@ gimp_container_view_lookup (GimpContainerView *view, gboolean gimp_container_view_item_selected (GimpContainerView *view, - GimpViewable *viewable) + GimpViewable *viewable) { GimpContainerViewPrivate *private; gboolean success; @@ -759,7 +759,7 @@ gimp_container_view_item_selected (GimpContainerView *view, void gimp_container_view_item_activated (GimpContainerView *view, - GimpViewable *viewable) + GimpViewable *viewable) { g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view)); g_return_if_fail (GIMP_IS_VIEWABLE (viewable)); @@ -769,7 +769,7 @@ gimp_container_view_item_activated (GimpContainerView *view, void gimp_container_view_item_context (GimpContainerView *view, - GimpViewable *viewable) + GimpViewable *viewable) { g_return_if_fail (GIMP_IS_CONTAINER_VIEW (view)); g_return_if_fail (GIMP_IS_VIEWABLE (viewable)); @@ -875,7 +875,7 @@ gimp_container_view_real_clear_items (GimpContainerView *view) static void gimp_container_view_add_foreach (GimpViewable *viewable, - GimpContainerView *view) + GimpContainerView *view) { GimpContainerViewInterface *view_iface; GimpContainerViewPrivate *private; @@ -896,8 +896,8 @@ gimp_container_view_add_foreach (GimpViewable *viewable, static void gimp_container_view_add (GimpContainerView *view, - GimpViewable *viewable, - GimpContainer *container) + GimpViewable *viewable, + GimpContainer *container) { GimpContainerViewInterface *view_iface; GimpContainerViewPrivate *private; @@ -925,8 +925,8 @@ gimp_container_view_add (GimpContainerView *view, static void gimp_container_view_remove (GimpContainerView *view, - GimpViewable *viewable, - GimpContainer *container) + GimpViewable *viewable, + GimpContainer *container) { GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view); gpointer insert_data; @@ -951,9 +951,9 @@ gimp_container_view_remove (GimpContainerView *view, static void gimp_container_view_reorder (GimpContainerView *view, - GimpViewable *viewable, - gint new_index, - GimpContainer *container) + GimpViewable *viewable, + gint new_index, + GimpContainer *container) { GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view); gpointer insert_data; @@ -1025,8 +1025,8 @@ gimp_container_view_name_changed (GimpViewable *viewable, static void gimp_container_view_context_changed (GimpContext *context, - GimpViewable *viewable, - GimpContainerView *view) + GimpViewable *viewable, + GimpContainerView *view) { if (! gimp_container_view_select_item (view, viewable)) g_warning ("%s: select_item() failed (should not happen)", G_STRFUNC); @@ -1034,8 +1034,8 @@ gimp_container_view_context_changed (GimpContext *context, static void gimp_container_view_viewable_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data) + GimpViewable *viewable, + gpointer data) { GimpContainerView *view = GIMP_CONTAINER_VIEW (data); GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view); @@ -1049,8 +1049,8 @@ gimp_container_view_viewable_dropped (GtkWidget *widget, static void gimp_container_view_button_viewable_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data) + GimpViewable *viewable, + gpointer data) { GimpContainerView *view = GIMP_CONTAINER_VIEW (data); GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view); diff --git a/app/widgets/gimpdatafactoryview.c b/app/widgets/gimpdatafactoryview.c index e9ca236751..88cf87233f 100644 --- a/app/widgets/gimpdatafactoryview.c +++ b/app/widgets/gimpdatafactoryview.c @@ -41,7 +41,7 @@ #include "gimpcontainergridview.h" #include "gimpcontainertreeview.h" #include "gimpdnd.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpuimanager.h" #include "gimpwidgets-utils.h" @@ -112,12 +112,12 @@ gimp_data_factory_view_init (GimpDataFactoryView *view) GtkWidget * gimp_data_factory_view_new (GimpViewType view_type, - GimpDataFactory *factory, - GimpDataEditFunc edit_func, - GimpContext *context, - gint preview_size, + GimpDataFactory *factory, + GimpDataEditFunc edit_func, + GimpContext *context, + gint preview_size, gint preview_border_width, - GimpMenuFactory *menu_factory, + GimpMenuFactory *menu_factory, const gchar *menu_identifier, const gchar *ui_identifier, const gchar *action_group) @@ -127,13 +127,13 @@ gimp_data_factory_view_new (GimpViewType view_type, factory_view = g_object_new (GIMP_TYPE_DATA_FACTORY_VIEW, NULL); if (! gimp_data_factory_view_construct (factory_view, - view_type, - factory, - edit_func, - context, - preview_size, + view_type, + factory, + edit_func, + context, + preview_size, preview_border_width, - menu_factory, + menu_factory, menu_identifier, ui_identifier, action_group)) @@ -147,13 +147,13 @@ gimp_data_factory_view_new (GimpViewType view_type, gboolean gimp_data_factory_view_construct (GimpDataFactoryView *factory_view, - GimpViewType view_type, - GimpDataFactory *factory, - GimpDataEditFunc edit_func, - GimpContext *context, - gint preview_size, + GimpViewType view_type, + GimpDataFactory *factory, + GimpDataEditFunc edit_func, + GimpContext *context, + gint preview_size, gint preview_border_width, - GimpMenuFactory *menu_factory, + GimpMenuFactory *menu_factory, const gchar *menu_identifier, const gchar *ui_identifier, const gchar *action_group) @@ -164,19 +164,19 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view, g_return_val_if_fail (GIMP_IS_DATA_FACTORY_VIEW (factory_view), FALSE); g_return_val_if_fail (GIMP_IS_DATA_FACTORY (factory), FALSE); g_return_val_if_fail (preview_size > 0 && - preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, FALSE); + preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, FALSE); g_return_val_if_fail (preview_border_width >= 0 && - preview_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, + preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, FALSE); factory_view->factory = factory; factory_view->data_edit_func = edit_func; if (! gimp_container_editor_construct (GIMP_CONTAINER_EDITOR (factory_view), - view_type, - factory->container, context, - preview_size, preview_border_width, - menu_factory, menu_identifier, + view_type, + factory->container, context, + preview_size, preview_border_width, + menu_factory, menu_identifier, ui_identifier)) { return FALSE; @@ -253,11 +253,11 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view, factory->container->children_type); gimp_container_view_enable_dnd (editor->view, - GTK_BUTTON (factory_view->duplicate_button), - factory->container->children_type); + GTK_BUTTON (factory_view->duplicate_button), + factory->container->children_type); gimp_container_view_enable_dnd (editor->view, - GTK_BUTTON (factory_view->delete_button), - factory->container->children_type); + GTK_BUTTON (factory_view->delete_button), + factory->container->children_type); gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor); @@ -266,7 +266,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view, static void gimp_data_factory_view_activate_item (GimpContainerEditor *editor, - GimpViewable *viewable) + GimpViewable *viewable) { GimpDataFactoryView *view = GIMP_DATA_FACTORY_VIEW (editor); GimpData *data = GIMP_DATA (viewable); @@ -297,8 +297,8 @@ gimp_data_factory_view_tree_name_edited (GtkCellRendererText *cell, if (gtk_tree_model_get_iter (tree_view->model, &iter, path)) { - GimpPreviewRenderer *renderer; - GimpData *data; + GimpViewRenderer *renderer; + GimpData *data; gtk_tree_model_get (tree_view->model, &iter, tree_view->model_column_renderer, &renderer, diff --git a/app/widgets/gimpitemtreeview.c b/app/widgets/gimpitemtreeview.c index d045fcf143..6ab23efd66 100644 --- a/app/widgets/gimpitemtreeview.c +++ b/app/widgets/gimpitemtreeview.c @@ -47,7 +47,7 @@ #include "gimpdocked.h" #include "gimplayertreeview.h" #include "gimpmenufactory.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpuimanager.h" #include "gimpvectorstreeview.h" #include "gimpwidgets-utils.h" @@ -636,7 +636,7 @@ gimp_item_tree_view_new (gint preview_size, g_return_val_if_fail (preview_size > 0 && preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); g_return_val_if_fail (preview_border_width >= 0 && - preview_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, + preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); g_return_val_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage), NULL); g_return_val_if_fail (signal_name != NULL, NULL); @@ -1256,8 +1256,8 @@ gimp_item_tree_view_name_edited (GtkCellRendererText *cell, if (gtk_tree_model_get_iter (tree_view->model, &iter, path)) { - GimpPreviewRenderer *renderer; - GimpItem *item; + GimpViewRenderer *renderer; + GimpItem *item; gtk_tree_model_get (tree_view->model, &iter, tree_view->model_column_renderer, &renderer, @@ -1398,10 +1398,10 @@ gimp_item_tree_view_toggle_clicked (GtkCellRendererToggle *toggle, if (gtk_tree_model_get_iter (tree_view->model, &iter, path)) { - GimpPreviewRenderer *renderer; - GimpItem *item; - GimpImage *gimage; - gboolean active; + GimpViewRenderer *renderer; + GimpItem *item; + GimpImage *gimage; + gboolean active; gtk_tree_model_get (tree_view->model, &iter, tree_view->model_column_renderer, &renderer, diff --git a/app/widgets/gimplayertreeview.c b/app/widgets/gimplayertreeview.c index 5eb54aedfb..1cdeb729a3 100644 --- a/app/widgets/gimplayertreeview.c +++ b/app/widgets/gimplayertreeview.c @@ -51,7 +51,7 @@ #include "gimpdnd.h" #include "gimphelp-ids.h" #include "gimplayertreeview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpuimanager.h" #include "gimpwidgets-constructors.h" @@ -70,16 +70,16 @@ static void gimp_layer_tree_view_finalize (GObject *object); static void gimp_layer_tree_view_unrealize (GtkWidget *widget); static void gimp_layer_tree_view_style_set (GtkWidget *widget, - GtkStyle *prev_style); + GtkStyle *prev_style); static void gimp_layer_tree_view_set_container (GimpContainerView *view, - GimpContainer *container); + GimpContainer *container); static gpointer gimp_layer_tree_view_insert_item (GimpContainerView *view, GimpViewable *viewable, gint index); static gboolean gimp_layer_tree_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); + GimpViewable *item, + gpointer insert_data); static void gimp_layer_tree_view_set_preview_size (GimpContainerView *view); static gboolean gimp_layer_tree_view_drop_possible(GimpContainerTreeView *view, @@ -113,28 +113,28 @@ static void gimp_layer_tree_view_floating_selection_changed static void gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget *widget, - GimpLayerTreeView *view); + GimpLayerTreeView *view); static void gimp_layer_tree_view_preserve_button_toggled (GtkWidget *widget, - GimpLayerTreeView *view); + GimpLayerTreeView *view); static void gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment *adj, - GimpLayerTreeView *view); + GimpLayerTreeView *view); static void gimp_layer_tree_view_layer_signal_handler (GimpLayer *layer, - GimpLayerTreeView *view); + GimpLayerTreeView *view); static void gimp_layer_tree_view_update_options (GimpLayerTreeView *view, - GimpLayer *layer); + GimpLayer *layer); static void gimp_layer_tree_view_update_menu (GimpLayerTreeView *view, - GimpLayer *layer); + GimpLayer *layer); static void gimp_layer_tree_view_mask_update (GimpLayerTreeView *view, GtkTreeIter *iter, GimpLayer *layer); static void gimp_layer_tree_view_mask_changed (GimpLayer *layer, GimpLayerTreeView *view); -static void gimp_layer_tree_view_renderer_update(GimpPreviewRenderer *renderer, +static void gimp_layer_tree_view_renderer_update(GimpViewRenderer *renderer, GimpLayerTreeView *view); static void gimp_layer_tree_view_update_borders (GimpLayerTreeView *view, @@ -272,7 +272,7 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view) * more info. */ view->model_column_mask = tree_view->n_model_columns; - tree_view->model_columns[tree_view->n_model_columns] = GIMP_TYPE_PREVIEW_RENDERER; + tree_view->model_columns[tree_view->n_model_columns] = GIMP_TYPE_VIEW_RENDERER; tree_view->n_model_columns++; view->model_column_mask_visible = tree_view->n_model_columns; @@ -291,9 +291,9 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view) view->paint_mode_menu = gimp_paint_mode_menu_new (G_CALLBACK (gimp_layer_tree_view_paint_mode_menu_callback), - view, - FALSE, - GIMP_NORMAL_MODE); + view, + FALSE, + GIMP_NORMAL_MODE); gtk_box_pack_start (GTK_BOX (hbox), view->paint_mode_menu, TRUE, TRUE, 0); gtk_widget_show (view->paint_mode_menu); @@ -307,8 +307,8 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view) gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", - G_CALLBACK (gimp_layer_tree_view_preserve_button_toggled), - view); + G_CALLBACK (gimp_layer_tree_view_preserve_button_toggled), + view); gimp_help_set_help_data (toggle, _("Keep transparency"), GIMP_HELP_LAYER_DIALOG_KEEP_TRANS_BUTTON); @@ -322,22 +322,22 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view) gtk_widget_show (image); gimp_table_attach_aligned (GTK_TABLE (view->options_box), 0, 0, - _("Mode:"), 0.0, 0.5, - hbox, 2, FALSE); + _("Mode:"), 0.0, 0.5, + hbox, 2, FALSE); /* Opacity scale */ view->opacity_adjustment = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (view->options_box), 0, 1, - _("Opacity:"), -1, -1, - 100.0, 0.0, 100.0, 1.0, 10.0, 1, - TRUE, 0.0, 0.0, - NULL, + _("Opacity:"), -1, -1, + 100.0, 0.0, 100.0, 1.0, 10.0, 1, + TRUE, 0.0, 0.0, + NULL, GIMP_HELP_LAYER_DIALOG_OPACITY_SCALE)); g_signal_connect (view->opacity_adjustment, "value_changed", - G_CALLBACK (gimp_layer_tree_view_opacity_scale_changed), - view); + G_CALLBACK (gimp_layer_tree_view_opacity_scale_changed), + view); /* Hide basically useless Edit button */ @@ -422,11 +422,11 @@ gimp_layer_tree_view_constructor (GType type, "layers-anchor", NULL); gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (layer_view)->button_box), - layer_view->anchor_button, 5); + layer_view->anchor_button, 5); gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (layer_view), - GTK_BUTTON (layer_view->anchor_button), - GIMP_TYPE_LAYER); + GTK_BUTTON (layer_view->anchor_button), + GIMP_TYPE_LAYER); return object; } @@ -463,7 +463,7 @@ gimp_layer_tree_view_unrealize (GtkWidget *widget) iter_valid; iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (tree_view->model, &iter, layer_view->model_column_mask, &renderer, @@ -471,7 +471,7 @@ gimp_layer_tree_view_unrealize (GtkWidget *widget) if (renderer) { - gimp_preview_renderer_unrealize (renderer); + gimp_view_renderer_unrealize (renderer); g_object_unref (renderer); } } @@ -481,7 +481,7 @@ gimp_layer_tree_view_unrealize (GtkWidget *widget) static void gimp_layer_tree_view_style_set (GtkWidget *widget, - GtkStyle *prev_style) + GtkStyle *prev_style) { GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (widget); gint content_spacing; @@ -490,12 +490,12 @@ gimp_layer_tree_view_style_set (GtkWidget *widget, gtk_widget_style_get (widget, "content_spacing", &content_spacing, "button_spacing", &button_spacing, - NULL); + NULL); gtk_table_set_col_spacings (GTK_TABLE (layer_view->options_box), - button_spacing); + button_spacing); gtk_table_set_row_spacings (GTK_TABLE (layer_view->options_box), - content_spacing); + content_spacing); if (GTK_WIDGET_CLASS (parent_class)->style_set) GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style); @@ -506,7 +506,7 @@ gimp_layer_tree_view_style_set (GtkWidget *widget, static void gimp_layer_tree_view_set_container (GimpContainerView *view, - GimpContainer *container) + GimpContainer *container) { GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view); GimpContainer *old_container; @@ -516,15 +516,15 @@ gimp_layer_tree_view_set_container (GimpContainerView *view, if (old_container) { gimp_container_remove_handler (old_container, - layer_view->mode_changed_handler_id); + layer_view->mode_changed_handler_id); gimp_container_remove_handler (old_container, - layer_view->opacity_changed_handler_id); + layer_view->opacity_changed_handler_id); gimp_container_remove_handler (old_container, - layer_view->preserve_trans_changed_handler_id); + layer_view->preserve_trans_changed_handler_id); gimp_container_remove_handler (old_container, - layer_view->mask_changed_handler_id); + layer_view->mask_changed_handler_id); gimp_container_remove_handler (old_container, - layer_view->alpha_changed_handler_id); + layer_view->alpha_changed_handler_id); } parent_view_iface->set_container (view, container); @@ -532,25 +532,25 @@ gimp_layer_tree_view_set_container (GimpContainerView *view, if (container) { layer_view->mode_changed_handler_id = - gimp_container_add_handler (container, "mode_changed", - G_CALLBACK (gimp_layer_tree_view_layer_signal_handler), - view); + gimp_container_add_handler (container, "mode_changed", + G_CALLBACK (gimp_layer_tree_view_layer_signal_handler), + view); layer_view->opacity_changed_handler_id = - gimp_container_add_handler (container, "opacity_changed", - G_CALLBACK (gimp_layer_tree_view_layer_signal_handler), - view); + gimp_container_add_handler (container, "opacity_changed", + G_CALLBACK (gimp_layer_tree_view_layer_signal_handler), + view); layer_view->preserve_trans_changed_handler_id = - gimp_container_add_handler (container, "preserve_trans_changed", - G_CALLBACK (gimp_layer_tree_view_layer_signal_handler), - view); + gimp_container_add_handler (container, "preserve_trans_changed", + G_CALLBACK (gimp_layer_tree_view_layer_signal_handler), + view); layer_view->mask_changed_handler_id = - gimp_container_add_handler (container, "mask_changed", - G_CALLBACK (gimp_layer_tree_view_mask_changed), - view); + gimp_container_add_handler (container, "mask_changed", + G_CALLBACK (gimp_layer_tree_view_mask_changed), + view); layer_view->alpha_changed_handler_id = - gimp_container_add_handler (container, "alpha_changed", - G_CALLBACK (gimp_layer_tree_view_alpha_changed), - view); + gimp_container_add_handler (container, "alpha_changed", + G_CALLBACK (gimp_layer_tree_view_alpha_changed), + view); } } @@ -577,8 +577,8 @@ gimp_layer_tree_view_insert_item (GimpContainerView *view, static gboolean gimp_layer_tree_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) + GimpViewable *item, + gpointer insert_data) { GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view); GimpLayerTreeView *layer_view = GIMP_LAYER_TREE_VIEW (view); @@ -601,23 +601,23 @@ gimp_layer_tree_view_select_item (GimpContainerView *view, options_sensitive = TRUE; if (! success || gimp_layer_is_floating_sel (GIMP_LAYER (item))) - { - gtk_widget_set_sensitive (item_view->edit_button, FALSE); - gtk_widget_set_sensitive (item_view->lower_button, FALSE); - gtk_widget_set_sensitive (item_view->duplicate_button, FALSE); - } + { + gtk_widget_set_sensitive (item_view->edit_button, FALSE); + gtk_widget_set_sensitive (item_view->lower_button, FALSE); + gtk_widget_set_sensitive (item_view->duplicate_button, FALSE); + } else - { + { GimpContainer *container; container = gimp_container_view_get_container (view); - if (gimp_drawable_has_alpha (GIMP_DRAWABLE (item)) && - gimp_container_get_child_index (container, GIMP_OBJECT (item))) - { - raise_sensitive = TRUE; - } - } + if (gimp_drawable_has_alpha (GIMP_DRAWABLE (item)) && + gimp_container_get_child_index (container, GIMP_OBJECT (item))) + { + raise_sensitive = TRUE; + } + } } gtk_widget_set_sensitive (layer_view->options_box, options_sensitive); @@ -642,7 +642,7 @@ gimp_layer_tree_view_set_preview_size (GimpContainerView *view) iter_valid; iter_valid = gtk_tree_model_iter_next (tree_view->model, &iter)) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gtk_tree_model_get (tree_view->model, &iter, layer_view->model_column_mask, &renderer, @@ -650,7 +650,7 @@ gimp_layer_tree_view_set_preview_size (GimpContainerView *view) if (renderer) { - gimp_preview_renderer_set_size (renderer, preview_size, border_width); + gimp_view_renderer_set_size (renderer, preview_size, border_width); g_object_unref (renderer); } } @@ -915,16 +915,16 @@ gimp_layer_tree_view_floating_selection_changed (GimpImage *gimage, #define BLOCK() \ g_signal_handlers_block_by_func (layer, \ - gimp_layer_tree_view_layer_signal_handler, view) + gimp_layer_tree_view_layer_signal_handler, view) #define UNBLOCK() \ g_signal_handlers_unblock_by_func (layer, \ - gimp_layer_tree_view_layer_signal_handler, view) + gimp_layer_tree_view_layer_signal_handler, view) static void gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget *widget, - GimpLayerTreeView *view) + GimpLayerTreeView *view) { GimpImage *gimage; GimpLayer *layer; @@ -937,11 +937,11 @@ gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget *widget, if (layer) { GimpLayerModeEffects mode = - GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), + GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "gimp-item-data")); if (gimp_layer_get_mode (layer) != mode) - { + { GimpUndo *undo; gboolean push_undo = TRUE; @@ -952,21 +952,21 @@ gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget *widget, if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer)) push_undo = FALSE; - BLOCK(); - gimp_layer_set_mode (layer, mode, push_undo); - UNBLOCK(); + BLOCK(); + gimp_layer_set_mode (layer, mode, push_undo); + UNBLOCK(); - gimp_image_flush (gimage); + gimp_image_flush (gimage); if (!push_undo) gimp_undo_refresh_preview (undo); - } + } } } static void gimp_layer_tree_view_preserve_button_toggled (GtkWidget *widget, - GimpLayerTreeView *view) + GimpLayerTreeView *view) { GimpImage *gimage; GimpLayer *layer; @@ -983,17 +983,17 @@ gimp_layer_tree_view_preserve_button_toggled (GtkWidget *widget, preserve_trans = GTK_TOGGLE_BUTTON (widget)->active; if (gimp_layer_get_preserve_trans (layer) != preserve_trans) - { - BLOCK(); - gimp_layer_set_preserve_trans (layer, preserve_trans, TRUE); - UNBLOCK(); - } + { + BLOCK(); + gimp_layer_set_preserve_trans (layer, preserve_trans, TRUE); + UNBLOCK(); + } } } static void gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment *adjustment, - GimpLayerTreeView *view) + GimpLayerTreeView *view) { GimpImage *gimage; GimpLayer *layer; @@ -1008,7 +1008,7 @@ gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment *adjustment, gdouble opacity = adjustment->value / 100.0; if (gimp_layer_get_opacity (layer) != opacity) - { + { GimpUndo *undo; gboolean push_undo = TRUE; @@ -1019,15 +1019,15 @@ gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment *adjustment, if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer)) push_undo = FALSE; - BLOCK(); - gimp_layer_set_opacity (layer, opacity, push_undo); - UNBLOCK(); + BLOCK(); + gimp_layer_set_opacity (layer, opacity, push_undo); + UNBLOCK(); - gimp_image_flush (gimage); + gimp_image_flush (gimage); if (!push_undo) gimp_undo_refresh_preview (undo); - } + } } } @@ -1037,7 +1037,7 @@ gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment *adjustment, static void gimp_layer_tree_view_layer_signal_handler (GimpLayer *layer, - GimpLayerTreeView *view) + GimpLayerTreeView *view) { GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (view); GimpLayer *active_layer; @@ -1058,34 +1058,34 @@ gimp_layer_tree_view_layer_signal_handler (GimpLayer *layer, static void gimp_layer_tree_view_update_options (GimpLayerTreeView *view, - GimpLayer *layer) + GimpLayer *layer) { gimp_paint_mode_menu_set_history (GTK_OPTION_MENU (view->paint_mode_menu), - layer->mode); + layer->mode); if (layer->preserve_trans != GTK_TOGGLE_BUTTON (view->preserve_trans_toggle)->active) { BLOCK (view->preserve_trans_toggle, - gimp_layer_tree_view_preserve_button_toggled); + gimp_layer_tree_view_preserve_button_toggled); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view->preserve_trans_toggle), - layer->preserve_trans); + layer->preserve_trans); UNBLOCK (view->preserve_trans_toggle, - gimp_layer_tree_view_preserve_button_toggled); + gimp_layer_tree_view_preserve_button_toggled); } if (layer->opacity * 100.0 != view->opacity_adjustment->value) { BLOCK (view->opacity_adjustment, - gimp_layer_tree_view_opacity_scale_changed); + gimp_layer_tree_view_opacity_scale_changed); gtk_adjustment_set_value (view->opacity_adjustment, layer->opacity * 100.0); UNBLOCK (view->opacity_adjustment, - gimp_layer_tree_view_opacity_scale_changed); + gimp_layer_tree_view_opacity_scale_changed); } } @@ -1127,7 +1127,7 @@ gimp_layer_tree_view_mask_update (GimpLayerTreeView *layer_view, GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view); GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view); GimpLayerMask *mask; - GimpPreviewRenderer *renderer = NULL; + GimpViewRenderer *renderer = NULL; gboolean mask_visible = FALSE; mask = gimp_layer_get_mask (layer); @@ -1142,10 +1142,10 @@ gimp_layer_tree_view_mask_update (GimpLayerTreeView *layer_view, mask_visible = TRUE; - renderer = gimp_preview_renderer_new (G_TYPE_FROM_INSTANCE (mask), - preview_size, border_width, - FALSE); - gimp_preview_renderer_set_viewable (renderer, GIMP_VIEWABLE (mask)); + renderer = gimp_view_renderer_new (G_TYPE_FROM_INSTANCE (mask), + preview_size, border_width, + FALSE); + gimp_view_renderer_set_viewable (renderer, GIMP_VIEWABLE (mask)); g_signal_connect (renderer, "update", G_CALLBACK (gimp_layer_tree_view_renderer_update), @@ -1167,7 +1167,7 @@ gimp_layer_tree_view_mask_update (GimpLayerTreeView *layer_view, if (renderer) { gimp_layer_tree_view_update_borders (layer_view, iter); - gimp_preview_renderer_remove_idle (renderer); + gimp_view_renderer_remove_idle (renderer); g_object_unref (renderer); } } @@ -1186,8 +1186,8 @@ gimp_layer_tree_view_mask_changed (GimpLayer *layer, } static void -gimp_layer_tree_view_renderer_update (GimpPreviewRenderer *renderer, - GimpLayerTreeView *layer_view) +gimp_layer_tree_view_renderer_update (GimpViewRenderer *renderer, + GimpLayerTreeView *layer_view) { GimpContainerView *view = GIMP_CONTAINER_VIEW (layer_view); GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view); @@ -1216,10 +1216,10 @@ gimp_layer_tree_view_update_borders (GimpLayerTreeView *layer_view, GtkTreeIter *iter) { GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (layer_view); - GimpPreviewRenderer *layer_renderer; - GimpPreviewRenderer *mask_renderer; + GimpViewRenderer *layer_renderer; + GimpViewRenderer *mask_renderer; GimpLayerMask *mask = NULL; - GimpPreviewBorderType layer_type = GIMP_PREVIEW_BORDER_BLACK; + GimpViewBorderType layer_type = GIMP_VIEW_BORDER_BLACK; gtk_tree_model_get (tree_view->model, iter, tree_view->model_column_renderer, &layer_renderer, @@ -1230,28 +1230,28 @@ gimp_layer_tree_view_update_borders (GimpLayerTreeView *layer_view, mask = GIMP_LAYER_MASK (mask_renderer->viewable); if (! mask || (mask && ! gimp_layer_mask_get_edit (mask))) - layer_type = GIMP_PREVIEW_BORDER_WHITE; + layer_type = GIMP_VIEW_BORDER_WHITE; - gimp_preview_renderer_set_border_type (layer_renderer, layer_type); + gimp_view_renderer_set_border_type (layer_renderer, layer_type); if (mask) { - GimpPreviewBorderType mask_color = GIMP_PREVIEW_BORDER_BLACK; + GimpViewBorderType mask_color = GIMP_VIEW_BORDER_BLACK; if (gimp_layer_mask_get_show (mask)) - { - mask_color = GIMP_PREVIEW_BORDER_GREEN; - } + { + mask_color = GIMP_VIEW_BORDER_GREEN; + } else if (! gimp_layer_mask_get_apply (mask)) - { - mask_color = GIMP_PREVIEW_BORDER_RED; - } + { + mask_color = GIMP_VIEW_BORDER_RED; + } else if (gimp_layer_mask_get_edit (mask)) - { - mask_color = GIMP_PREVIEW_BORDER_WHITE; - } + { + mask_color = GIMP_VIEW_BORDER_WHITE; + } - gimp_preview_renderer_set_border_type (mask_renderer, mask_color); + gimp_view_renderer_set_border_type (mask_renderer, mask_color); } if (layer_renderer) @@ -1288,9 +1288,9 @@ gimp_layer_tree_view_layer_clicked (GimpCellRendererViewable *cell, if (gtk_tree_model_get_iter (tree_view->model, &iter, path)) { - GimpPreviewRenderer *renderer; - GimpUIManager *ui_manager; - GimpActionGroup *group; + GimpViewRenderer *renderer; + GimpUIManager *ui_manager; + GimpActionGroup *group; ui_manager = GIMP_EDITOR (tree_view)->ui_manager; group = gimp_ui_manager_get_action_group (ui_manager, "layers"); @@ -1327,9 +1327,9 @@ gimp_layer_tree_view_mask_clicked (GimpCellRendererViewable *cell, if (gtk_tree_model_get_iter (tree_view->model, &iter, path)) { - GimpPreviewRenderer *renderer; - GimpUIManager *ui_manager; - GimpActionGroup *group; + GimpViewRenderer *renderer; + GimpUIManager *ui_manager; + GimpActionGroup *group; ui_manager = GIMP_EDITOR (tree_view)->ui_manager; group = gimp_ui_manager_get_action_group (ui_manager, "layers"); diff --git a/app/widgets/gimpnavigationpreview.c b/app/widgets/gimpnavigationpreview.c index 3f900d04f9..74b3db539d 100644 --- a/app/widgets/gimpnavigationpreview.c +++ b/app/widgets/gimpnavigationpreview.c @@ -35,7 +35,7 @@ #include "core/gimpmarshal.h" #include "gimpnavigationpreview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #define BORDER_PEN_WIDTH 3 diff --git a/app/widgets/gimpnavigationview.c b/app/widgets/gimpnavigationview.c index 3f900d04f9..74b3db539d 100644 --- a/app/widgets/gimpnavigationview.c +++ b/app/widgets/gimpnavigationview.c @@ -35,7 +35,7 @@ #include "core/gimpmarshal.h" #include "gimpnavigationpreview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #define BORDER_PEN_WIDTH 3 diff --git a/app/widgets/gimppatternfactoryview.c b/app/widgets/gimppatternfactoryview.c index 273d8e249e..d06cbda6f6 100644 --- a/app/widgets/gimppatternfactoryview.c +++ b/app/widgets/gimppatternfactoryview.c @@ -33,7 +33,7 @@ #include "gimpcontainerview.h" #include "gimppatternfactoryview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" GType @@ -66,31 +66,31 @@ gimp_pattern_factory_view_get_type (void) GtkWidget * gimp_pattern_factory_view_new (GimpViewType view_type, - GimpDataFactory *factory, - GimpDataEditFunc edit_func, - GimpContext *context, - gint preview_size, + GimpDataFactory *factory, + GimpDataEditFunc edit_func, + GimpContext *context, + gint preview_size, gint preview_border_width, - GimpMenuFactory *menu_factory) + GimpMenuFactory *menu_factory) { GimpPatternFactoryView *factory_view; g_return_val_if_fail (GIMP_IS_DATA_FACTORY (factory), NULL); g_return_val_if_fail (preview_size > 0 && - preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); + preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); g_return_val_if_fail (preview_border_width >= 0 && - preview_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, + preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); factory_view = g_object_new (GIMP_TYPE_PATTERN_FACTORY_VIEW, NULL); if (! gimp_data_factory_view_construct (GIMP_DATA_FACTORY_VIEW (factory_view), - view_type, - factory, - edit_func, - context, - preview_size, preview_border_width, - menu_factory, "", + view_type, + factory, + edit_func, + context, + preview_size, preview_border_width, + menu_factory, "", "/patterns-popup", "patterns")) { diff --git a/app/widgets/gimppreviewrenderer-utils.c b/app/widgets/gimppreviewrenderer-utils.c index 2754080e62..c9d156eee2 100644 --- a/app/widgets/gimppreviewrenderer-utils.c +++ b/app/widgets/gimppreviewrenderer-utils.c @@ -44,7 +44,7 @@ GType gimp_preview_renderer_type_from_viewable_type (GType viewable_type) { - GType type = GIMP_TYPE_PREVIEW_RENDERER; + GType type = GIMP_TYPE_VIEW_RENDERER; g_return_val_if_fail (g_type_is_a (viewable_type, GIMP_TYPE_VIEWABLE), G_TYPE_NONE); diff --git a/app/widgets/gimppreviewrendererbrush.c b/app/widgets/gimppreviewrendererbrush.c index 4b33be1957..fc8892fdcc 100644 --- a/app/widgets/gimppreviewrendererbrush.c +++ b/app/widgets/gimppreviewrendererbrush.c @@ -36,14 +36,14 @@ 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 (GimpPreviewRenderer *renderer, - GtkWidget *widget); +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 gboolean gimp_preview_renderer_brush_render_timeout (gpointer data); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -66,7 +66,7 @@ gimp_preview_renderer_brush_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_brush_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererBrush", &renderer_info, 0); } @@ -77,11 +77,11 @@ gimp_preview_renderer_brush_get_type (void) static void gimp_preview_renderer_brush_class_init (GimpPreviewRendererBrushClass *klass) { - GObjectClass *object_class; - GimpPreviewRendererClass *renderer_class; + GObjectClass *object_class; + GimpViewRendererClass *renderer_class; object_class = G_OBJECT_CLASS (klass); - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -112,8 +112,8 @@ gimp_preview_renderer_brush_finalize (GObject *object) } static void -gimp_preview_renderer_brush_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_brush_render (GimpViewRenderer *renderer, + GtkWidget *widget) { GimpPreviewRendererBrush *renderbrush; GimpBrush *brush; @@ -145,26 +145,26 @@ gimp_preview_renderer_brush_render (GimpPreviewRenderer *renderer, if (renderer->is_popup) { - gimp_preview_renderer_render_buffer (renderer, temp_buf, -1, - GIMP_PREVIEW_BG_WHITE, - GIMP_PREVIEW_BG_WHITE); + 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 = + { + renderbrush->pipe_animation_index = 0; + renderbrush->pipe_timeout_id = g_timeout_add (300, gimp_preview_renderer_brush_render_timeout, renderbrush); - } + } return; } - gimp_preview_renderer_render_buffer (renderer, temp_buf, -1, - GIMP_PREVIEW_BG_WHITE, - GIMP_PREVIEW_BG_WHITE); + gimp_view_renderer_render_buffer (renderer, temp_buf, -1, + GIMP_VIEW_BG_WHITE, + GIMP_VIEW_BG_WHITE); temp_buf_free (temp_buf); @@ -282,13 +282,13 @@ static gboolean gimp_preview_renderer_brush_render_timeout (gpointer data) { GimpPreviewRendererBrush *renderbrush; - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; GimpBrushPipe *brush_pipe; GimpBrush *brush; TempBuf *temp_buf; renderbrush = GIMP_PREVIEW_RENDERER_BRUSH (data); - renderer = GIMP_PREVIEW_RENDERER (data); + renderer = GIMP_VIEW_RENDERER (data); if (! renderer->viewable) { @@ -309,16 +309,16 @@ gimp_preview_renderer_brush_render_timeout (gpointer data) GIMP_BRUSH (brush_pipe->brushes[renderbrush->pipe_animation_index]); temp_buf = gimp_viewable_get_new_preview (GIMP_VIEWABLE (brush), - renderer->width, - renderer->height); + renderer->width, + renderer->height); - gimp_preview_renderer_render_buffer (renderer, temp_buf, -1, - GIMP_PREVIEW_BG_WHITE, - GIMP_PREVIEW_BG_WHITE); + gimp_view_renderer_render_buffer (renderer, temp_buf, -1, + GIMP_VIEW_BG_WHITE, + GIMP_VIEW_BG_WHITE); temp_buf_free (temp_buf); - gimp_preview_renderer_update (renderer); + gimp_view_renderer_update (renderer); return TRUE; } diff --git a/app/widgets/gimppreviewrendererbrush.h b/app/widgets/gimppreviewrendererbrush.h index 38a5c0a78d..8181bd3de6 100644 --- a/app/widgets/gimppreviewrendererbrush.h +++ b/app/widgets/gimppreviewrendererbrush.h @@ -22,7 +22,7 @@ #ifndef __GIMP_PREVIEW_RENDERER_BRUSH_H__ #define __GIMP_PREVIEW_RENDERER_BRUSH_H__ -#include "gimppreviewrenderer.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)) @@ -36,15 +36,15 @@ typedef struct _GimpPreviewRendererBrushClass GimpPreviewRendererBrushClass; struct _GimpPreviewRendererBrush { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; - guint pipe_timeout_id; - gint pipe_animation_index; + guint pipe_timeout_id; + gint pipe_animation_index; }; struct _GimpPreviewRendererBrushClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimppreviewrendererdrawable.c b/app/widgets/gimppreviewrendererdrawable.c index 11858e2262..71384a5725 100644 --- a/app/widgets/gimppreviewrendererdrawable.c +++ b/app/widgets/gimppreviewrendererdrawable.c @@ -38,11 +38,11 @@ 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 (GimpPreviewRenderer *renderer, - GtkWidget *widget); +static void gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer, + GtkWidget *widget); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -65,7 +65,7 @@ gimp_preview_renderer_drawable_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_drawable_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererDrawable", &renderer_info, 0); } @@ -76,9 +76,9 @@ gimp_preview_renderer_drawable_get_type (void) static void gimp_preview_renderer_drawable_class_init (GimpPreviewRendererDrawableClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -91,8 +91,8 @@ gimp_preview_renderer_drawable_init (GimpPreviewRendererDrawable *renderer) } static void -gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer, + GtkWidget *widget) { GimpDrawable *drawable; GimpItem *item; @@ -114,9 +114,9 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, if (gimage && ! renderer->is_popup) { width = MAX (1, ROUND ((((gdouble) width / (gdouble) gimage->width) * - (gdouble) item->width))); + (gdouble) item->width))); height = MAX (1, ROUND ((((gdouble) height / (gdouble) gimage->height) * - (gdouble) item->height))); + (gdouble) item->height))); gimp_viewable_calc_preview_size (item->width, item->height, @@ -149,7 +149,7 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, temp_buf = gimp_viewable_get_new_preview (renderer->viewable, item->width, - item->height); + item->height); if (temp_buf) { @@ -161,8 +161,8 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, else { render_buf = gimp_viewable_get_new_preview (renderer->viewable, - preview_width, - preview_height); + preview_width, + preview_height); } if (render_buf) @@ -188,9 +188,9 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, render_buf->y = (height - preview_height) / 2; } - gimp_preview_renderer_render_buffer (renderer, render_buf, -1, - GIMP_PREVIEW_BG_CHECKS, - GIMP_PREVIEW_BG_CHECKS); + gimp_view_renderer_render_buffer (renderer, render_buf, -1, + GIMP_VIEW_BG_CHECKS, + GIMP_VIEW_BG_CHECKS); temp_buf_free (render_buf); } @@ -200,6 +200,6 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, stock_id = gimp_viewable_get_stock_id (renderer->viewable); - gimp_preview_renderer_default_render_stock (renderer, widget, stock_id); + gimp_view_renderer_default_render_stock (renderer, widget, stock_id); } } diff --git a/app/widgets/gimppreviewrendererdrawable.h b/app/widgets/gimppreviewrendererdrawable.h index c986b39cb2..853cadc884 100644 --- a/app/widgets/gimppreviewrendererdrawable.h +++ b/app/widgets/gimppreviewrendererdrawable.h @@ -22,7 +22,7 @@ #ifndef __GIMP_PREVIEW_RENDERER_DRAWABLE_H__ #define __GIMP_PREVIEW_RENDERER_DRAWABLE_H__ -#include "gimppreviewrenderer.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)) @@ -36,12 +36,12 @@ typedef struct _GimpPreviewRendererDrawableClass GimpPreviewRendererDrawableCla struct _GimpPreviewRendererDrawable { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; }; struct _GimpPreviewRendererDrawableClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimppreviewrenderergradient.c b/app/widgets/gimppreviewrenderergradient.c index 9c3353ec49..b540277512 100644 --- a/app/widgets/gimppreviewrenderergradient.c +++ b/app/widgets/gimppreviewrenderergradient.c @@ -47,11 +47,11 @@ static void gimp_preview_renderer_gradient_init (GimpPreviewRendererGrad static void gimp_preview_renderer_gradient_finalize (GObject *object); -static void gimp_preview_renderer_gradient_render (GimpPreviewRenderer *renderer, +static void gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer, GtkWidget *widget); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -74,7 +74,7 @@ gimp_preview_renderer_gradient_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_gradient_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererGradient", &renderer_info, 0); } @@ -85,11 +85,11 @@ gimp_preview_renderer_gradient_get_type (void) static void gimp_preview_renderer_gradient_class_init (GimpPreviewRendererGradientClass *klass) { - GObjectClass *object_class; - GimpPreviewRendererClass *renderer_class; + GObjectClass *object_class; + GimpViewRendererClass *renderer_class; object_class = G_OBJECT_CLASS (klass); - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -132,8 +132,8 @@ gimp_preview_renderer_gradient_finalize (GObject *object) } static void -gimp_preview_renderer_gradient_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer, + GtkWidget *widget) { GimpPreviewRendererGradient *rendergrad; GimpGradient *gradient; @@ -237,10 +237,10 @@ gimp_preview_renderer_gradient_set_offsets (GimpPreviewRendererGradient *rendere renderer->left = left; renderer->right = right; - gimp_preview_renderer_invalidate (GIMP_PREVIEW_RENDERER (renderer)); + gimp_view_renderer_invalidate (GIMP_VIEW_RENDERER (renderer)); if (instant_update) - gimp_preview_renderer_update (GIMP_PREVIEW_RENDERER (renderer)); + gimp_view_renderer_update (GIMP_VIEW_RENDERER (renderer)); } } @@ -254,7 +254,7 @@ gimp_preview_renderer_gradient_set_reverse (GimpPreviewRendererGradient *rendere { renderer->reverse = reverse ? TRUE : FALSE; - gimp_preview_renderer_invalidate (GIMP_PREVIEW_RENDERER (renderer)); - gimp_preview_renderer_update (GIMP_PREVIEW_RENDERER (renderer)); + gimp_view_renderer_invalidate (GIMP_VIEW_RENDERER (renderer)); + gimp_view_renderer_update (GIMP_VIEW_RENDERER (renderer)); } } diff --git a/app/widgets/gimppreviewrenderergradient.h b/app/widgets/gimppreviewrenderergradient.h index 35248d456c..20d556e2e7 100644 --- a/app/widgets/gimppreviewrenderergradient.h +++ b/app/widgets/gimppreviewrenderergradient.h @@ -22,7 +22,7 @@ #ifndef __GIMP_PREVIEW_RENDERER_GRADIENT_H__ #define __GIMP_PREVIEW_RENDERER_GRADIENT_H__ -#include "gimppreviewrenderer.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)) @@ -36,20 +36,20 @@ typedef struct _GimpPreviewRendererGradientClass GimpPreviewRendererGradientCla struct _GimpPreviewRendererGradient { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; - guchar *even; - guchar *odd; - gint width; - gdouble left; - gdouble right; + guchar *even; + guchar *odd; + gint width; + gdouble left; + gdouble right; - gboolean reverse; + gboolean reverse; }; struct _GimpPreviewRendererGradientClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimppreviewrendererimage.c b/app/widgets/gimppreviewrendererimage.c index 21c4d25283..02d98da664 100644 --- a/app/widgets/gimppreviewrendererimage.c +++ b/app/widgets/gimppreviewrendererimage.c @@ -37,11 +37,11 @@ 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 (GimpPreviewRenderer *renderer, - GtkWidget *widget); +static void gimp_preview_renderer_image_render (GimpViewRenderer *renderer, + GtkWidget *widget); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -64,7 +64,7 @@ gimp_preview_renderer_image_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_image_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererImage", &renderer_info, 0); } @@ -75,9 +75,9 @@ gimp_preview_renderer_image_get_type (void) static void gimp_preview_renderer_image_class_init (GimpPreviewRendererImageClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -91,8 +91,8 @@ gimp_preview_renderer_image_init (GimpPreviewRendererImage *renderer) } static void -gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_image_render (GimpViewRenderer *renderer, + GtkWidget *widget) { GimpPreviewRendererImage *rendererimage; GimpImage *gimage; @@ -121,7 +121,7 @@ gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, TempBuf *temp_buf; temp_buf = gimp_viewable_get_new_preview (renderer->viewable, - gimage->width, gimage->height); + gimage->width, gimage->height); if (temp_buf) { @@ -134,8 +134,8 @@ gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, else { render_buf = gimp_viewable_get_new_preview (renderer->viewable, - preview_width, - preview_height); + preview_width, + preview_height); } if (render_buf) @@ -164,10 +164,10 @@ gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, component_index = gimp_image_get_component_index (gimage, rendererimage->channel); - gimp_preview_renderer_render_buffer (renderer, render_buf, - component_index, - GIMP_PREVIEW_BG_CHECKS, - GIMP_PREVIEW_BG_WHITE); + gimp_view_renderer_render_buffer (renderer, render_buf, + component_index, + GIMP_VIEW_BG_CHECKS, + GIMP_VIEW_BG_WHITE); temp_buf_free (render_buf); } @@ -189,6 +189,6 @@ gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, break; } - gimp_preview_renderer_default_render_stock (renderer, widget, stock_id); + gimp_view_renderer_default_render_stock (renderer, widget, stock_id); } } diff --git a/app/widgets/gimppreviewrendererimage.h b/app/widgets/gimppreviewrendererimage.h index 5e7bda935c..3d2faf467c 100644 --- a/app/widgets/gimppreviewrendererimage.h +++ b/app/widgets/gimppreviewrendererimage.h @@ -22,7 +22,7 @@ #ifndef __GIMP_PREVIEW_RENDERER_IMAGE_H__ #define __GIMP_PREVIEW_RENDERER_IMAGE_H__ -#include "gimppreviewrenderer.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)) @@ -36,14 +36,14 @@ typedef struct _GimpPreviewRendererImageClass GimpPreviewRendererImageClass; struct _GimpPreviewRendererImage { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; GimpChannelType channel; }; struct _GimpPreviewRendererImageClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimppreviewrendererimagefile.c b/app/widgets/gimppreviewrendererimagefile.c index 1f765a25d2..7fcc93fef1 100644 --- a/app/widgets/gimppreviewrendererimagefile.c +++ b/app/widgets/gimppreviewrendererimagefile.c @@ -45,11 +45,11 @@ 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 (GimpPreviewRenderer *renderer, - GtkWidget *widget); +static void gimp_preview_renderer_imagefile_render (GimpViewRenderer *renderer, + GtkWidget *widget); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -72,7 +72,7 @@ gimp_preview_renderer_imagefile_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_imagefile_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererImagefile", &renderer_info, 0); } @@ -83,9 +83,9 @@ gimp_preview_renderer_imagefile_get_type (void) static void gimp_preview_renderer_imagefile_class_init (GimpPreviewRendererImagefileClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -101,8 +101,8 @@ gimp_preview_renderer_imagefile_init (GimpPreviewRendererImagefile *renderer) } static void -gimp_preview_renderer_imagefile_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_imagefile_render (GimpViewRenderer *renderer, + GtkWidget *widget) { TempBuf *temp_buf = gimp_viewable_get_preview (renderer->viewable, renderer->width, @@ -110,7 +110,7 @@ gimp_preview_renderer_imagefile_render (GimpPreviewRenderer *renderer, if (temp_buf) { - gimp_preview_renderer_default_render_buffer (renderer, widget, temp_buf); + gimp_view_renderer_default_render_buffer (renderer, widget, temp_buf); } else { @@ -171,9 +171,9 @@ gimp_preview_renderer_imagefile_render (GimpPreviewRenderer *renderer, if (temp_buf->height < renderer->height) temp_buf->y = (renderer->height - temp_buf->height) / 2; - gimp_preview_renderer_render_buffer (renderer, temp_buf, -1, - GIMP_PREVIEW_BG_WHITE, - GIMP_PREVIEW_BG_WHITE); + 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); @@ -184,8 +184,8 @@ gimp_preview_renderer_imagefile_render (GimpPreviewRenderer *renderer, stock_id = gimp_viewable_get_stock_id (renderer->viewable); - gimp_preview_renderer_default_render_stock (renderer, widget, - stock_id); + gimp_view_renderer_default_render_stock (renderer, widget, + stock_id); } } } diff --git a/app/widgets/gimppreviewrendererimagefile.h b/app/widgets/gimppreviewrendererimagefile.h index 446fcfee1a..fb6137b001 100644 --- a/app/widgets/gimppreviewrendererimagefile.h +++ b/app/widgets/gimppreviewrendererimagefile.h @@ -23,7 +23,7 @@ #define __GIMP_PREVIEW_RENDERER_IMAGEFILE_H__ -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" /* #define ENABLE_FILE_SYSTEM_ICONS 1 */ @@ -40,7 +40,7 @@ typedef struct _GimpPreviewRendererImagefileClass GimpPreviewRendererImagefileC struct _GimpPreviewRendererImagefile { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; #ifdef ENABLE_FILE_SYSTEM_ICONS gpointer file_system; @@ -49,7 +49,7 @@ struct _GimpPreviewRendererImagefile struct _GimpPreviewRendererImagefileClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimppreviewrendererlayer.c b/app/widgets/gimppreviewrendererlayer.c index 992fd67a1a..2ad0429d31 100644 --- a/app/widgets/gimppreviewrendererlayer.c +++ b/app/widgets/gimppreviewrendererlayer.c @@ -34,8 +34,8 @@ static void gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass); -static void gimp_preview_renderer_layer_render (GimpPreviewRenderer *renderer, - GtkWidget *widget); +static void gimp_preview_renderer_layer_render (GimpViewRenderer *renderer, + GtkWidget *widget); static GimpPreviewRendererDrawableClass *parent_class = NULL; @@ -72,9 +72,9 @@ gimp_preview_renderer_layer_get_type (void) static void gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -82,8 +82,8 @@ gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass) } static void -gimp_preview_renderer_layer_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_layer_render (GimpViewRenderer *renderer, + GtkWidget *widget) { const gchar *stock_id = NULL; @@ -97,7 +97,7 @@ gimp_preview_renderer_layer_render (GimpPreviewRenderer *renderer, } if (stock_id) - gimp_preview_renderer_default_render_stock (renderer, widget, stock_id); + gimp_view_renderer_default_render_stock (renderer, widget, stock_id); else - GIMP_PREVIEW_RENDERER_CLASS (parent_class)->render (renderer, widget); + GIMP_VIEW_RENDERER_CLASS (parent_class)->render (renderer, widget); } diff --git a/app/widgets/gimppreviewrenderervectors.c b/app/widgets/gimppreviewrenderervectors.c index 78d3b95470..fda7acc78d 100644 --- a/app/widgets/gimppreviewrenderervectors.c +++ b/app/widgets/gimppreviewrenderervectors.c @@ -39,14 +39,14 @@ static void gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass); -static void gimp_preview_renderer_vectors_draw (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget, - const GdkRectangle *draw_area, - const GdkRectangle *expose_area); +static void gimp_preview_renderer_vectors_draw (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget, + const GdkRectangle *draw_area, + const GdkRectangle *expose_area); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -69,7 +69,7 @@ gimp_preview_renderer_vectors_get_type (void) NULL, /* instance_init */ }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererVectors", &renderer_info, 0); } @@ -80,9 +80,9 @@ gimp_preview_renderer_vectors_get_type (void) static void gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -90,11 +90,11 @@ gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass } static void -gimp_preview_renderer_vectors_draw (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget, - const GdkRectangle *draw_area, - const GdkRectangle *expose_area) +gimp_preview_renderer_vectors_draw (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget, + const GdkRectangle *draw_area, + const GdkRectangle *expose_area) { GimpVectors *vectors; GimpStroke *stroke; diff --git a/app/widgets/gimpselectioneditor.c b/app/widgets/gimpselectioneditor.c index 3c799b5b0a..9798531bea 100644 --- a/app/widgets/gimpselectioneditor.c +++ b/app/widgets/gimpselectioneditor.c @@ -47,7 +47,7 @@ #include "gimphelp-ids.h" #include "gimpmenufactory.h" #include "gimpview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpwidgets-utils.h" #include "gimp-intl.h" @@ -132,8 +132,8 @@ gimp_selection_editor_init (GimpSelectionEditor *editor) GIMP_TYPE_SELECTION, GIMP_PREVIEW_SIZE_HUGE, 0, TRUE); - gimp_preview_renderer_set_background (GIMP_VIEW (editor->preview)->renderer, - GIMP_STOCK_TEXTURE); + gimp_view_renderer_set_background (GIMP_VIEW (editor->preview)->renderer, + GIMP_STOCK_TEXTURE); gtk_widget_set_size_request (editor->preview, GIMP_PREVIEW_SIZE_HUGE, GIMP_PREVIEW_SIZE_HUGE); gimp_view_set_expand (GIMP_VIEW (editor->preview), TRUE); @@ -262,7 +262,7 @@ gimp_selection_preview_button_press (GtkWidget *widget, GimpSelectionEditor *editor) { GimpImageEditor *image_editor = GIMP_IMAGE_EDITOR (editor); - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; GimpToolInfo *tool_info; GimpSelectionOptions *options; GimpDrawable *drawable; @@ -376,5 +376,5 @@ static void gimp_selection_editor_mask_changed (GimpImage *gimage, GimpSelectionEditor *editor) { - gimp_preview_renderer_invalidate (GIMP_VIEW (editor->preview)->renderer); + gimp_view_renderer_invalidate (GIMP_VIEW (editor->preview)->renderer); } diff --git a/app/widgets/gimptemplateview.c b/app/widgets/gimptemplateview.c index b804b86236..f46df1ba14 100644 --- a/app/widgets/gimptemplateview.c +++ b/app/widgets/gimptemplateview.c @@ -42,7 +42,7 @@ #include "gimptemplateview.h" #include "gimpdnd.h" #include "gimphelp-ids.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpuimanager.h" #include "gimp-intl.h" @@ -227,8 +227,8 @@ gimp_template_view_tree_name_edited (GtkCellRendererText *cell, if (gtk_tree_model_get_iter (tree_view->model, &iter, path)) { - GimpPreviewRenderer *renderer; - GimpObject *object; + GimpViewRenderer *renderer; + GimpObject *object; gtk_tree_model_get (tree_view->model, &iter, tree_view->model_column_renderer, &renderer, diff --git a/app/widgets/gimptooloptionseditor.c b/app/widgets/gimptooloptionseditor.c index 287d4a2388..56f38604bc 100644 --- a/app/widgets/gimptooloptionseditor.c +++ b/app/widgets/gimptooloptionseditor.c @@ -38,7 +38,7 @@ #include "gimphelp-ids.h" #include "gimpmenufactory.h" #include "gimpview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimppropwidgets.h" #include "gimptooloptionseditor.h" #include "gimpuimanager.h" @@ -264,8 +264,8 @@ gimp_tool_options_editor_get_preview (GimpDocked *docked, view = gimp_prop_preview_new (G_OBJECT (context), "tool", height); GIMP_VIEW (view)->renderer->size = -1; - gimp_preview_renderer_set_size_full (GIMP_VIEW (view)->renderer, - width, height, 0); + gimp_view_renderer_set_size_full (GIMP_VIEW (view)->renderer, + width, height, 0); return view; } diff --git a/app/widgets/gimptoolview.c b/app/widgets/gimptoolview.c index 2a22d46550..3c8e86a9ae 100644 --- a/app/widgets/gimptoolview.c +++ b/app/widgets/gimptoolview.c @@ -34,7 +34,7 @@ #include "gimpcontainertreeview.h" #include "gimpcontainerview.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimptoolview.h" #include "gimphelp-ids.h" #include "gimpuimanager.h" @@ -264,7 +264,7 @@ gimp_tool_view_eye_data_func (GtkTreeViewColumn *tree_column, gpointer data) { GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (data); - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; gboolean visible; gtk_tree_model_get (tree_model, iter, @@ -291,8 +291,8 @@ gimp_tool_view_eye_clicked (GtkCellRendererToggle *toggle, if (gtk_tree_model_get_iter (tree_view->model, &iter, path)) { - GimpPreviewRenderer *renderer; - gboolean active; + GimpViewRenderer *renderer; + gboolean active; g_object_get (toggle, "active", &active, diff --git a/app/widgets/gimpview-popup.c b/app/widgets/gimpview-popup.c index 9640e2596e..6bf289a8ac 100644 --- a/app/widgets/gimpview-popup.c +++ b/app/widgets/gimpview-popup.c @@ -1,7 +1,7 @@ /* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimppreview-popup.h + * gimpview-popup.c * Copyright (C) 2001 Michael Natterer * * This program is free software; you can redistribute it and/or modify @@ -30,16 +30,16 @@ #include "core/gimpviewable.h" #include "gimpview.h" -#include "gimppreviewrenderer.h" -#include "gimppreview-popup.h" +#include "gimpviewrenderer.h" +#include "gimpview-popup.h" -#define PREVIEW_POPUP_DELAY 150 +#define VIEW_POPUP_DELAY 150 -typedef struct _GimpPreviewPopup GimpPreviewPopup; +typedef struct _GimpViewPopup GimpViewPopup; -struct _GimpPreviewPopup +struct _GimpViewPopup { GtkWidget *widget; GimpViewable *viewable; @@ -58,42 +58,42 @@ struct _GimpPreviewPopup /* local function prototypes */ -static void gimp_preview_popup_hide (GimpPreviewPopup *popup); -static gboolean gimp_preview_popup_button_release (GtkWidget *widget, - GdkEventButton *bevent, - GimpPreviewPopup *popup); -static void gimp_preview_popup_unmap (GtkWidget *widget, - GimpPreviewPopup *popup); -static gboolean gimp_preview_popup_timeout (GimpPreviewPopup *popup); +static void gimp_view_popup_hide (GimpViewPopup *popup); +static gboolean gimp_view_popup_button_release (GtkWidget *widget, + GdkEventButton *bevent, + GimpViewPopup *popup); +static void gimp_view_popup_unmap (GtkWidget *widget, + GimpViewPopup *popup); +static gboolean gimp_view_popup_timeout (GimpViewPopup *popup); /* public functions */ gboolean -gimp_preview_popup_show (GtkWidget *widget, - GdkEventButton *bevent, - GimpViewable *viewable, - gint preview_width, - gint preview_height, - gboolean dot_for_dot) +gimp_view_popup_show (GtkWidget *widget, + GdkEventButton *bevent, + GimpViewable *viewable, + gint view_width, + gint view_height, + gboolean dot_for_dot) { - GimpPreviewPopup *popup; - gint popup_width; - gint popup_height; + GimpViewPopup *popup; + gint popup_width; + gint popup_height; g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); g_return_val_if_fail (bevent != NULL, FALSE); g_return_val_if_fail (GIMP_IS_VIEWABLE (viewable), FALSE); if (! gimp_viewable_get_popup_size (viewable, - preview_width, - preview_height, + view_width, + view_height, dot_for_dot, &popup_width, &popup_height)) return FALSE; - popup = g_new0 (GimpPreviewPopup, 1); + popup = g_new0 (GimpViewPopup, 1); popup->widget = widget; popup->viewable = viewable; @@ -111,18 +111,18 @@ gimp_preview_popup_show (GtkWidget *widget, } g_signal_connect (widget, "button_release_event", - G_CALLBACK (gimp_preview_popup_button_release), + G_CALLBACK (gimp_view_popup_button_release), popup); g_signal_connect (widget, "unmap", - G_CALLBACK (gimp_preview_popup_unmap), + G_CALLBACK (gimp_view_popup_unmap), popup); - popup->timeout_id = g_timeout_add (PREVIEW_POPUP_DELAY, - (GSourceFunc) gimp_preview_popup_timeout, + popup->timeout_id = g_timeout_add (VIEW_POPUP_DELAY, + (GSourceFunc) gimp_view_popup_timeout, popup); - g_object_set_data_full (G_OBJECT (widget), "gimp-preview-popup", popup, - (GDestroyNotify) gimp_preview_popup_hide); + g_object_set_data_full (G_OBJECT (widget), "gimp-view-popup", popup, + (GDestroyNotify) gimp_view_popup_hide); gtk_grab_add (widget); @@ -133,7 +133,7 @@ gimp_preview_popup_show (GtkWidget *widget, /* private functions */ static void -gimp_preview_popup_hide (GimpPreviewPopup *popup) +gimp_view_popup_hide (GimpViewPopup *popup) { if (popup->timeout_id) g_source_remove (popup->timeout_id); @@ -142,10 +142,10 @@ gimp_preview_popup_hide (GimpPreviewPopup *popup) gtk_widget_destroy (popup->popup); g_signal_handlers_disconnect_by_func (popup->widget, - gimp_preview_popup_button_release, + gimp_view_popup_button_release, popup); g_signal_handlers_disconnect_by_func (popup->widget, - gimp_preview_popup_unmap, + gimp_view_popup_unmap, popup); gtk_grab_remove (popup->widget); @@ -154,25 +154,25 @@ gimp_preview_popup_hide (GimpPreviewPopup *popup) } static gboolean -gimp_preview_popup_button_release (GtkWidget *widget, - GdkEventButton *bevent, - GimpPreviewPopup *popup) +gimp_view_popup_button_release (GtkWidget *widget, + GdkEventButton *bevent, + GimpViewPopup *popup) { if (bevent->button == popup->button) - g_object_set_data (G_OBJECT (popup->widget), "gimp-preview-popup", NULL); + g_object_set_data (G_OBJECT (popup->widget), "gimp-view-popup", NULL); return FALSE; } static void -gimp_preview_popup_unmap (GtkWidget *widget, - GimpPreviewPopup *popup) +gimp_view_popup_unmap (GtkWidget *widget, + GimpViewPopup *popup) { - g_object_set_data (G_OBJECT (popup->widget), "gimp-preview-popup", NULL); + g_object_set_data (G_OBJECT (popup->widget), "gimp-view-popup", NULL); } static gboolean -gimp_preview_popup_timeout (GimpPreviewPopup *popup) +gimp_view_popup_timeout (GimpViewPopup *popup) { GtkWidget *window; GtkWidget *frame; @@ -201,8 +201,8 @@ gimp_preview_popup_timeout (GimpPreviewPopup *popup) popup->popup_width, popup->popup_height, 0, TRUE, FALSE, FALSE); - gimp_preview_renderer_set_dot_for_dot (GIMP_VIEW (view)->renderer, - popup->dot_for_dot); + gimp_view_renderer_set_dot_for_dot (GIMP_VIEW (view)->renderer, + popup->dot_for_dot); gtk_container_add (GTK_CONTAINER (frame), view); gtk_widget_show (view); diff --git a/app/widgets/gimpview-popup.h b/app/widgets/gimpview-popup.h index 2f5bd8c496..4b33e30b28 100644 --- a/app/widgets/gimpview-popup.h +++ b/app/widgets/gimpview-popup.h @@ -1,7 +1,7 @@ /* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimppreview-popup.h + * gimpview-popup.h * Copyright (C) 2003 Michael Natterer * * This program is free software; you can redistribute it and/or modify @@ -19,16 +19,16 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#ifndef __GIMP_PREVIEW_POPUP_H__ -#define __GIMP_PREVIEW_POPUP_H__ +#ifndef __GIMP_VIEW_POPUP_H__ +#define __GIMP_VIEW_POPUP_H__ -gboolean gimp_preview_popup_show (GtkWidget *widget, - GdkEventButton *bevent, - GimpViewable *viewable, - gint preview_width, - gint preview_height, - gboolean dot_for_dot); +gboolean gimp_view_popup_show (GtkWidget *widget, + GdkEventButton *bevent, + GimpViewable *viewable, + gint view_width, + gint view_height, + gboolean dot_for_dot); -#endif /* __GIMP_PREVIEW_POPUP_H__ */ +#endif /* __GIMP_VIEW_POPUP_H__ */ diff --git a/app/widgets/gimpview.c b/app/widgets/gimpview.c index 0e7be31f8d..8a9e33e395 100644 --- a/app/widgets/gimpview.c +++ b/app/widgets/gimpview.c @@ -37,8 +37,8 @@ #include "gimpdnd.h" #include "gimpview.h" -#include "gimppreview-popup.h" -#include "gimppreviewrenderer.h" +#include "gimpview-popup.h" +#include "gimpviewrenderer.h" #include "gimppreviewrenderer-utils.h" @@ -80,8 +80,8 @@ static gboolean gimp_view_enter_notify_event (GtkWidget *widget, static gboolean gimp_view_leave_notify_event (GtkWidget *widget, GdkEventCrossing *event); -static void gimp_view_update_callback (GimpPreviewRenderer *renderer, - GimpView *view); +static void gimp_view_update_callback (GimpViewRenderer *renderer, + GimpView *view); static GimpViewable * gimp_view_drag_viewable (GtkWidget *widget, gpointer data); @@ -256,7 +256,7 @@ gimp_view_unrealize (GtkWidget *widget) } if (view->renderer) - gimp_preview_renderer_unrealize (view->renderer); + gimp_view_renderer_unrealize (view->renderer); GTK_WIDGET_CLASS (parent_class)->unrealize (widget); } @@ -364,18 +364,18 @@ gimp_view_size_allocate (GtkWidget *widget, scaled_height = scaled_height * height / scaled_height; } - gimp_preview_renderer_set_size (view->renderer, - MAX (scaled_width, scaled_height), - border_width); + gimp_view_renderer_set_size (view->renderer, + MAX (scaled_width, scaled_height), + border_width); } else { - gimp_preview_renderer_set_size_full (view->renderer, - width, height, - border_width); + gimp_view_renderer_set_size_full (view->renderer, + width, height, + border_width); } - gimp_preview_renderer_remove_idle (view->renderer); + gimp_view_renderer_remove_idle (view->renderer); } } @@ -410,10 +410,10 @@ gimp_view_expose_event (GtkWidget *widget, if (! GTK_WIDGET_DRAWABLE (widget)) return FALSE; - gimp_preview_renderer_draw (GIMP_VIEW (widget)->renderer, - widget->window, widget, - &widget->allocation, - &event->area); + gimp_view_renderer_draw (GIMP_VIEW (widget)->renderer, + widget->window, widget, + &widget->allocation, + &event->area); return FALSE; } @@ -462,11 +462,11 @@ gimp_view_button_press_event (GtkWidget *widget, if (view->show_popup && view->viewable) { - gimp_preview_popup_show (widget, bevent, - view->viewable, - view->renderer->width, - view->renderer->height, - view->renderer->dot_for_dot); + gimp_view_popup_show (widget, bevent, + view->viewable, + view->renderer->width, + view->renderer->height, + view->renderer->dot_for_dot); } } else @@ -474,11 +474,11 @@ gimp_view_button_press_event (GtkWidget *widget, view->press_state = 0; if (bevent->button == 2) - gimp_preview_popup_show (widget, bevent, - view->viewable, - view->renderer->width, - view->renderer->height, - view->renderer->dot_for_dot); + gimp_view_popup_show (widget, bevent, + view->viewable, + view->renderer->width, + view->renderer->height, + view->renderer->dot_for_dot); if (bevent->button == 3) g_signal_emit (widget, view_signals[CONTEXT], 0); @@ -548,7 +548,7 @@ gimp_view_enter_notify_event (GtkWidget *widget, static gboolean gimp_view_leave_notify_event (GtkWidget *widget, - GdkEventCrossing *event) + GdkEventCrossing *event) { GimpView *view; GtkWidget *event_widget; @@ -585,7 +585,7 @@ gimp_view_new (GimpViewable *viewable, if (view) gimp_view_set_viewable (GIMP_VIEW (view), viewable); - gimp_preview_renderer_remove_idle (GIMP_VIEW (view)->renderer); + gimp_view_renderer_remove_idle (GIMP_VIEW (view)->renderer); return view; } @@ -611,7 +611,7 @@ gimp_view_new_full (GimpViewable *viewable, if (view) gimp_view_set_viewable (GIMP_VIEW (view), viewable); - gimp_preview_renderer_remove_idle (GIMP_VIEW (view)->renderer); + gimp_view_renderer_remove_idle (GIMP_VIEW (view)->renderer); return view; } @@ -623,18 +623,18 @@ gimp_view_new_by_types (GType view_type, gint border_width, gboolean is_popup) { - GimpPreviewRenderer *renderer; - GimpView *view; + GimpViewRenderer *renderer; + GimpView *view; g_return_val_if_fail (g_type_is_a (view_type, GIMP_TYPE_VIEW), NULL); g_return_val_if_fail (g_type_is_a (viewable_type, GIMP_TYPE_VIEWABLE), NULL); g_return_val_if_fail (size > 0 && size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); g_return_val_if_fail (border_width >= 0 && - border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, NULL); + border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); - renderer = gimp_preview_renderer_new (viewable_type, size, - border_width, is_popup); + renderer = gimp_view_renderer_new (viewable_type, size, + border_width, is_popup); g_return_val_if_fail (renderer != NULL, NULL); @@ -659,8 +659,8 @@ gimp_view_new_full_by_types (GType view_type, gboolean clickable, gboolean show_popup) { - GimpPreviewRenderer *renderer; - GimpView *view; + GimpViewRenderer *renderer; + GimpView *view; g_return_val_if_fail (g_type_is_a (view_type, GIMP_TYPE_VIEW), NULL); g_return_val_if_fail (g_type_is_a (viewable_type, GIMP_TYPE_VIEWABLE), NULL); @@ -669,10 +669,10 @@ gimp_view_new_full_by_types (GType view_type, g_return_val_if_fail (height > 0 && height <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); g_return_val_if_fail (border_width >= 0 && - border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, NULL); + border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); - renderer = gimp_preview_renderer_new_full (viewable_type, width, height, - border_width, is_popup); + renderer = gimp_view_renderer_new_full (viewable_type, width, height, + border_width, is_popup); g_return_val_if_fail (renderer != NULL, NULL); @@ -737,7 +737,7 @@ gimp_view_set_viewable (GimpView *view, } } - gimp_preview_renderer_set_viewable (view->renderer, viewable); + gimp_view_renderer_set_viewable (view->renderer, viewable); view->viewable = viewable; if (view->viewable) @@ -764,8 +764,8 @@ gimp_view_set_expand (GimpView *view, /* private functions */ static void -gimp_view_update_callback (GimpPreviewRenderer *renderer, - GimpView *view) +gimp_view_update_callback (GimpViewRenderer *renderer, + GimpView *view) { GtkWidget *widget; gint width; diff --git a/app/widgets/gimpview.h b/app/widgets/gimpview.h index 708e4c3815..260b17aca3 100644 --- a/app/widgets/gimpview.h +++ b/app/widgets/gimpview.h @@ -35,22 +35,22 @@ typedef struct _GimpViewClass GimpViewClass; struct _GimpView { - GtkWidget parent_instance; + GtkWidget parent_instance; - GdkWindow *event_window; + GdkWindow *event_window; - GimpViewable *viewable; - GimpPreviewRenderer *renderer; + GimpViewable *viewable; + GimpViewRenderer *renderer; - gboolean clickable; - gboolean eat_button_events; - gboolean show_popup; - gboolean expand; + gboolean clickable; + gboolean eat_button_events; + gboolean show_popup; + gboolean expand; /*< private >*/ - gboolean in_button; - gboolean has_grab; - GdkModifierType press_state; + gboolean in_button; + gboolean has_grab; + GdkModifierType press_state; }; struct _GimpViewClass diff --git a/app/widgets/gimpviewablebutton.c b/app/widgets/gimpviewablebutton.c index 7d64ff0984..a9ea430637 100644 --- a/app/widgets/gimpviewablebutton.c +++ b/app/widgets/gimpviewablebutton.c @@ -34,7 +34,7 @@ #include "gimpcontainerpopup.h" #include "gimpdialogfactory.h" #include "gimppropwidgets.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimpviewablebutton.h" #include "gimp-intl.h" @@ -243,7 +243,7 @@ gimp_viewable_button_new (GimpContainer *container, g_return_val_if_fail (preview_size > 0 && preview_size <= GIMP_VIEWABLE_MAX_BUTTON_SIZE, NULL); g_return_val_if_fail (preview_border_width >= 0 && - preview_border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, + preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); g_return_val_if_fail (dialog_factory == NULL || GIMP_IS_DIALOG_FACTORY (dialog_factory), NULL); diff --git a/app/widgets/gimpviewrenderer-utils.c b/app/widgets/gimpviewrenderer-utils.c index 2754080e62..c9d156eee2 100644 --- a/app/widgets/gimpviewrenderer-utils.c +++ b/app/widgets/gimpviewrenderer-utils.c @@ -44,7 +44,7 @@ GType gimp_preview_renderer_type_from_viewable_type (GType viewable_type) { - GType type = GIMP_TYPE_PREVIEW_RENDERER; + GType type = GIMP_TYPE_VIEW_RENDERER; g_return_val_if_fail (g_type_is_a (viewable_type, GIMP_TYPE_VIEWABLE), G_TYPE_NONE); diff --git a/app/widgets/gimpviewrenderer.c b/app/widgets/gimpviewrenderer.c index 3bc22adce0..839a913c2d 100644 --- a/app/widgets/gimpviewrenderer.c +++ b/app/widgets/gimpviewrenderer.c @@ -1,7 +1,7 @@ /* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimppreviewrenderer.c + * gimpviewrenderer.c * Copyright (C) 2003 Michael Natterer * * This program is free software; you can redistribute it and/or modify @@ -44,7 +44,7 @@ #include "display/gimpdisplayshell-render.h" -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" #include "gimppreviewrenderer-utils.h" #include "gimpwidgets-utils.h" @@ -56,26 +56,26 @@ enum }; -static void gimp_preview_renderer_class_init (GimpPreviewRendererClass *klass); -static void gimp_preview_renderer_init (GimpPreviewRenderer *renderer); +static void gimp_view_renderer_class_init (GimpViewRendererClass *klass); +static void gimp_view_renderer_init (GimpViewRenderer *renderer); -static void gimp_preview_renderer_dispose (GObject *object); -static void gimp_preview_renderer_finalize (GObject *object); +static void gimp_view_renderer_dispose (GObject *object); +static void gimp_view_renderer_finalize (GObject *object); -static gboolean gimp_preview_renderer_idle_update (GimpPreviewRenderer *renderer); -static void gimp_preview_renderer_real_draw (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget, - const GdkRectangle *draw_area, - const GdkRectangle *expose_area); -static void gimp_preview_renderer_real_render (GimpPreviewRenderer *renderer, - GtkWidget *widget); +static gboolean gimp_view_renderer_idle_update (GimpViewRenderer *renderer); +static void gimp_view_renderer_real_draw (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget, + const GdkRectangle *draw_area, + const GdkRectangle *expose_area); +static void gimp_view_renderer_real_render (GimpViewRenderer *renderer, + GtkWidget *widget); -static void gimp_preview_renderer_size_changed (GimpPreviewRenderer *renderer, - GimpViewable *viewable); -static GdkGC * gimp_preview_renderer_create_gc (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget); +static void gimp_view_renderer_size_changed (GimpViewRenderer *renderer, + GimpViewable *viewable); +static GdkGC * gimp_view_renderer_create_gc (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget); static guint renderer_signals[LAST_SIGNAL] = { 0 }; @@ -89,7 +89,7 @@ static GimpRGB red_color; GType -gimp_preview_renderer_get_type (void) +gimp_view_renderer_get_type (void) { static GType renderer_type = 0; @@ -97,19 +97,19 @@ gimp_preview_renderer_get_type (void) { static const GTypeInfo renderer_info = { - sizeof (GimpPreviewRendererClass), + sizeof (GimpViewRendererClass), NULL, /* base_init */ NULL, /* base_finalize */ - (GClassInitFunc) gimp_preview_renderer_class_init, + (GClassInitFunc) gimp_view_renderer_class_init, NULL, /* class_finalize */ NULL, /* class_data */ - sizeof (GimpPreviewRenderer), + sizeof (GimpViewRenderer), 0, /* n_preallocs */ - (GInstanceInitFunc) gimp_preview_renderer_init, + (GInstanceInitFunc) gimp_view_renderer_init, }; renderer_type = g_type_register_static (G_TYPE_OBJECT, - "GimpPreviewRenderer", + "GimpViewRenderer", &renderer_info, 0); } @@ -117,7 +117,7 @@ gimp_preview_renderer_get_type (void) } static void -gimp_preview_renderer_class_init (GimpPreviewRendererClass *klass) +gimp_view_renderer_class_init (GimpViewRendererClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); @@ -127,16 +127,16 @@ gimp_preview_renderer_class_init (GimpPreviewRendererClass *klass) g_signal_new ("update", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, - G_STRUCT_OFFSET (GimpPreviewRendererClass, update), + G_STRUCT_OFFSET (GimpViewRendererClass, update), NULL, NULL, gimp_marshal_VOID__VOID, G_TYPE_NONE, 0); - object_class->dispose = gimp_preview_renderer_dispose; - object_class->finalize = gimp_preview_renderer_finalize; + object_class->dispose = gimp_view_renderer_dispose; + object_class->finalize = gimp_view_renderer_finalize; - klass->draw = gimp_preview_renderer_real_draw; - klass->render = gimp_preview_renderer_real_render; + klass->draw = gimp_view_renderer_real_draw; + klass->render = gimp_view_renderer_real_render; gimp_rgba_set (&black_color, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE); gimp_rgba_set (&white_color, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE); @@ -145,49 +145,49 @@ gimp_preview_renderer_class_init (GimpPreviewRendererClass *klass) } static void -gimp_preview_renderer_init (GimpPreviewRenderer *renderer) +gimp_view_renderer_init (GimpViewRenderer *renderer) { - renderer->viewable = NULL; + renderer->viewable = NULL; - renderer->width = 8; - renderer->height = 8; - renderer->border_width = 0; - renderer->dot_for_dot = TRUE; - renderer->is_popup = FALSE; + renderer->width = 8; + renderer->height = 8; + renderer->border_width = 0; + renderer->dot_for_dot = TRUE; + renderer->is_popup = FALSE; - renderer->border_type = GIMP_PREVIEW_BORDER_BLACK; - renderer->border_color = black_color; - renderer->gc = NULL; + renderer->border_type = GIMP_VIEW_BORDER_BLACK; + renderer->border_color = black_color; + renderer->gc = NULL; - renderer->buffer = NULL; - renderer->rowstride = 0; - renderer->bytes = 3; + renderer->buffer = NULL; + renderer->rowstride = 0; + renderer->bytes = 3; - renderer->no_preview_pixbuf = NULL; - renderer->bg_stock_id = NULL; + renderer->no_view_pixbuf = NULL; + renderer->bg_stock_id = NULL; - renderer->size = -1; - renderer->needs_render = TRUE; - renderer->idle_id = 0; + renderer->size = -1; + renderer->needs_render = TRUE; + renderer->idle_id = 0; } static void -gimp_preview_renderer_dispose (GObject *object) +gimp_view_renderer_dispose (GObject *object) { - GimpPreviewRenderer *renderer = GIMP_PREVIEW_RENDERER (object); + GimpViewRenderer *renderer = GIMP_VIEW_RENDERER (object); if (renderer->viewable) - gimp_preview_renderer_set_viewable (renderer, NULL); + gimp_view_renderer_set_viewable (renderer, NULL); - gimp_preview_renderer_remove_idle (renderer); + gimp_view_renderer_remove_idle (renderer); G_OBJECT_CLASS (parent_class)->dispose (object); } static void -gimp_preview_renderer_finalize (GObject *object) +gimp_view_renderer_finalize (GObject *object) { - GimpPreviewRenderer *renderer = GIMP_PREVIEW_RENDERER (object); + GimpViewRenderer *renderer = GIMP_VIEW_RENDERER (object); if (renderer->buffer) { @@ -195,10 +195,10 @@ gimp_preview_renderer_finalize (GObject *object) renderer->buffer = NULL; } - if (renderer->no_preview_pixbuf) + if (renderer->no_view_pixbuf) { - g_object_unref (renderer->no_preview_pixbuf); - renderer->no_preview_pixbuf = NULL; + g_object_unref (renderer->no_view_pixbuf); + renderer->no_view_pixbuf = NULL; } if (renderer->bg_stock_id) @@ -216,11 +216,11 @@ gimp_preview_renderer_finalize (GObject *object) G_OBJECT_CLASS (parent_class)->finalize (object); } -static GimpPreviewRenderer * -gimp_preview_renderer_new_internal (GType viewable_type, - gboolean is_popup) +static GimpViewRenderer * +gimp_view_renderer_new_internal (GType viewable_type, + gboolean is_popup) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; renderer = g_object_new (gimp_preview_renderer_type_from_viewable_type (viewable_type), NULL); @@ -234,36 +234,36 @@ gimp_preview_renderer_new_internal (GType viewable_type, /* public functions */ -GimpPreviewRenderer * -gimp_preview_renderer_new (GType viewable_type, - gint size, - gint border_width, - gboolean is_popup) +GimpViewRenderer * +gimp_view_renderer_new (GType viewable_type, + gint size, + gint border_width, + gboolean is_popup) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; g_return_val_if_fail (g_type_is_a (viewable_type, GIMP_TYPE_VIEWABLE), NULL); g_return_val_if_fail (size > 0 && size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); g_return_val_if_fail (border_width >= 0 && - border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, NULL); + border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); - renderer = gimp_preview_renderer_new_internal (viewable_type, is_popup); + renderer = gimp_view_renderer_new_internal (viewable_type, is_popup); - gimp_preview_renderer_set_size (renderer, size, border_width); - gimp_preview_renderer_remove_idle (renderer); + gimp_view_renderer_set_size (renderer, size, border_width); + gimp_view_renderer_remove_idle (renderer); return renderer; } -GimpPreviewRenderer * -gimp_preview_renderer_new_full (GType viewable_type, - gint width, - gint height, - gint border_width, - gboolean is_popup) +GimpViewRenderer * +gimp_view_renderer_new_full (GType viewable_type, + gint width, + gint height, + gint border_width, + gboolean is_popup) { - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; g_return_val_if_fail (g_type_is_a (viewable_type, GIMP_TYPE_VIEWABLE), NULL); g_return_val_if_fail (width > 0 && @@ -271,21 +271,21 @@ gimp_preview_renderer_new_full (GType viewable_type, g_return_val_if_fail (height > 0 && height <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL); g_return_val_if_fail (border_width >= 0 && - border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH, NULL); + border_width <= GIMP_VIEW_MAX_BORDER_WIDTH, NULL); - renderer = gimp_preview_renderer_new_internal (viewable_type, is_popup); + renderer = gimp_view_renderer_new_internal (viewable_type, is_popup); - gimp_preview_renderer_set_size_full (renderer, width, height, border_width); - gimp_preview_renderer_remove_idle (renderer); + gimp_view_renderer_set_size_full (renderer, width, height, border_width); + gimp_view_renderer_remove_idle (renderer); return renderer; } void -gimp_preview_renderer_set_viewable (GimpPreviewRenderer *renderer, - GimpViewable *viewable) +gimp_view_renderer_set_viewable (GimpViewRenderer *renderer, + GimpViewable *viewable) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); g_return_if_fail (! viewable || GIMP_IS_VIEWABLE (viewable)); if (viewable) @@ -301,10 +301,10 @@ gimp_preview_renderer_set_viewable (GimpPreviewRenderer *renderer, renderer->buffer = NULL; } - if (renderer->no_preview_pixbuf) + if (renderer->no_view_pixbuf) { - g_object_unref (renderer->no_preview_pixbuf); - renderer->no_preview_pixbuf = NULL; + g_object_unref (renderer->no_view_pixbuf); + renderer->no_view_pixbuf = NULL; } if (renderer->viewable) @@ -313,11 +313,11 @@ gimp_preview_renderer_set_viewable (GimpPreviewRenderer *renderer, (gpointer *) &renderer->viewable); g_signal_handlers_disconnect_by_func (renderer->viewable, - G_CALLBACK (gimp_preview_renderer_invalidate), + G_CALLBACK (gimp_view_renderer_invalidate), renderer); g_signal_handlers_disconnect_by_func (renderer->viewable, - G_CALLBACK (gimp_preview_renderer_size_changed), + G_CALLBACK (gimp_view_renderer_size_changed), renderer); } @@ -330,38 +330,38 @@ gimp_preview_renderer_set_viewable (GimpPreviewRenderer *renderer, g_signal_connect_swapped (renderer->viewable, "invalidate_preview", - G_CALLBACK (gimp_preview_renderer_invalidate), + G_CALLBACK (gimp_view_renderer_invalidate), renderer); g_signal_connect_swapped (renderer->viewable, "size_changed", - G_CALLBACK (gimp_preview_renderer_size_changed), + G_CALLBACK (gimp_view_renderer_size_changed), renderer); if (renderer->size != -1) - gimp_preview_renderer_set_size (renderer, renderer->size, - renderer->border_width); + gimp_view_renderer_set_size (renderer, renderer->size, + renderer->border_width); - gimp_preview_renderer_invalidate (renderer); + gimp_view_renderer_invalidate (renderer); } else { - gimp_preview_renderer_update_idle (renderer); + gimp_view_renderer_update_idle (renderer); } } void -gimp_preview_renderer_set_size (GimpPreviewRenderer *renderer, - gint preview_size, - gint border_width) +gimp_view_renderer_set_size (GimpViewRenderer *renderer, + gint preview_size, + gint border_width) { gint width, height; - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); g_return_if_fail (preview_size > 0 && preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE); g_return_if_fail (border_width >= 0 && - border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH); + border_width <= GIMP_VIEW_MAX_BORDER_WIDTH); renderer->size = preview_size; @@ -379,22 +379,22 @@ gimp_preview_renderer_set_size (GimpPreviewRenderer *renderer, height = preview_size; } - gimp_preview_renderer_set_size_full (renderer, width, height, border_width); + gimp_view_renderer_set_size_full (renderer, width, height, border_width); } void -gimp_preview_renderer_set_size_full (GimpPreviewRenderer *renderer, - gint width, - gint height, - gint border_width) +gimp_view_renderer_set_size_full (GimpViewRenderer *renderer, + gint width, + gint height, + gint border_width) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); g_return_if_fail (width > 0 && width <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE); g_return_if_fail (height > 0 && height <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE); g_return_if_fail (border_width >= 0 && - border_width <= GIMP_PREVIEW_MAX_BORDER_WIDTH); + border_width <= GIMP_VIEW_MAX_BORDER_WIDTH); if (width != renderer->width || height != renderer->height || @@ -413,62 +413,62 @@ gimp_preview_renderer_set_size_full (GimpPreviewRenderer *renderer, } if (renderer->viewable) - gimp_preview_renderer_invalidate (renderer); + gimp_view_renderer_invalidate (renderer); } } void -gimp_preview_renderer_set_dot_for_dot (GimpPreviewRenderer *renderer, - gboolean dot_for_dot) +gimp_view_renderer_set_dot_for_dot (GimpViewRenderer *renderer, + gboolean dot_for_dot) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); if (dot_for_dot != renderer->dot_for_dot) { renderer->dot_for_dot = dot_for_dot ? TRUE: FALSE; if (renderer->size != -1) - gimp_preview_renderer_set_size (renderer, renderer->size, - renderer->border_width); + gimp_view_renderer_set_size (renderer, renderer->size, + renderer->border_width); - gimp_preview_renderer_invalidate (renderer); + gimp_view_renderer_invalidate (renderer); } } void -gimp_preview_renderer_set_border_type (GimpPreviewRenderer *renderer, - GimpPreviewBorderType border_type) +gimp_view_renderer_set_border_type (GimpViewRenderer *renderer, + GimpViewBorderType border_type) { GimpRGB *border_color = &black_color; - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); renderer->border_type = border_type; switch (border_type) { - case GIMP_PREVIEW_BORDER_BLACK: + case GIMP_VIEW_BORDER_BLACK: border_color = &black_color; break; - case GIMP_PREVIEW_BORDER_WHITE: + case GIMP_VIEW_BORDER_WHITE: border_color = &white_color; break; - case GIMP_PREVIEW_BORDER_GREEN: + case GIMP_VIEW_BORDER_GREEN: border_color = &green_color; break; - case GIMP_PREVIEW_BORDER_RED: + case GIMP_VIEW_BORDER_RED: border_color = &red_color; break; } - gimp_preview_renderer_set_border_color (renderer, border_color); + gimp_view_renderer_set_border_color (renderer, border_color); } void -gimp_preview_renderer_set_border_color (GimpPreviewRenderer *renderer, - const GimpRGB *color) +gimp_view_renderer_set_border_color (GimpViewRenderer *renderer, + const GimpRGB *color) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); g_return_if_fail (color != NULL); if (gimp_rgb_distance (&renderer->border_color, color)) @@ -483,15 +483,15 @@ gimp_preview_renderer_set_border_color (GimpPreviewRenderer *renderer, gdk_gc_set_rgb_fg_color (renderer->gc, &gdk_color); } - gimp_preview_renderer_update_idle (renderer); + gimp_view_renderer_update_idle (renderer); } } void -gimp_preview_renderer_set_background (GimpPreviewRenderer *renderer, - const gchar *stock_id) +gimp_view_renderer_set_background (GimpViewRenderer *renderer, + const gchar *stock_id) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); if (renderer->bg_stock_id) g_free (renderer->bg_stock_id); @@ -506,9 +506,9 @@ gimp_preview_renderer_set_background (GimpPreviewRenderer *renderer, } void -gimp_preview_renderer_unrealize (GimpPreviewRenderer *renderer) +gimp_view_renderer_unrealize (GimpViewRenderer *renderer) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); if (renderer->gc) { @@ -518,9 +518,9 @@ gimp_preview_renderer_unrealize (GimpPreviewRenderer *renderer) } void -gimp_preview_renderer_invalidate (GimpPreviewRenderer *renderer) +gimp_view_renderer_invalidate (GimpViewRenderer *renderer) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); if (renderer->idle_id) g_source_remove (renderer->idle_id); @@ -529,14 +529,14 @@ gimp_preview_renderer_invalidate (GimpPreviewRenderer *renderer) renderer->idle_id = g_idle_add_full (G_PRIORITY_LOW, - (GSourceFunc) gimp_preview_renderer_idle_update, + (GSourceFunc) gimp_view_renderer_idle_update, renderer, NULL); } void -gimp_preview_renderer_update (GimpPreviewRenderer *renderer) +gimp_view_renderer_update (GimpViewRenderer *renderer) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); if (renderer->idle_id) { @@ -548,23 +548,23 @@ gimp_preview_renderer_update (GimpPreviewRenderer *renderer) } void -gimp_preview_renderer_update_idle (GimpPreviewRenderer *renderer) +gimp_view_renderer_update_idle (GimpViewRenderer *renderer) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); if (renderer->idle_id) g_source_remove (renderer->idle_id); renderer->idle_id = g_idle_add_full (G_PRIORITY_LOW, - (GSourceFunc) gimp_preview_renderer_idle_update, + (GSourceFunc) gimp_view_renderer_idle_update, renderer, NULL); } void -gimp_preview_renderer_remove_idle (GimpPreviewRenderer *renderer) +gimp_view_renderer_remove_idle (GimpViewRenderer *renderer) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); if (renderer->idle_id) { @@ -574,13 +574,13 @@ gimp_preview_renderer_remove_idle (GimpPreviewRenderer *renderer) } void -gimp_preview_renderer_draw (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget, - const GdkRectangle *draw_area, - const GdkRectangle *expose_area) +gimp_view_renderer_draw (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget, + const GdkRectangle *draw_area, + const GdkRectangle *expose_area) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); g_return_if_fail (GDK_IS_WINDOW (window)); g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (draw_area != NULL); @@ -591,10 +591,10 @@ gimp_preview_renderer_draw (GimpPreviewRenderer *renderer, if (renderer->viewable) { - GIMP_PREVIEW_RENDERER_GET_CLASS (renderer)->draw (renderer, - window, widget, - draw_area, - expose_area); + GIMP_VIEW_RENDERER_GET_CLASS (renderer)->draw (renderer, + window, widget, + draw_area, + expose_area); } else { @@ -602,14 +602,14 @@ gimp_preview_renderer_draw (GimpPreviewRenderer *renderer, viewable_class = g_type_class_ref (renderer->viewable_type); - gimp_preview_renderer_default_render_stock (renderer, - widget, - viewable_class->default_stock_id); + gimp_view_renderer_default_render_stock (renderer, + widget, + viewable_class->default_stock_id); g_type_class_unref (viewable_class); - gimp_preview_renderer_real_draw (renderer, - window, widget, draw_area, expose_area); + gimp_view_renderer_real_draw (renderer, + window, widget, draw_area, expose_area); } if (renderer->border_width > 0) @@ -623,8 +623,8 @@ gimp_preview_renderer_draw (GimpPreviewRenderer *renderer, rect.y = draw_area->y + (draw_area->height - rect.height) / 2; if (! renderer->gc) - renderer->gc = gimp_preview_renderer_create_gc (renderer, - window, widget); + renderer->gc = gimp_view_renderer_create_gc (renderer, + window, widget); for (i = 0; i < renderer->border_width; i++) gdk_draw_rectangle (window, @@ -641,35 +641,35 @@ gimp_preview_renderer_draw (GimpPreviewRenderer *renderer, /* private functions */ static gboolean -gimp_preview_renderer_idle_update (GimpPreviewRenderer *renderer) +gimp_view_renderer_idle_update (GimpViewRenderer *renderer) { renderer->idle_id = 0; - gimp_preview_renderer_update (renderer); + gimp_view_renderer_update (renderer); return FALSE; } static void -gimp_preview_renderer_real_draw (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget, - const GdkRectangle *draw_area, - const GdkRectangle *expose_area) +gimp_view_renderer_real_draw (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget, + const GdkRectangle *draw_area, + const GdkRectangle *expose_area) { GdkRectangle rect; GdkRectangle render_rect; if (renderer->needs_render) - GIMP_PREVIEW_RENDERER_GET_CLASS (renderer)->render (renderer, widget); + GIMP_VIEW_RENDERER_GET_CLASS (renderer)->render (renderer, widget); - if (renderer->no_preview_pixbuf) + if (renderer->no_view_pixbuf) { if (renderer->bg_stock_id) { if (!renderer->gc) - renderer->gc = gimp_preview_renderer_create_gc (renderer, - window, widget); + renderer->gc = gimp_view_renderer_create_gc (renderer, + window, widget); if (gdk_rectangle_intersect ((GdkRectangle *) draw_area, (GdkRectangle *) expose_area, @@ -682,8 +682,8 @@ gimp_preview_renderer_real_draw (GimpPreviewRenderer *renderer, } } - rect.width = gdk_pixbuf_get_width (renderer->no_preview_pixbuf); - rect.height = gdk_pixbuf_get_height (renderer->no_preview_pixbuf); + rect.width = gdk_pixbuf_get_width (renderer->no_view_pixbuf); + rect.height = gdk_pixbuf_get_height (renderer->no_view_pixbuf); rect.x = draw_area->x + (draw_area->width - rect.width) / 2; rect.y = draw_area->y + (draw_area->height - rect.height) / 2; @@ -692,7 +692,7 @@ gimp_preview_renderer_real_draw (GimpPreviewRenderer *renderer, { gdk_draw_pixbuf (GDK_DRAWABLE (window), widget->style->bg_gc[widget->state], - renderer->no_preview_pixbuf, + renderer->no_view_pixbuf, render_rect.x - rect.x, render_rect.y - rect.y, render_rect.x, @@ -735,8 +735,8 @@ gimp_preview_renderer_real_draw (GimpPreviewRenderer *renderer, } static void -gimp_preview_renderer_real_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_view_renderer_real_render (GimpViewRenderer *renderer, + GtkWidget *widget) { TempBuf *temp_buf; @@ -746,7 +746,7 @@ gimp_preview_renderer_real_render (GimpPreviewRenderer *renderer, if (temp_buf) { - gimp_preview_renderer_default_render_buffer (renderer, widget, temp_buf); + gimp_view_renderer_default_render_buffer (renderer, widget, temp_buf); } else /* no preview available */ { @@ -754,30 +754,30 @@ gimp_preview_renderer_real_render (GimpPreviewRenderer *renderer, stock_id = gimp_viewable_get_stock_id (renderer->viewable); - gimp_preview_renderer_default_render_stock (renderer, widget, stock_id); + gimp_view_renderer_default_render_stock (renderer, widget, stock_id); } } static void -gimp_preview_renderer_size_changed (GimpPreviewRenderer *renderer, - GimpViewable *viewable) +gimp_view_renderer_size_changed (GimpViewRenderer *renderer, + GimpViewable *viewable) { if (renderer->size != -1) - gimp_preview_renderer_set_size (renderer, renderer->size, - renderer->border_width); + gimp_view_renderer_set_size (renderer, renderer->size, + renderer->border_width); - gimp_preview_renderer_invalidate (renderer); + gimp_view_renderer_invalidate (renderer); } /* protected functions */ void -gimp_preview_renderer_default_render_buffer (GimpPreviewRenderer *renderer, - GtkWidget *widget, - TempBuf *temp_buf) +gimp_view_renderer_default_render_buffer (GimpViewRenderer *renderer, + GtkWidget *widget, + TempBuf *temp_buf) { - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (temp_buf != NULL); @@ -787,27 +787,27 @@ gimp_preview_renderer_default_render_buffer (GimpPreviewRenderer *renderer, if (temp_buf->height < renderer->height) temp_buf->y = (renderer->height - temp_buf->height) / 2; - gimp_preview_renderer_render_buffer (renderer, temp_buf, -1, - GIMP_PREVIEW_BG_CHECKS, - GIMP_PREVIEW_BG_WHITE); + gimp_view_renderer_render_buffer (renderer, temp_buf, -1, + GIMP_VIEW_BG_CHECKS, + GIMP_VIEW_BG_WHITE); } void -gimp_preview_renderer_default_render_stock (GimpPreviewRenderer *renderer, - GtkWidget *widget, - const gchar *stock_id) +gimp_view_renderer_default_render_stock (GimpViewRenderer *renderer, + GtkWidget *widget, + const gchar *stock_id) { GdkPixbuf *pixbuf = NULL; GtkIconSize icon_size; - g_return_if_fail (GIMP_IS_PREVIEW_RENDERER (renderer)); + g_return_if_fail (GIMP_IS_VIEW_RENDERER (renderer)); g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (stock_id != NULL); - if (renderer->no_preview_pixbuf) + if (renderer->no_view_pixbuf) { - g_object_unref (renderer->no_preview_pixbuf); - renderer->no_preview_pixbuf = NULL; + g_object_unref (renderer->no_view_pixbuf); + renderer->no_view_pixbuf = NULL; } if (renderer->buffer) @@ -845,51 +845,51 @@ gimp_preview_renderer_default_render_stock (GimpPreviewRenderer *renderer, pixbuf = scaled_pixbuf; } - renderer->no_preview_pixbuf = pixbuf; + renderer->no_view_pixbuf = pixbuf; } renderer->needs_render = FALSE; } void -gimp_preview_renderer_render_buffer (GimpPreviewRenderer *renderer, - TempBuf *temp_buf, - gint channel, - GimpPreviewBG inside_bg, - GimpPreviewBG outside_bg) +gimp_view_renderer_render_buffer (GimpViewRenderer *renderer, + TempBuf *temp_buf, + gint channel, + GimpViewBG inside_bg, + GimpViewBG outside_bg) { if (! renderer->buffer) renderer->buffer = g_new0 (guchar, renderer->height * renderer->rowstride); - if (renderer->no_preview_pixbuf) + if (renderer->no_view_pixbuf) { - g_object_unref (renderer->no_preview_pixbuf); - renderer->no_preview_pixbuf = NULL; + g_object_unref (renderer->no_view_pixbuf); + renderer->no_view_pixbuf = NULL; } - gimp_preview_render_to_buffer (temp_buf, - channel, - inside_bg, - outside_bg, - renderer->buffer, - renderer->width, - renderer->height, - renderer->rowstride, - renderer->bytes); + gimp_view_render_to_buffer (temp_buf, + channel, + inside_bg, + outside_bg, + renderer->buffer, + renderer->width, + renderer->height, + renderer->rowstride, + renderer->bytes); renderer->needs_render = FALSE; } void -gimp_preview_render_to_buffer (TempBuf *temp_buf, - gint channel, - GimpPreviewBG inside_bg, - GimpPreviewBG outside_bg, - guchar *dest_buffer, - gint dest_width, - gint dest_height, - gint dest_rowstride, - gint dest_bytes) +gimp_view_render_to_buffer (TempBuf *temp_buf, + gint channel, + GimpViewBG inside_bg, + GimpViewBG outside_bg, + guchar *dest_buffer, + gint dest_width, + gint dest_height, + gint dest_rowstride, + gint dest_bytes) { guchar *src, *s; guchar *cb; @@ -925,11 +925,11 @@ gimp_preview_render_to_buffer (TempBuf *temp_buf, rowstride = temp_buf->width * temp_buf->bytes; /* render the checkerboard only if the temp_buf has alpha *and* - * we render a composite preview + * we render a composite view */ - if (has_alpha && render_composite && outside_bg == GIMP_PREVIEW_BG_CHECKS) + if (has_alpha && render_composite && outside_bg == GIMP_VIEW_BG_CHECKS) pad_buf = render_check_buf; - else if (outside_bg == GIMP_PREVIEW_BG_WHITE) + else if (outside_bg == GIMP_VIEW_BG_WHITE) pad_buf = render_white_buf; else pad_buf = render_empty_buf; @@ -998,7 +998,7 @@ gimp_preview_render_to_buffer (TempBuf *temp_buf, { a = s[alpha_component] << 8; - if (inside_bg == GIMP_PREVIEW_BG_CHECKS) + if (inside_bg == GIMP_VIEW_BG_CHECKS) { if ((j + offset) & 0x4) { @@ -1019,7 +1019,7 @@ gimp_preview_render_to_buffer (TempBuf *temp_buf, render_blend_light_check [(a | s[blue_component])]; } } - else /* GIMP_PREVIEW_BG_WHITE */ + else /* GIMP_VIEW_BG_WHITE */ { render_temp_buf[j * 3 + 0] = render_blend_white [(a | s[red_component])]; @@ -1060,9 +1060,9 @@ gimp_preview_render_to_buffer (TempBuf *temp_buf, } static GdkGC * -gimp_preview_renderer_create_gc (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget) +gimp_view_renderer_create_gc (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget) { GdkGC *gc; GdkPixmap *pixmap = NULL; diff --git a/app/widgets/gimpviewrenderer.h b/app/widgets/gimpviewrenderer.h index 29ed7690bd..e741b45a9c 100644 --- a/app/widgets/gimpviewrenderer.h +++ b/app/widgets/gimpviewrenderer.h @@ -1,7 +1,7 @@ /* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimppreviewrenderer.h + * gimpviewrenderer.h * Copyright (C) 2003 Michael Natterer * * This program is free software; you can redistribute it and/or modify @@ -19,141 +19,141 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#ifndef __GIMP_PREVIEW_RENDERER_H__ -#define __GIMP_PREVIEW_RENDERER_H__ +#ifndef __GIMP_VIEW_RENDERER_H__ +#define __GIMP_VIEW_RENDERER_H__ -#define GIMP_PREVIEW_MAX_BORDER_WIDTH 16 +#define GIMP_VIEW_MAX_BORDER_WIDTH 16 -#define GIMP_TYPE_PREVIEW_RENDERER (gimp_preview_renderer_get_type ()) -#define GIMP_PREVIEW_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PREVIEW_RENDERER, GimpPreviewRenderer)) -#define GIMP_PREVIEW_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PREVIEW_RENDERER, GimpPreviewRendererClass)) -#define GIMP_IS_PREVIEW_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_PREVIEW_RENDERER)) -#define GIMP_IS_PREVIEW_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PREVIEW_RENDERER)) -#define GIMP_PREVIEW_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PREVIEW_RENDERER, GimpPreviewRendererClass)) +#define GIMP_TYPE_VIEW_RENDERER (gimp_view_renderer_get_type ()) +#define GIMP_VIEW_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VIEW_RENDERER, GimpViewRenderer)) +#define GIMP_VIEW_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEW_RENDERER, GimpViewRendererClass)) +#define GIMP_IS_VIEW_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_VIEW_RENDERER)) +#define GIMP_IS_VIEW_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEW_RENDERER)) +#define GIMP_VIEW_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VIEW_RENDERER, GimpViewRendererClass)) -typedef struct _GimpPreviewRendererClass GimpPreviewRendererClass; +typedef struct _GimpViewRendererClass GimpViewRendererClass; -struct _GimpPreviewRenderer +struct _GimpViewRenderer { - GObject parent_instance; + GObject parent_instance; - GType viewable_type; - GimpViewable *viewable; + GType viewable_type; + GimpViewable *viewable; - gint width; - gint height; - gint border_width; - gboolean dot_for_dot; - gboolean is_popup; + gint width; + gint height; + gint border_width; + gboolean dot_for_dot; + gboolean is_popup; - GimpPreviewBorderType border_type; - GimpRGB border_color; - GdkGC *gc; + GimpViewBorderType border_type; + GimpRGB border_color; + GdkGC *gc; /*< private >*/ - guchar *buffer; - gint rowstride; - gint bytes; + guchar *buffer; + gint rowstride; + gint bytes; - GdkPixbuf *no_preview_pixbuf; - gchar *bg_stock_id; + GdkPixbuf *no_view_pixbuf; + gchar *bg_stock_id; - gint size; - gboolean needs_render; - guint idle_id; + gint size; + gboolean needs_render; + guint idle_id; }; -struct _GimpPreviewRendererClass +struct _GimpViewRendererClass { GObjectClass parent_class; /* signals */ - void (* update) (GimpPreviewRenderer *renderer); + void (* update) (GimpViewRenderer *renderer); /* virtual functions */ - void (* draw) (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget, - const GdkRectangle *draw_area, - const GdkRectangle *expose_area); - void (* render) (GimpPreviewRenderer *renderer, - GtkWidget *widget); + void (* draw) (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget, + const GdkRectangle *draw_area, + const GdkRectangle *expose_area); + void (* render) (GimpViewRenderer *renderer, + GtkWidget *widget); }; -GType gimp_preview_renderer_get_type (void) G_GNUC_CONST; +GType gimp_view_renderer_get_type (void) G_GNUC_CONST; -GimpPreviewRenderer * gimp_preview_renderer_new (GType viewable_type, - gint size, - gint border_width, - gboolean is_popup); -GimpPreviewRenderer * gimp_preview_renderer_new_full (GType viewable_type, - gint width, - gint height, - gint border_width, - gboolean is_popup); +GimpViewRenderer * gimp_view_renderer_new (GType viewable_type, + gint size, + gint border_width, + gboolean is_popup); +GimpViewRenderer * gimp_view_renderer_new_full (GType viewable_type, + gint width, + gint height, + gint border_width, + gboolean is_popup); -void gimp_preview_renderer_set_viewable (GimpPreviewRenderer *renderer, - GimpViewable *viewable); -void gimp_preview_renderer_set_size (GimpPreviewRenderer *renderer, - gint size, - gint border_width); -void gimp_preview_renderer_set_size_full (GimpPreviewRenderer *renderer, - gint width, - gint height, - gint border_width); -void gimp_preview_renderer_set_dot_for_dot (GimpPreviewRenderer *renderer, - gboolean dot_for_dot); -void gimp_preview_renderer_set_border_type (GimpPreviewRenderer *renderer, - GimpPreviewBorderType border_type); -void gimp_preview_renderer_set_border_color (GimpPreviewRenderer *renderer, - const GimpRGB *border_color); -void gimp_preview_renderer_set_background (GimpPreviewRenderer *renderer, - const gchar *stock_id); +void gimp_view_renderer_set_viewable (GimpViewRenderer *renderer, + GimpViewable *viewable); +void gimp_view_renderer_set_size (GimpViewRenderer *renderer, + gint size, + gint border_width); +void gimp_view_renderer_set_size_full (GimpViewRenderer *renderer, + gint width, + gint height, + gint border_width); +void gimp_view_renderer_set_dot_for_dot (GimpViewRenderer *renderer, + gboolean dot_for_dot); +void gimp_view_renderer_set_border_type (GimpViewRenderer *renderer, + GimpViewBorderType border_type); +void gimp_view_renderer_set_border_color (GimpViewRenderer *renderer, + const GimpRGB *border_color); +void gimp_view_renderer_set_background (GimpViewRenderer *renderer, + const gchar *stock_id); -void gimp_preview_renderer_unrealize (GimpPreviewRenderer *renderer); +void gimp_view_renderer_unrealize (GimpViewRenderer *renderer); -void gimp_preview_renderer_invalidate (GimpPreviewRenderer *renderer); -void gimp_preview_renderer_update (GimpPreviewRenderer *renderer); -void gimp_preview_renderer_update_idle (GimpPreviewRenderer *renderer); -void gimp_preview_renderer_remove_idle (GimpPreviewRenderer *renderer); +void gimp_view_renderer_invalidate (GimpViewRenderer *renderer); +void gimp_view_renderer_update (GimpViewRenderer *renderer); +void gimp_view_renderer_update_idle (GimpViewRenderer *renderer); +void gimp_view_renderer_remove_idle (GimpViewRenderer *renderer); -void gimp_preview_renderer_draw (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget, - const GdkRectangle *draw_area, - const GdkRectangle *expose_area); +void gimp_view_renderer_draw (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget, + const GdkRectangle *draw_area, + const GdkRectangle *expose_area); /* protected */ -void gimp_preview_renderer_default_render_buffer (GimpPreviewRenderer *renderer, - GtkWidget *widget, - TempBuf *temp_buf); -void gimp_preview_renderer_default_render_stock (GimpPreviewRenderer *renderer, - GtkWidget *widget, - const gchar *stock_id); -void gimp_preview_renderer_render_buffer (GimpPreviewRenderer *renderer, - TempBuf *temp_buf, - gint channel, - GimpPreviewBG inside_bg, - GimpPreviewBG outside_bg); +void gimp_view_renderer_default_render_buffer (GimpViewRenderer *renderer, + GtkWidget *widget, + TempBuf *temp_buf); +void gimp_view_renderer_default_render_stock (GimpViewRenderer *renderer, + GtkWidget *widget, + const gchar *stock_id); +void gimp_view_renderer_render_buffer (GimpViewRenderer *renderer, + TempBuf *temp_buf, + gint channel, + GimpViewBG inside_bg, + GimpViewBG outside_bg); /* general purpose temp_buf to buffer projection function */ -void gimp_preview_render_to_buffer (TempBuf *temp_buf, - gint channel, - GimpPreviewBG inside_bg, - GimpPreviewBG outside_bg, - guchar *dest_buffer, - gint dest_width, - gint dest_height, - gint dest_rowstride, - gint dest_bytes); +void gimp_view_render_to_buffer (TempBuf *temp_buf, + gint channel, + GimpViewBG inside_bg, + GimpViewBG outside_bg, + guchar *dest_buffer, + gint dest_width, + gint dest_height, + gint dest_rowstride, + gint dest_bytes); -#endif /* __GIMP_PREVIEW_RENDERER_H__ */ +#endif /* __GIMP_VIEW_RENDERER_H__ */ diff --git a/app/widgets/gimpviewrendererbrush.c b/app/widgets/gimpviewrendererbrush.c index 4b33be1957..fc8892fdcc 100644 --- a/app/widgets/gimpviewrendererbrush.c +++ b/app/widgets/gimpviewrendererbrush.c @@ -36,14 +36,14 @@ 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 (GimpPreviewRenderer *renderer, - GtkWidget *widget); +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 gboolean gimp_preview_renderer_brush_render_timeout (gpointer data); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -66,7 +66,7 @@ gimp_preview_renderer_brush_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_brush_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererBrush", &renderer_info, 0); } @@ -77,11 +77,11 @@ gimp_preview_renderer_brush_get_type (void) static void gimp_preview_renderer_brush_class_init (GimpPreviewRendererBrushClass *klass) { - GObjectClass *object_class; - GimpPreviewRendererClass *renderer_class; + GObjectClass *object_class; + GimpViewRendererClass *renderer_class; object_class = G_OBJECT_CLASS (klass); - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -112,8 +112,8 @@ gimp_preview_renderer_brush_finalize (GObject *object) } static void -gimp_preview_renderer_brush_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_brush_render (GimpViewRenderer *renderer, + GtkWidget *widget) { GimpPreviewRendererBrush *renderbrush; GimpBrush *brush; @@ -145,26 +145,26 @@ gimp_preview_renderer_brush_render (GimpPreviewRenderer *renderer, if (renderer->is_popup) { - gimp_preview_renderer_render_buffer (renderer, temp_buf, -1, - GIMP_PREVIEW_BG_WHITE, - GIMP_PREVIEW_BG_WHITE); + 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 = + { + renderbrush->pipe_animation_index = 0; + renderbrush->pipe_timeout_id = g_timeout_add (300, gimp_preview_renderer_brush_render_timeout, renderbrush); - } + } return; } - gimp_preview_renderer_render_buffer (renderer, temp_buf, -1, - GIMP_PREVIEW_BG_WHITE, - GIMP_PREVIEW_BG_WHITE); + gimp_view_renderer_render_buffer (renderer, temp_buf, -1, + GIMP_VIEW_BG_WHITE, + GIMP_VIEW_BG_WHITE); temp_buf_free (temp_buf); @@ -282,13 +282,13 @@ static gboolean gimp_preview_renderer_brush_render_timeout (gpointer data) { GimpPreviewRendererBrush *renderbrush; - GimpPreviewRenderer *renderer; + GimpViewRenderer *renderer; GimpBrushPipe *brush_pipe; GimpBrush *brush; TempBuf *temp_buf; renderbrush = GIMP_PREVIEW_RENDERER_BRUSH (data); - renderer = GIMP_PREVIEW_RENDERER (data); + renderer = GIMP_VIEW_RENDERER (data); if (! renderer->viewable) { @@ -309,16 +309,16 @@ gimp_preview_renderer_brush_render_timeout (gpointer data) GIMP_BRUSH (brush_pipe->brushes[renderbrush->pipe_animation_index]); temp_buf = gimp_viewable_get_new_preview (GIMP_VIEWABLE (brush), - renderer->width, - renderer->height); + renderer->width, + renderer->height); - gimp_preview_renderer_render_buffer (renderer, temp_buf, -1, - GIMP_PREVIEW_BG_WHITE, - GIMP_PREVIEW_BG_WHITE); + gimp_view_renderer_render_buffer (renderer, temp_buf, -1, + GIMP_VIEW_BG_WHITE, + GIMP_VIEW_BG_WHITE); temp_buf_free (temp_buf); - gimp_preview_renderer_update (renderer); + gimp_view_renderer_update (renderer); return TRUE; } diff --git a/app/widgets/gimpviewrendererbrush.h b/app/widgets/gimpviewrendererbrush.h index 38a5c0a78d..8181bd3de6 100644 --- a/app/widgets/gimpviewrendererbrush.h +++ b/app/widgets/gimpviewrendererbrush.h @@ -22,7 +22,7 @@ #ifndef __GIMP_PREVIEW_RENDERER_BRUSH_H__ #define __GIMP_PREVIEW_RENDERER_BRUSH_H__ -#include "gimppreviewrenderer.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)) @@ -36,15 +36,15 @@ typedef struct _GimpPreviewRendererBrushClass GimpPreviewRendererBrushClass; struct _GimpPreviewRendererBrush { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; - guint pipe_timeout_id; - gint pipe_animation_index; + guint pipe_timeout_id; + gint pipe_animation_index; }; struct _GimpPreviewRendererBrushClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimpviewrendererdrawable.c b/app/widgets/gimpviewrendererdrawable.c index 11858e2262..71384a5725 100644 --- a/app/widgets/gimpviewrendererdrawable.c +++ b/app/widgets/gimpviewrendererdrawable.c @@ -38,11 +38,11 @@ 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 (GimpPreviewRenderer *renderer, - GtkWidget *widget); +static void gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer, + GtkWidget *widget); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -65,7 +65,7 @@ gimp_preview_renderer_drawable_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_drawable_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererDrawable", &renderer_info, 0); } @@ -76,9 +76,9 @@ gimp_preview_renderer_drawable_get_type (void) static void gimp_preview_renderer_drawable_class_init (GimpPreviewRendererDrawableClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -91,8 +91,8 @@ gimp_preview_renderer_drawable_init (GimpPreviewRendererDrawable *renderer) } static void -gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_drawable_render (GimpViewRenderer *renderer, + GtkWidget *widget) { GimpDrawable *drawable; GimpItem *item; @@ -114,9 +114,9 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, if (gimage && ! renderer->is_popup) { width = MAX (1, ROUND ((((gdouble) width / (gdouble) gimage->width) * - (gdouble) item->width))); + (gdouble) item->width))); height = MAX (1, ROUND ((((gdouble) height / (gdouble) gimage->height) * - (gdouble) item->height))); + (gdouble) item->height))); gimp_viewable_calc_preview_size (item->width, item->height, @@ -149,7 +149,7 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, temp_buf = gimp_viewable_get_new_preview (renderer->viewable, item->width, - item->height); + item->height); if (temp_buf) { @@ -161,8 +161,8 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, else { render_buf = gimp_viewable_get_new_preview (renderer->viewable, - preview_width, - preview_height); + preview_width, + preview_height); } if (render_buf) @@ -188,9 +188,9 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, render_buf->y = (height - preview_height) / 2; } - gimp_preview_renderer_render_buffer (renderer, render_buf, -1, - GIMP_PREVIEW_BG_CHECKS, - GIMP_PREVIEW_BG_CHECKS); + gimp_view_renderer_render_buffer (renderer, render_buf, -1, + GIMP_VIEW_BG_CHECKS, + GIMP_VIEW_BG_CHECKS); temp_buf_free (render_buf); } @@ -200,6 +200,6 @@ gimp_preview_renderer_drawable_render (GimpPreviewRenderer *renderer, stock_id = gimp_viewable_get_stock_id (renderer->viewable); - gimp_preview_renderer_default_render_stock (renderer, widget, stock_id); + gimp_view_renderer_default_render_stock (renderer, widget, stock_id); } } diff --git a/app/widgets/gimpviewrendererdrawable.h b/app/widgets/gimpviewrendererdrawable.h index c986b39cb2..853cadc884 100644 --- a/app/widgets/gimpviewrendererdrawable.h +++ b/app/widgets/gimpviewrendererdrawable.h @@ -22,7 +22,7 @@ #ifndef __GIMP_PREVIEW_RENDERER_DRAWABLE_H__ #define __GIMP_PREVIEW_RENDERER_DRAWABLE_H__ -#include "gimppreviewrenderer.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)) @@ -36,12 +36,12 @@ typedef struct _GimpPreviewRendererDrawableClass GimpPreviewRendererDrawableCla struct _GimpPreviewRendererDrawable { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; }; struct _GimpPreviewRendererDrawableClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimpviewrenderergradient.c b/app/widgets/gimpviewrenderergradient.c index 9c3353ec49..b540277512 100644 --- a/app/widgets/gimpviewrenderergradient.c +++ b/app/widgets/gimpviewrenderergradient.c @@ -47,11 +47,11 @@ static void gimp_preview_renderer_gradient_init (GimpPreviewRendererGrad static void gimp_preview_renderer_gradient_finalize (GObject *object); -static void gimp_preview_renderer_gradient_render (GimpPreviewRenderer *renderer, +static void gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer, GtkWidget *widget); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -74,7 +74,7 @@ gimp_preview_renderer_gradient_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_gradient_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererGradient", &renderer_info, 0); } @@ -85,11 +85,11 @@ gimp_preview_renderer_gradient_get_type (void) static void gimp_preview_renderer_gradient_class_init (GimpPreviewRendererGradientClass *klass) { - GObjectClass *object_class; - GimpPreviewRendererClass *renderer_class; + GObjectClass *object_class; + GimpViewRendererClass *renderer_class; object_class = G_OBJECT_CLASS (klass); - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -132,8 +132,8 @@ gimp_preview_renderer_gradient_finalize (GObject *object) } static void -gimp_preview_renderer_gradient_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_gradient_render (GimpViewRenderer *renderer, + GtkWidget *widget) { GimpPreviewRendererGradient *rendergrad; GimpGradient *gradient; @@ -237,10 +237,10 @@ gimp_preview_renderer_gradient_set_offsets (GimpPreviewRendererGradient *rendere renderer->left = left; renderer->right = right; - gimp_preview_renderer_invalidate (GIMP_PREVIEW_RENDERER (renderer)); + gimp_view_renderer_invalidate (GIMP_VIEW_RENDERER (renderer)); if (instant_update) - gimp_preview_renderer_update (GIMP_PREVIEW_RENDERER (renderer)); + gimp_view_renderer_update (GIMP_VIEW_RENDERER (renderer)); } } @@ -254,7 +254,7 @@ gimp_preview_renderer_gradient_set_reverse (GimpPreviewRendererGradient *rendere { renderer->reverse = reverse ? TRUE : FALSE; - gimp_preview_renderer_invalidate (GIMP_PREVIEW_RENDERER (renderer)); - gimp_preview_renderer_update (GIMP_PREVIEW_RENDERER (renderer)); + gimp_view_renderer_invalidate (GIMP_VIEW_RENDERER (renderer)); + gimp_view_renderer_update (GIMP_VIEW_RENDERER (renderer)); } } diff --git a/app/widgets/gimpviewrenderergradient.h b/app/widgets/gimpviewrenderergradient.h index 35248d456c..20d556e2e7 100644 --- a/app/widgets/gimpviewrenderergradient.h +++ b/app/widgets/gimpviewrenderergradient.h @@ -22,7 +22,7 @@ #ifndef __GIMP_PREVIEW_RENDERER_GRADIENT_H__ #define __GIMP_PREVIEW_RENDERER_GRADIENT_H__ -#include "gimppreviewrenderer.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)) @@ -36,20 +36,20 @@ typedef struct _GimpPreviewRendererGradientClass GimpPreviewRendererGradientCla struct _GimpPreviewRendererGradient { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; - guchar *even; - guchar *odd; - gint width; - gdouble left; - gdouble right; + guchar *even; + guchar *odd; + gint width; + gdouble left; + gdouble right; - gboolean reverse; + gboolean reverse; }; struct _GimpPreviewRendererGradientClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimpviewrendererimage.c b/app/widgets/gimpviewrendererimage.c index 21c4d25283..02d98da664 100644 --- a/app/widgets/gimpviewrendererimage.c +++ b/app/widgets/gimpviewrendererimage.c @@ -37,11 +37,11 @@ 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 (GimpPreviewRenderer *renderer, - GtkWidget *widget); +static void gimp_preview_renderer_image_render (GimpViewRenderer *renderer, + GtkWidget *widget); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -64,7 +64,7 @@ gimp_preview_renderer_image_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_image_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererImage", &renderer_info, 0); } @@ -75,9 +75,9 @@ gimp_preview_renderer_image_get_type (void) static void gimp_preview_renderer_image_class_init (GimpPreviewRendererImageClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -91,8 +91,8 @@ gimp_preview_renderer_image_init (GimpPreviewRendererImage *renderer) } static void -gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_image_render (GimpViewRenderer *renderer, + GtkWidget *widget) { GimpPreviewRendererImage *rendererimage; GimpImage *gimage; @@ -121,7 +121,7 @@ gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, TempBuf *temp_buf; temp_buf = gimp_viewable_get_new_preview (renderer->viewable, - gimage->width, gimage->height); + gimage->width, gimage->height); if (temp_buf) { @@ -134,8 +134,8 @@ gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, else { render_buf = gimp_viewable_get_new_preview (renderer->viewable, - preview_width, - preview_height); + preview_width, + preview_height); } if (render_buf) @@ -164,10 +164,10 @@ gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, component_index = gimp_image_get_component_index (gimage, rendererimage->channel); - gimp_preview_renderer_render_buffer (renderer, render_buf, - component_index, - GIMP_PREVIEW_BG_CHECKS, - GIMP_PREVIEW_BG_WHITE); + gimp_view_renderer_render_buffer (renderer, render_buf, + component_index, + GIMP_VIEW_BG_CHECKS, + GIMP_VIEW_BG_WHITE); temp_buf_free (render_buf); } @@ -189,6 +189,6 @@ gimp_preview_renderer_image_render (GimpPreviewRenderer *renderer, break; } - gimp_preview_renderer_default_render_stock (renderer, widget, stock_id); + gimp_view_renderer_default_render_stock (renderer, widget, stock_id); } } diff --git a/app/widgets/gimpviewrendererimage.h b/app/widgets/gimpviewrendererimage.h index 5e7bda935c..3d2faf467c 100644 --- a/app/widgets/gimpviewrendererimage.h +++ b/app/widgets/gimpviewrendererimage.h @@ -22,7 +22,7 @@ #ifndef __GIMP_PREVIEW_RENDERER_IMAGE_H__ #define __GIMP_PREVIEW_RENDERER_IMAGE_H__ -#include "gimppreviewrenderer.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)) @@ -36,14 +36,14 @@ typedef struct _GimpPreviewRendererImageClass GimpPreviewRendererImageClass; struct _GimpPreviewRendererImage { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; GimpChannelType channel; }; struct _GimpPreviewRendererImageClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimpviewrendererimagefile.c b/app/widgets/gimpviewrendererimagefile.c index 1f765a25d2..7fcc93fef1 100644 --- a/app/widgets/gimpviewrendererimagefile.c +++ b/app/widgets/gimpviewrendererimagefile.c @@ -45,11 +45,11 @@ 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 (GimpPreviewRenderer *renderer, - GtkWidget *widget); +static void gimp_preview_renderer_imagefile_render (GimpViewRenderer *renderer, + GtkWidget *widget); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -72,7 +72,7 @@ gimp_preview_renderer_imagefile_get_type (void) (GInstanceInitFunc) gimp_preview_renderer_imagefile_init, }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererImagefile", &renderer_info, 0); } @@ -83,9 +83,9 @@ gimp_preview_renderer_imagefile_get_type (void) static void gimp_preview_renderer_imagefile_class_init (GimpPreviewRendererImagefileClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -101,8 +101,8 @@ gimp_preview_renderer_imagefile_init (GimpPreviewRendererImagefile *renderer) } static void -gimp_preview_renderer_imagefile_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_imagefile_render (GimpViewRenderer *renderer, + GtkWidget *widget) { TempBuf *temp_buf = gimp_viewable_get_preview (renderer->viewable, renderer->width, @@ -110,7 +110,7 @@ gimp_preview_renderer_imagefile_render (GimpPreviewRenderer *renderer, if (temp_buf) { - gimp_preview_renderer_default_render_buffer (renderer, widget, temp_buf); + gimp_view_renderer_default_render_buffer (renderer, widget, temp_buf); } else { @@ -171,9 +171,9 @@ gimp_preview_renderer_imagefile_render (GimpPreviewRenderer *renderer, if (temp_buf->height < renderer->height) temp_buf->y = (renderer->height - temp_buf->height) / 2; - gimp_preview_renderer_render_buffer (renderer, temp_buf, -1, - GIMP_PREVIEW_BG_WHITE, - GIMP_PREVIEW_BG_WHITE); + 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); @@ -184,8 +184,8 @@ gimp_preview_renderer_imagefile_render (GimpPreviewRenderer *renderer, stock_id = gimp_viewable_get_stock_id (renderer->viewable); - gimp_preview_renderer_default_render_stock (renderer, widget, - stock_id); + gimp_view_renderer_default_render_stock (renderer, widget, + stock_id); } } } diff --git a/app/widgets/gimpviewrendererimagefile.h b/app/widgets/gimpviewrendererimagefile.h index 446fcfee1a..fb6137b001 100644 --- a/app/widgets/gimpviewrendererimagefile.h +++ b/app/widgets/gimpviewrendererimagefile.h @@ -23,7 +23,7 @@ #define __GIMP_PREVIEW_RENDERER_IMAGEFILE_H__ -#include "gimppreviewrenderer.h" +#include "gimpviewrenderer.h" /* #define ENABLE_FILE_SYSTEM_ICONS 1 */ @@ -40,7 +40,7 @@ typedef struct _GimpPreviewRendererImagefileClass GimpPreviewRendererImagefileC struct _GimpPreviewRendererImagefile { - GimpPreviewRenderer parent_instance; + GimpViewRenderer parent_instance; #ifdef ENABLE_FILE_SYSTEM_ICONS gpointer file_system; @@ -49,7 +49,7 @@ struct _GimpPreviewRendererImagefile struct _GimpPreviewRendererImagefileClass { - GimpPreviewRendererClass parent_class; + GimpViewRendererClass parent_class; }; diff --git a/app/widgets/gimpviewrendererlayer.c b/app/widgets/gimpviewrendererlayer.c index 992fd67a1a..2ad0429d31 100644 --- a/app/widgets/gimpviewrendererlayer.c +++ b/app/widgets/gimpviewrendererlayer.c @@ -34,8 +34,8 @@ static void gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass); -static void gimp_preview_renderer_layer_render (GimpPreviewRenderer *renderer, - GtkWidget *widget); +static void gimp_preview_renderer_layer_render (GimpViewRenderer *renderer, + GtkWidget *widget); static GimpPreviewRendererDrawableClass *parent_class = NULL; @@ -72,9 +72,9 @@ gimp_preview_renderer_layer_get_type (void) static void gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -82,8 +82,8 @@ gimp_preview_renderer_layer_class_init (GimpPreviewRendererLayerClass *klass) } static void -gimp_preview_renderer_layer_render (GimpPreviewRenderer *renderer, - GtkWidget *widget) +gimp_preview_renderer_layer_render (GimpViewRenderer *renderer, + GtkWidget *widget) { const gchar *stock_id = NULL; @@ -97,7 +97,7 @@ gimp_preview_renderer_layer_render (GimpPreviewRenderer *renderer, } if (stock_id) - gimp_preview_renderer_default_render_stock (renderer, widget, stock_id); + gimp_view_renderer_default_render_stock (renderer, widget, stock_id); else - GIMP_PREVIEW_RENDERER_CLASS (parent_class)->render (renderer, widget); + GIMP_VIEW_RENDERER_CLASS (parent_class)->render (renderer, widget); } diff --git a/app/widgets/gimpviewrenderervectors.c b/app/widgets/gimpviewrenderervectors.c index 78d3b95470..fda7acc78d 100644 --- a/app/widgets/gimpviewrenderervectors.c +++ b/app/widgets/gimpviewrenderervectors.c @@ -39,14 +39,14 @@ static void gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass); -static void gimp_preview_renderer_vectors_draw (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget, - const GdkRectangle *draw_area, - const GdkRectangle *expose_area); +static void gimp_preview_renderer_vectors_draw (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget, + const GdkRectangle *draw_area, + const GdkRectangle *expose_area); -static GimpPreviewRendererClass *parent_class = NULL; +static GimpViewRendererClass *parent_class = NULL; GType @@ -69,7 +69,7 @@ gimp_preview_renderer_vectors_get_type (void) NULL, /* instance_init */ }; - renderer_type = g_type_register_static (GIMP_TYPE_PREVIEW_RENDERER, + renderer_type = g_type_register_static (GIMP_TYPE_VIEW_RENDERER, "GimpPreviewRendererVectors", &renderer_info, 0); } @@ -80,9 +80,9 @@ gimp_preview_renderer_vectors_get_type (void) static void gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass) { - GimpPreviewRendererClass *renderer_class; + GimpViewRendererClass *renderer_class; - renderer_class = GIMP_PREVIEW_RENDERER_CLASS (klass); + renderer_class = GIMP_VIEW_RENDERER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -90,11 +90,11 @@ gimp_preview_renderer_vectors_class_init (GimpPreviewRendererVectorsClass *klass } static void -gimp_preview_renderer_vectors_draw (GimpPreviewRenderer *renderer, - GdkWindow *window, - GtkWidget *widget, - const GdkRectangle *draw_area, - const GdkRectangle *expose_area) +gimp_preview_renderer_vectors_draw (GimpViewRenderer *renderer, + GdkWindow *window, + GtkWidget *widget, + const GdkRectangle *draw_area, + const GdkRectangle *expose_area) { GimpVectors *vectors; GimpStroke *stroke; diff --git a/app/widgets/widgets-enums.h b/app/widgets/widgets-enums.h index 7bc78e23b3..1056f69f89 100644 --- a/app/widgets/widgets-enums.h +++ b/app/widgets/widgets-enums.h @@ -162,17 +162,17 @@ typedef enum typedef enum /*< skip >*/ { - GIMP_PREVIEW_BG_CHECKS, - GIMP_PREVIEW_BG_WHITE -} GimpPreviewBG; + GIMP_VIEW_BG_CHECKS, + GIMP_VIEW_BG_WHITE +} GimpViewBG; typedef enum /*< skip >*/ { - GIMP_PREVIEW_BORDER_BLACK, - GIMP_PREVIEW_BORDER_WHITE, - GIMP_PREVIEW_BORDER_RED, - GIMP_PREVIEW_BORDER_GREEN -} GimpPreviewBorderType; + GIMP_VIEW_BORDER_BLACK, + GIMP_VIEW_BORDER_WHITE, + GIMP_VIEW_BORDER_RED, + GIMP_VIEW_BORDER_GREEN +} GimpViewBorderType; typedef enum /*< skip >*/ { diff --git a/app/widgets/widgets-types.h b/app/widgets/widgets-types.h index ad4b70c1dd..81c7f60f8b 100644 --- a/app/widgets/widgets-types.h +++ b/app/widgets/widgets-types.h @@ -170,7 +170,7 @@ typedef struct _GimpNavigationPreview GimpNavigationPreview; /* preview renderers */ -typedef struct _GimpPreviewRenderer GimpPreviewRenderer; +typedef struct _GimpViewRenderer GimpViewRenderer; typedef struct _GimpPreviewRendererBrush GimpPreviewRendererBrush; typedef struct _GimpPreviewRendererDrawable GimpPreviewRendererDrawable; typedef struct _GimpPreviewRendererGradient GimpPreviewRendererGradient;