mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-23 13:01:42 +00:00
33d35e65db
2003-09-30 Michael Natterer <mitch@gimp.org> * app/widgets/gimpcontainergridview.c * app/widgets/gimpcontainertreeview.c: implement GtkWidget::popup_menu() and pop up the menu from the selected item. If there is no selected item, return FALSE to makeGimpDockable pop up the menu from its menu button.
732 lines
23 KiB
C
732 lines
23 KiB
C
/* The GIMP -- an image manipulation program
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
*
|
|
* gimpcontainergridview.c
|
|
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <gtk/gtk.h>
|
|
#include <gdk/gdkkeysyms.h>
|
|
|
|
#include "libgimpcolor/gimpcolor.h"
|
|
|
|
#include "widgets-types.h"
|
|
|
|
#include "core/gimpcontainer.h"
|
|
#include "core/gimpcontext.h"
|
|
#include "core/gimpmarshal.h"
|
|
#include "core/gimpviewable.h"
|
|
|
|
#include "gimpcontainergridview.h"
|
|
#include "gimpitemfactory.h"
|
|
#include "gimppreview.h"
|
|
#include "gimppreviewrenderer.h"
|
|
#include "gtkhwrapbox.h"
|
|
|
|
#include "gimp-intl.h"
|
|
|
|
|
|
enum
|
|
{
|
|
MOVE_CURSOR,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
|
|
static void gimp_container_grid_view_class_init (GimpContainerGridViewClass *klass);
|
|
static void gimp_container_grid_view_init (GimpContainerGridView *view);
|
|
|
|
static gboolean gimp_container_grid_view_move_cursor (GimpContainerGridView *view,
|
|
GtkMovementStep step,
|
|
gint count);
|
|
static gboolean gimp_container_grid_view_focus (GtkWidget *widget,
|
|
GtkDirectionType direction);
|
|
static gboolean gimp_container_grid_view_popup_menu (GtkWidget *widget);
|
|
|
|
static gpointer gimp_container_grid_view_insert_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gint index);
|
|
static void gimp_container_grid_view_remove_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gpointer insert_data);
|
|
static void gimp_container_grid_view_reorder_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gint new_index,
|
|
gpointer insert_data);
|
|
static gboolean gimp_container_grid_view_select_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gpointer insert_data);
|
|
static void gimp_container_grid_view_clear_items (GimpContainerView *view);
|
|
static void gimp_container_grid_view_set_preview_size (GimpContainerView *view);
|
|
static gboolean gimp_container_grid_view_item_selected(GtkWidget *widget,
|
|
GdkEventButton *bevent,
|
|
gpointer data);
|
|
static void gimp_container_grid_view_item_activated (GtkWidget *widget,
|
|
gpointer data);
|
|
static void gimp_container_grid_view_item_context (GtkWidget *widget,
|
|
gpointer data);
|
|
static void gimp_container_grid_view_highlight_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gpointer insert_data);
|
|
|
|
static void gimp_container_grid_view_vieport_resized (GtkWidget *widget,
|
|
GtkAllocation *allocation,
|
|
GimpContainerGridView *view);
|
|
static void gimp_container_grid_view_vieport_realize (GtkWidget *widget,
|
|
GimpContainerGridView *view);
|
|
|
|
|
|
static GimpContainerViewClass *parent_class = NULL;
|
|
static guint grid_view_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
static GimpRGB white_color;
|
|
static GimpRGB black_color;
|
|
|
|
|
|
GType
|
|
gimp_container_grid_view_get_type (void)
|
|
{
|
|
static GType view_type = 0;
|
|
|
|
if (! view_type)
|
|
{
|
|
static const GTypeInfo view_info =
|
|
{
|
|
sizeof (GimpContainerGridViewClass),
|
|
NULL, /* base_init */
|
|
NULL, /* base_finalize */
|
|
(GClassInitFunc) gimp_container_grid_view_class_init,
|
|
NULL, /* class_finalize */
|
|
NULL, /* class_data */
|
|
sizeof (GimpContainerGridView),
|
|
0, /* n_preallocs */
|
|
(GInstanceInitFunc) gimp_container_grid_view_init,
|
|
};
|
|
|
|
view_type = g_type_register_static (GIMP_TYPE_CONTAINER_VIEW,
|
|
"GimpContainerGridView",
|
|
&view_info, 0);
|
|
}
|
|
|
|
return view_type;
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_class_init (GimpContainerGridViewClass *klass)
|
|
{
|
|
GimpContainerViewClass *container_view_class;
|
|
GtkWidgetClass *widget_class;
|
|
GtkBindingSet *binding_set;
|
|
|
|
container_view_class = GIMP_CONTAINER_VIEW_CLASS (klass);
|
|
widget_class = GTK_WIDGET_CLASS (klass);
|
|
|
|
parent_class = g_type_class_peek_parent (klass);
|
|
binding_set = gtk_binding_set_by_class (klass);
|
|
|
|
widget_class->focus = gimp_container_grid_view_focus;
|
|
widget_class->popup_menu = gimp_container_grid_view_popup_menu;
|
|
|
|
container_view_class->insert_item = gimp_container_grid_view_insert_item;
|
|
container_view_class->remove_item = gimp_container_grid_view_remove_item;
|
|
container_view_class->reorder_item = gimp_container_grid_view_reorder_item;
|
|
container_view_class->select_item = gimp_container_grid_view_select_item;
|
|
container_view_class->clear_items = gimp_container_grid_view_clear_items;
|
|
container_view_class->set_preview_size = gimp_container_grid_view_set_preview_size;
|
|
|
|
klass->move_cursor = gimp_container_grid_view_move_cursor;
|
|
|
|
grid_view_signals[MOVE_CURSOR] =
|
|
g_signal_new ("move_cursor",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
G_STRUCT_OFFSET (GimpContainerGridViewClass, move_cursor),
|
|
NULL, NULL,
|
|
gimp_marshal_BOOLEAN__ENUM_INT,
|
|
G_TYPE_BOOLEAN, 2,
|
|
GTK_TYPE_MOVEMENT_STEP,
|
|
G_TYPE_INT);
|
|
|
|
gtk_binding_entry_add_signal (binding_set, GDK_Home, 0,
|
|
"move_cursor", 2,
|
|
G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS,
|
|
G_TYPE_INT, -1);
|
|
gtk_binding_entry_add_signal (binding_set, GDK_End, 0,
|
|
"move_cursor", 2,
|
|
G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS,
|
|
G_TYPE_INT, 1);
|
|
gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, 0,
|
|
"move_cursor", 2,
|
|
G_TYPE_ENUM, GTK_MOVEMENT_PAGES,
|
|
G_TYPE_INT, -1);
|
|
gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, 0,
|
|
"move_cursor", 2,
|
|
G_TYPE_ENUM, GTK_MOVEMENT_PAGES,
|
|
G_TYPE_INT, 1);
|
|
|
|
gimp_rgba_set (&white_color, 1.0, 1.0, 1.0, 1.0);
|
|
gimp_rgba_set (&black_color, 0.0, 0.0, 0.0, 1.0);
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_init (GimpContainerGridView *grid_view)
|
|
{
|
|
GimpContainerView *view;
|
|
|
|
view = GIMP_CONTAINER_VIEW (grid_view);
|
|
|
|
grid_view->rows = 1;
|
|
grid_view->columns = 1;
|
|
grid_view->visible_rows = 0;
|
|
grid_view->selected_item = NULL;
|
|
|
|
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view->scrolled_win),
|
|
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
|
|
|
|
grid_view->name_label = gtk_label_new (_("(None)"));
|
|
gtk_misc_set_alignment (GTK_MISC (grid_view->name_label), 0.0, 0.5);
|
|
gtk_box_pack_start (GTK_BOX (grid_view), grid_view->name_label,
|
|
FALSE, FALSE, 0);
|
|
gtk_box_reorder_child (GTK_BOX (grid_view), grid_view->name_label, 0);
|
|
gtk_widget_show (grid_view->name_label);
|
|
|
|
grid_view->wrap_box = gtk_hwrap_box_new (FALSE);
|
|
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (view->scrolled_win),
|
|
grid_view->wrap_box);
|
|
gtk_widget_show (grid_view->wrap_box);
|
|
|
|
g_signal_connect (grid_view->wrap_box->parent, "size_allocate",
|
|
G_CALLBACK (gimp_container_grid_view_vieport_resized),
|
|
grid_view);
|
|
|
|
#ifdef __GNUC__
|
|
#warning FIXME: remove realize callback once we depend on GTK+ 2.2.2
|
|
#endif
|
|
if (! GTK_CHECK_VERSION (2, 2, 2))
|
|
g_signal_connect (grid_view->wrap_box->parent, "realize",
|
|
G_CALLBACK (gimp_container_grid_view_vieport_realize),
|
|
grid_view);
|
|
|
|
GTK_WIDGET_SET_FLAGS (grid_view, GTK_CAN_FOCUS);
|
|
}
|
|
|
|
GtkWidget *
|
|
gimp_container_grid_view_new (GimpContainer *container,
|
|
GimpContext *context,
|
|
gint preview_size,
|
|
gint preview_border_width,
|
|
gboolean reorderable)
|
|
{
|
|
GimpContainerGridView *grid_view;
|
|
|
|
g_return_val_if_fail (container == NULL || GIMP_IS_CONTAINER (container),
|
|
NULL);
|
|
g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), 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,
|
|
NULL);
|
|
|
|
grid_view = g_object_new (GIMP_TYPE_CONTAINER_GRID_VIEW, NULL);
|
|
|
|
gimp_container_view_construct (GIMP_CONTAINER_VIEW (grid_view),
|
|
container, context,
|
|
preview_size, preview_border_width,
|
|
reorderable);
|
|
|
|
return GTK_WIDGET (grid_view);
|
|
}
|
|
|
|
static gboolean
|
|
gimp_container_grid_view_move_by (GimpContainerGridView *view,
|
|
gint x,
|
|
gint y)
|
|
{
|
|
GimpContainer *container;
|
|
GimpViewable *item;
|
|
gint index;
|
|
|
|
if (! view->selected_item)
|
|
return FALSE;
|
|
|
|
container = GIMP_CONTAINER_VIEW (view)->container;
|
|
|
|
item = view->selected_item->viewable;
|
|
|
|
index = gimp_container_get_child_index (container, GIMP_OBJECT (item));
|
|
|
|
index += x;
|
|
index = CLAMP (index, 0, container->num_children - 1);
|
|
|
|
index += y * view->columns;
|
|
while (index < 0)
|
|
index += view->columns;
|
|
while (index >= container->num_children)
|
|
index -= view->columns;
|
|
|
|
item = (GimpViewable *) gimp_container_get_child_by_index (container, index);
|
|
if (item)
|
|
gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (view), item);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gimp_container_grid_view_move_cursor (GimpContainerGridView *view,
|
|
GtkMovementStep step,
|
|
gint count)
|
|
{
|
|
GimpContainer *container;
|
|
GimpViewable *item;
|
|
|
|
if (!GTK_WIDGET_HAS_FOCUS (GTK_WIDGET (view)) || count == 0)
|
|
return FALSE;
|
|
|
|
switch (step)
|
|
{
|
|
case GTK_MOVEMENT_PAGES:
|
|
return gimp_container_grid_view_move_by (view,
|
|
0, count * view->visible_rows);
|
|
|
|
case GTK_MOVEMENT_BUFFER_ENDS:
|
|
container = GIMP_CONTAINER_VIEW (view)->container;
|
|
count = count < 0 ? 0 : container->num_children - 1;
|
|
|
|
item = (GimpViewable *) gimp_container_get_child_by_index (container,
|
|
count);
|
|
if (item)
|
|
gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (view), item);
|
|
|
|
return TRUE;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
gimp_container_grid_view_focus (GtkWidget *widget,
|
|
GtkDirectionType direction)
|
|
{
|
|
GimpContainerGridView *view;
|
|
|
|
if (GTK_WIDGET_CAN_FOCUS (widget) && !GTK_WIDGET_HAS_FOCUS (widget))
|
|
{
|
|
gtk_widget_grab_focus (GTK_WIDGET (widget));
|
|
return TRUE;
|
|
}
|
|
|
|
view = GIMP_CONTAINER_GRID_VIEW (widget);
|
|
|
|
switch (direction)
|
|
{
|
|
case GTK_DIR_UP:
|
|
return gimp_container_grid_view_move_by (view, 0, -1);
|
|
case GTK_DIR_DOWN:
|
|
return gimp_container_grid_view_move_by (view, 0, 1);
|
|
case GTK_DIR_LEFT:
|
|
return gimp_container_grid_view_move_by (view, -1, 0);
|
|
case GTK_DIR_RIGHT:
|
|
return gimp_container_grid_view_move_by (view, 1, 0);
|
|
|
|
case GTK_DIR_TAB_FORWARD:
|
|
case GTK_DIR_TAB_BACKWARD:
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_menu_position (GtkMenu *menu,
|
|
gint *x,
|
|
gint *y,
|
|
gpointer data)
|
|
{
|
|
GtkWidget *widget;
|
|
GtkRequisition requisition;
|
|
GdkScreen *screen;
|
|
|
|
widget = GTK_WIDGET (data);
|
|
|
|
gdk_window_get_origin (widget->window, x, y);
|
|
|
|
if (GTK_WIDGET_NO_WINDOW (widget))
|
|
{
|
|
*x += widget->allocation.x;
|
|
*y += widget->allocation.y;
|
|
}
|
|
|
|
*x += widget->allocation.width / 2;
|
|
*y += widget->allocation.height / 2;
|
|
|
|
gtk_widget_size_request (GTK_WIDGET (menu), &requisition);
|
|
|
|
screen = gtk_widget_get_screen (GTK_WIDGET (menu));
|
|
|
|
if (*x + requisition.width > gdk_screen_get_width (screen))
|
|
*x -= requisition.width;
|
|
|
|
if (*x < 0)
|
|
*x = 0;
|
|
|
|
if (*y + requisition.height > gdk_screen_get_height (screen))
|
|
*y -= requisition.height;
|
|
|
|
if (*y < 0)
|
|
*y = 0;
|
|
}
|
|
|
|
static gboolean
|
|
gimp_container_grid_view_popup_menu (GtkWidget *widget)
|
|
{
|
|
GimpContainerGridView *grid_view;
|
|
GimpEditor *editor;
|
|
|
|
grid_view = GIMP_CONTAINER_GRID_VIEW (widget);
|
|
editor = GIMP_EDITOR (widget);
|
|
|
|
if (editor->item_factory && grid_view->selected_item)
|
|
{
|
|
gimp_item_factory_popup_with_data (editor->item_factory,
|
|
editor->item_factory_data,
|
|
gimp_container_grid_view_menu_position,
|
|
grid_view->selected_item,
|
|
NULL);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gpointer
|
|
gimp_container_grid_view_insert_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gint index)
|
|
{
|
|
GimpContainerGridView *grid_view;
|
|
GtkWidget *preview;
|
|
|
|
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
|
|
|
preview = gimp_preview_new_full (viewable,
|
|
view->preview_size,
|
|
view->preview_size,
|
|
1,
|
|
FALSE, TRUE, TRUE);
|
|
gimp_preview_renderer_set_border_color (GIMP_PREVIEW (preview)->renderer,
|
|
&white_color);
|
|
|
|
gtk_wrap_box_pack (GTK_WRAP_BOX (grid_view->wrap_box), preview,
|
|
FALSE, FALSE, FALSE, FALSE);
|
|
|
|
if (index != -1)
|
|
gtk_wrap_box_reorder_child (GTK_WRAP_BOX (grid_view->wrap_box),
|
|
preview, index);
|
|
|
|
gtk_widget_show (preview);
|
|
|
|
g_signal_connect (preview, "button_press_event",
|
|
G_CALLBACK (gimp_container_grid_view_item_selected),
|
|
view);
|
|
g_signal_connect (preview, "double_clicked",
|
|
G_CALLBACK (gimp_container_grid_view_item_activated),
|
|
view);
|
|
g_signal_connect (preview, "context",
|
|
G_CALLBACK (gimp_container_grid_view_item_context),
|
|
view);
|
|
|
|
return (gpointer) preview;
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_remove_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gpointer insert_data)
|
|
{
|
|
GimpContainerGridView *grid_view;
|
|
GtkWidget *preview;
|
|
|
|
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
|
preview = GTK_WIDGET (insert_data);
|
|
|
|
if (preview)
|
|
{
|
|
if (preview == (GtkWidget *) grid_view->selected_item)
|
|
grid_view->selected_item = NULL;
|
|
|
|
gtk_container_remove (GTK_CONTAINER (grid_view->wrap_box), preview);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_reorder_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gint new_index,
|
|
gpointer insert_data)
|
|
{
|
|
GimpContainerGridView *grid_view;
|
|
GtkWidget *preview;
|
|
|
|
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
|
preview = GTK_WIDGET (insert_data);
|
|
|
|
gtk_wrap_box_reorder_child (GTK_WRAP_BOX (grid_view->wrap_box),
|
|
preview, new_index);
|
|
}
|
|
|
|
static gboolean
|
|
gimp_container_grid_view_select_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gpointer insert_data)
|
|
{
|
|
gimp_container_grid_view_highlight_item (view, viewable, insert_data);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_clear_items (GimpContainerView *view)
|
|
{
|
|
GimpContainerGridView *grid_view;
|
|
|
|
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
|
|
|
grid_view->selected_item = NULL;
|
|
|
|
while (GTK_WRAP_BOX (grid_view->wrap_box)->children)
|
|
gtk_container_remove (GTK_CONTAINER (grid_view->wrap_box),
|
|
GTK_WRAP_BOX (grid_view->wrap_box)->children->widget);
|
|
|
|
GIMP_CONTAINER_VIEW_CLASS (parent_class)->clear_items (view);
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_set_preview_size (GimpContainerView *view)
|
|
{
|
|
GimpContainerGridView *grid_view;
|
|
GtkWrapBoxChild *child;
|
|
|
|
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
|
|
|
for (child = GTK_WRAP_BOX (grid_view->wrap_box)->children;
|
|
child;
|
|
child = child->next)
|
|
{
|
|
GimpPreview *preview = GIMP_PREVIEW (child->widget);
|
|
|
|
gimp_preview_renderer_set_size (preview->renderer,
|
|
view->preview_size,
|
|
preview->renderer->border_width);
|
|
}
|
|
|
|
gtk_widget_queue_resize (grid_view->wrap_box);
|
|
}
|
|
|
|
static gboolean
|
|
gimp_container_grid_view_item_selected (GtkWidget *widget,
|
|
GdkEventButton *bevent,
|
|
gpointer data)
|
|
{
|
|
if (bevent->type == GDK_BUTTON_PRESS && bevent->button == 1)
|
|
{
|
|
if (GTK_WIDGET_CAN_FOCUS (data) && !GTK_WIDGET_HAS_FOCUS (data))
|
|
gtk_widget_grab_focus (GTK_WIDGET (data));
|
|
|
|
gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (data),
|
|
GIMP_PREVIEW (widget)->viewable);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_item_activated (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
gimp_container_view_item_activated (GIMP_CONTAINER_VIEW (data),
|
|
GIMP_PREVIEW (widget)->viewable);
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_item_context (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
if (gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (data),
|
|
GIMP_PREVIEW (widget)->viewable))
|
|
{
|
|
gimp_container_view_item_context (GIMP_CONTAINER_VIEW (data),
|
|
GIMP_PREVIEW (widget)->viewable);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_highlight_item (GimpContainerView *view,
|
|
GimpViewable *viewable,
|
|
gpointer insert_data)
|
|
{
|
|
GimpContainerGridView *grid_view;
|
|
GimpPreview *preview = NULL;
|
|
|
|
grid_view = GIMP_CONTAINER_GRID_VIEW (view);
|
|
|
|
if (insert_data)
|
|
preview = GIMP_PREVIEW (insert_data);
|
|
|
|
if (grid_view->selected_item && grid_view->selected_item != preview)
|
|
{
|
|
gimp_preview_renderer_set_border_color (grid_view->selected_item->renderer,
|
|
&white_color);
|
|
gimp_preview_renderer_update (grid_view->selected_item->renderer);
|
|
}
|
|
|
|
if (preview)
|
|
{
|
|
GtkRequisition preview_requisition;
|
|
GtkAdjustment *adj;
|
|
gint item_height;
|
|
gint index;
|
|
gint row;
|
|
gchar *name;
|
|
|
|
adj = gtk_scrolled_window_get_vadjustment
|
|
(GTK_SCROLLED_WINDOW (view->scrolled_win));
|
|
|
|
gtk_widget_size_request (GTK_WIDGET (preview), &preview_requisition);
|
|
|
|
item_height = preview_requisition.height;
|
|
|
|
index = gimp_container_get_child_index (view->container,
|
|
GIMP_OBJECT (viewable));
|
|
|
|
row = index / grid_view->columns;
|
|
|
|
if (row * item_height < adj->value)
|
|
{
|
|
gtk_adjustment_set_value (adj, row * item_height);
|
|
}
|
|
else if ((row + 1) * item_height > adj->value + adj->page_size)
|
|
{
|
|
gtk_adjustment_set_value (adj,
|
|
(row + 1) * item_height - adj->page_size);
|
|
}
|
|
|
|
gimp_preview_renderer_set_border_color (preview->renderer, &black_color);
|
|
gimp_preview_renderer_update (preview->renderer);
|
|
|
|
name = gimp_viewable_get_description (preview->renderer->viewable, NULL);
|
|
gtk_label_set_text (GTK_LABEL (grid_view->name_label), name);
|
|
g_free (name);
|
|
}
|
|
else
|
|
{
|
|
gtk_label_set_text (GTK_LABEL (grid_view->name_label), _("(None)"));
|
|
}
|
|
|
|
grid_view->selected_item = preview;
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_vieport_resized (GtkWidget *widget,
|
|
GtkAllocation *allocation,
|
|
GimpContainerGridView *grid_view)
|
|
{
|
|
GimpContainerView *view;
|
|
|
|
view = GIMP_CONTAINER_VIEW (grid_view);
|
|
|
|
if (view->container)
|
|
{
|
|
GList *children;
|
|
gint n_children;
|
|
|
|
children = gtk_container_get_children (GTK_CONTAINER (grid_view->wrap_box));
|
|
n_children = g_list_length (children);
|
|
|
|
if (children)
|
|
{
|
|
GtkRequisition preview_requisition;
|
|
gint columns;
|
|
gint rows;
|
|
|
|
gtk_widget_size_request (GTK_WIDGET (children->data),
|
|
&preview_requisition);
|
|
|
|
g_list_free (children);
|
|
|
|
columns = MAX (1, allocation->width / preview_requisition.width);
|
|
|
|
rows = n_children / columns;
|
|
|
|
if (n_children % columns)
|
|
rows++;
|
|
|
|
if ((rows != grid_view->rows) || (columns != grid_view->columns))
|
|
{
|
|
grid_view->rows = rows;
|
|
grid_view->columns = columns;
|
|
|
|
gtk_widget_set_size_request (grid_view->wrap_box,
|
|
columns * preview_requisition.width,
|
|
rows * preview_requisition.height);
|
|
|
|
}
|
|
|
|
grid_view->visible_rows = (allocation->height /
|
|
preview_requisition.height);
|
|
}
|
|
|
|
if (grid_view->selected_item)
|
|
{
|
|
GimpPreview *preview;
|
|
|
|
preview = grid_view->selected_item;
|
|
|
|
gimp_container_grid_view_highlight_item (view,
|
|
preview->viewable,
|
|
preview);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_container_grid_view_vieport_realize (GtkWidget *widget,
|
|
GimpContainerGridView *grid_view)
|
|
{
|
|
GimpContainerView *view;
|
|
|
|
view = GIMP_CONTAINER_VIEW (grid_view);
|
|
|
|
if (view->container && grid_view->selected_item)
|
|
{
|
|
GimpPreview *preview;
|
|
|
|
preview = grid_view->selected_item;
|
|
|
|
gimp_container_grid_view_highlight_item (view,
|
|
preview->viewable,
|
|
preview);
|
|
}
|
|
}
|