static gboolean gimp_container_grid_view_move_by (GimpContainerGridView *grid_view, gint x, gint y) { GimpContainerView *view = GIMP_CONTAINER_VIEW (grid_view); GimpContainer *container; GimpViewable *item; gint index; if (! grid_view->selected_item) return FALSE; container = gimp_container_view_get_container (view); item = grid_view->selected_item->viewable; index = gimp_container_get_child_index (container, GIMP_OBJECT (item)); index += x; index = CLAMP (index, 0, gimp_container_get_n_children (container) - 1); index += y * grid_view->columns; while (index < 0) index += grid_view->columns; while (index >= gimp_container_get_n_children (container)) index -= grid_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 GObject * gimp_vectors_tree_view_constructor (GType type, guint n_params, GObjectConstructParam *params) { GObject *object; GimpEditor *editor; GimpContainerTreeView *tree_view; GimpVectorsTreeView *view; object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params); editor = GIMP_EDITOR (object); tree_view = GIMP_CONTAINER_TREE_VIEW (object); view = GIMP_VECTORS_TREE_VIEW (object); /* hide basically useless edit button */ gtk_widget_hide (GIMP_ITEM_TREE_VIEW (view)->edit_button); view->toselection_button = gimp_editor_add_action_button (editor, "vectors", "vectors-selection-replace", "vectors-selection-add", GDK_SHIFT_MASK, "vectors-selection-subtract", GDK_CONTROL_MASK, "vectors-selection-intersect", GDK_SHIFT_MASK | GDK_CONTROL_MASK, NULL); gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor), GTK_BUTTON (view->toselection_button), GIMP_TYPE_VECTORS); gtk_box_reorder_child (GTK_BOX (editor->button_box), view->toselection_button, 5); view->tovectors_button = gimp_editor_add_action_button (editor, "vectors", "vectors-selection-to-vectors", "vectors-selection-to-vectors-advanced", GDK_SHIFT_MASK, NULL); gtk_box_reorder_child (GTK_BOX (editor->button_box), view->tovectors_button, 6); view->stroke_button = gimp_editor_add_action_button (editor, "vectors", "vectors-stroke", "vectors-stroke-last-values", GDK_SHIFT_MASK, NULL); gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor), GTK_BUTTON (view->stroke_button), GIMP_TYPE_VECTORS); gtk_box_reorder_child (GTK_BOX (editor->button_box), view->stroke_button, 7); gimp_dnd_svg_dest_add (GTK_WIDGET (tree_view->view), NULL, view); return object; }
static void gimp_vectors_tree_view_constructed (GObject *object) { GimpEditor *editor = GIMP_EDITOR (object); GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (object); GimpVectorsTreeView *view = GIMP_VECTORS_TREE_VIEW (object); GdkModifierType extend_mask; GdkModifierType modify_mask; G_OBJECT_CLASS (parent_class)->constructed (object); extend_mask = gtk_widget_get_modifier_mask (GTK_WIDGET (object), GDK_MODIFIER_INTENT_EXTEND_SELECTION); modify_mask = gtk_widget_get_modifier_mask (GTK_WIDGET (object), GDK_MODIFIER_INTENT_MODIFY_SELECTION); /* hide basically useless edit button */ gtk_widget_hide (gimp_item_tree_view_get_edit_button (GIMP_ITEM_TREE_VIEW (view))); view->toselection_button = gimp_editor_add_action_button (editor, "vectors", "vectors-selection-replace", "vectors-selection-add", extend_mask, "vectors-selection-subtract", modify_mask, "vectors-selection-intersect", extend_mask | modify_mask, NULL); gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor), GTK_BUTTON (view->toselection_button), GIMP_TYPE_VECTORS); gtk_box_reorder_child (gimp_editor_get_button_box (editor), view->toselection_button, 5); view->tovectors_button = gimp_editor_add_action_button (editor, "vectors", "vectors-selection-to-vectors", "vectors-selection-to-vectors-advanced", GDK_SHIFT_MASK, NULL); gtk_box_reorder_child (gimp_editor_get_button_box (editor), view->tovectors_button, 6); view->stroke_button = gimp_editor_add_action_button (editor, "vectors", "vectors-stroke", "vectors-stroke-last-values", GDK_SHIFT_MASK, NULL); gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor), GTK_BUTTON (view->stroke_button), GIMP_TYPE_VECTORS); gtk_box_reorder_child (gimp_editor_get_button_box (editor), view->stroke_button, 7); gimp_dnd_svg_dest_add (GTK_WIDGET (tree_view->view), NULL, view); }
static void gimp_controller_list_constructed (GObject *object) { GimpControllerList *list = GIMP_CONTROLLER_LIST (object); G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_GIMP (list->gimp)); gimp_container_view_set_container (GIMP_CONTAINER_VIEW (list->dest), gimp_controllers_get_list (list->gimp)); gimp_container_view_set_context (GIMP_CONTAINER_VIEW (list->dest), gimp_get_user_context (list->gimp)); }
GtkWidget * gimp_container_grid_view_new (GimpContainer *container, GimpContext *context, gint view_size, gint view_border_width) { GimpContainerGridView *grid_view; GimpContainerView *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 (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); grid_view = g_object_new (GIMP_TYPE_CONTAINER_GRID_VIEW, NULL); view = GIMP_CONTAINER_VIEW (grid_view); gimp_container_view_set_view_size (view, view_size, view_border_width); if (container) gimp_container_view_set_container (view, container); if (context) gimp_container_view_set_context (view, context); return GTK_WIDGET (grid_view); }
GtkWidget * gimp_container_entry_new (GimpContainer *container, GimpContext *context, gint view_size, gint view_border_width) { GtkWidget *entry; GimpContainerView *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); entry = g_object_new (GIMP_TYPE_CONTAINER_ENTRY, NULL); view = GIMP_CONTAINER_VIEW (entry); gimp_container_view_set_view_size (view, view_size, view_border_width); if (container) gimp_container_view_set_container (view, container); if (context) gimp_container_view_set_context (view, context); return entry; }
void gimp_container_editor_set_selection_mode (GimpContainerEditor *editor, GtkSelectionMode mode) { gimp_container_view_set_selection_mode (GIMP_CONTAINER_VIEW (editor->view), mode); }
void gimp_container_tree_view_real_drop_viewable (GimpContainerTreeView *tree_view, GimpViewable *src_viewable, GimpViewable *dest_viewable, GtkTreeViewDropPosition drop_pos) { GimpContainerView *view = GIMP_CONTAINER_VIEW (tree_view); GimpContainer *container = gimp_container_view_get_container (view); gint src_index; gint dest_index; src_index = gimp_container_get_child_index (container, GIMP_OBJECT (src_viewable)); dest_index = gimp_container_get_child_index (container, GIMP_OBJECT (dest_viewable)); if (drop_pos == GTK_TREE_VIEW_DROP_AFTER && src_index > dest_index) { dest_index++; } else if (drop_pos == GTK_TREE_VIEW_DROP_BEFORE && src_index < dest_index) { dest_index--; } gimp_container_reorder (container, GIMP_OBJECT (src_viewable), dest_index); }
GtkWidget * gimp_container_combo_box_new (GimpContainer *container, GimpContext *context, gint view_size, gint view_border_width) { GtkWidget *combo_box; GimpContainerView *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); combo_box = g_object_new (GIMP_TYPE_CONTAINER_COMBO_BOX, NULL); view = GIMP_CONTAINER_VIEW (combo_box); gimp_container_view_set_view_size (view, view_size, view_border_width); if (container) gimp_container_view_set_container (view, container); if (context) gimp_container_view_set_context (view, context); return combo_box; }
static void gimp_container_grid_view_item_activated (GtkWidget *widget, gpointer data) { gimp_container_view_item_activated (GIMP_CONTAINER_VIEW (data), GIMP_VIEW (widget)->viewable); }
static void gimp_container_grid_view_viewport_resized (GtkWidget *widget, GtkAllocation *allocation, GimpContainerGridView *grid_view) { GimpContainerView *container_view = GIMP_CONTAINER_VIEW (grid_view); if (gimp_container_view_get_container (container_view)) { 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 view_requisition; gint columns; gint rows; gtk_widget_size_request (GTK_WIDGET (children->data), &view_requisition); g_list_free (children); columns = MAX (1, allocation->width / view_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 * view_requisition.width, rows * view_requisition.height); } grid_view->visible_rows = (allocation->height / view_requisition.height); } if (grid_view->selected_item) { GimpView *view = grid_view->selected_item; gimp_container_grid_view_highlight_item (container_view, view->viewable, view); } } }
static void gimp_container_popup_create_view (GimpContainerPopup *popup) { GimpEditor *editor; GtkWidget *button; popup->editor = g_object_new (GIMP_TYPE_CONTAINER_EDITOR, NULL); gimp_container_editor_construct (popup->editor, popup->view_type, popup->container, popup->context, popup->view_size, popup->view_border_width, NULL, NULL, NULL); gimp_container_view_set_reorderable (GIMP_CONTAINER_VIEW (popup->editor->view), FALSE); gimp_container_box_set_size_request (GIMP_CONTAINER_BOX (popup->editor->view), 6 * (popup->default_view_size + 2 * popup->view_border_width), 10 * (popup->default_view_size + 2 * popup->view_border_width)); if (GIMP_IS_EDITOR (popup->editor->view)) gimp_editor_set_show_name (GIMP_EDITOR (popup->editor->view), FALSE); gtk_container_add (GTK_CONTAINER (popup->frame), GTK_WIDGET (popup->editor)); gtk_widget_show (GTK_WIDGET (popup->editor)); editor = GIMP_EDITOR (popup->editor->view); gimp_editor_add_button (editor, GTK_STOCK_ZOOM_OUT, _("Smaller Previews"), NULL, G_CALLBACK (gimp_container_popup_smaller_clicked), NULL, popup); gimp_editor_add_button (editor, GTK_STOCK_ZOOM_IN, _("Larger Previews"), NULL, G_CALLBACK (gimp_container_popup_larger_clicked), NULL, popup); button = gimp_editor_add_stock_box (editor, GIMP_TYPE_VIEW_TYPE, "gimp", G_CALLBACK (gimp_container_popup_view_type_toggled), popup); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), popup->view_type); if (popup->dialog_factory) gimp_editor_add_button (editor, popup->dialog_stock_id, popup->dialog_tooltip, NULL, G_CALLBACK (gimp_container_popup_dialog_clicked), NULL, popup); gtk_widget_grab_focus (GTK_WIDGET (popup->editor)); }
static void gimp_container_grid_view_item_context (GtkWidget *widget, gpointer data) { /* ref the view because calling gimp_container_view_item_selected() * may destroy the widget */ g_object_ref (data); if (gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (data), GIMP_VIEW (widget)->viewable)) { gimp_container_view_item_context (GIMP_CONTAINER_VIEW (data), GIMP_VIEW (widget)->viewable); } g_object_unref (data); }
static void gimp_drawable_tree_view_floating_selection_changed (GimpImage *image, GimpDrawableTreeView *view) { GimpItem *item; item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image); /* update button states */ gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view), (GimpViewable *) item); }
static void gimp_container_entry_init (GimpContainerEntry *entry) { GtkEntryCompletion *completion; GtkTreeModel *model; GtkCellRenderer *cell; GType types[GIMP_CONTAINER_TREE_STORE_N_COLUMNS]; gint n_types = 0; completion = g_object_new (GTK_TYPE_ENTRY_COMPLETION, "inline-completion", TRUE, "popup-single-match", FALSE, "popup-set-width", FALSE, NULL); gimp_container_tree_store_columns_init (types, &n_types); model = gimp_container_tree_store_new (GIMP_CONTAINER_VIEW (entry), n_types, types); gimp_container_tree_store_set_use_name (GIMP_CONTAINER_TREE_STORE (model), TRUE); gtk_entry_completion_set_model (completion, model); g_object_unref (model); gtk_entry_set_completion (GTK_ENTRY (entry), completion); g_signal_connect (completion, "match-selected", G_CALLBACK (gimp_container_entry_match_selected), entry); g_object_unref (completion); /* FIXME: This can be done better with GTK+ 2.6. */ cell = gimp_cell_renderer_viewable_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (completion), cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (completion), cell, "renderer", GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, NULL); gimp_container_tree_store_add_renderer_cell (GIMP_CONTAINER_TREE_STORE (model), cell); gtk_entry_completion_set_text_column (completion, GIMP_CONTAINER_TREE_STORE_COLUMN_NAME); g_signal_connect (entry, "changed", G_CALLBACK (gimp_container_entry_changed), entry); }
static void gimp_container_box_init (GimpContainerBox *box) { GimpContainerView *view = GIMP_CONTAINER_VIEW (box); box->scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (box), box->scrolled_win, TRUE, TRUE, 0); gtk_widget_show (box->scrolled_win); GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (box->scrolled_win)->vscrollbar, GTK_CAN_FOCUS); gimp_container_view_set_dnd_widget (view, box->scrolled_win); }
static void gimp_controller_list_add_clicked (GtkWidget *button, GimpControllerList *list) { GimpControllerInfo *info; GimpContainer *container; if (list->src_gtype == GIMP_TYPE_CONTROLLER_KEYBOARD && gimp_controllers_get_keyboard (list->gimp) != NULL) { gimp_message_literal (list->gimp, G_OBJECT (button), GIMP_MESSAGE_WARNING, _("There can only be one active keyboard " "controller.\n\n" "You already have a keyboard controller in " "your list of active controllers.")); return; } else if (list->src_gtype == GIMP_TYPE_CONTROLLER_WHEEL && gimp_controllers_get_wheel (list->gimp) != NULL) { gimp_message_literal (list->gimp, G_OBJECT (button), GIMP_MESSAGE_WARNING, _("There can only be one active wheel " "controller.\n\n" "You already have a wheel controller in " "your list of active controllers.")); return; } else if (list->src_gtype == GIMP_TYPE_CONTROLLER_MOUSE && gimp_controllers_get_mouse (list->gimp) != NULL) { gimp_message_literal (list->gimp, G_OBJECT (button), GIMP_MESSAGE_WARNING, _("There can only be one active mouse " "controller.\n\n" "You already have a mouse controller in " "your list of active controllers.")); return; } info = gimp_controller_info_new (list->src_gtype); container = gimp_controllers_get_list (list->gimp); gimp_container_add (container, GIMP_OBJECT (info)); g_object_unref (info); gimp_container_view_select_item (GIMP_CONTAINER_VIEW (list->dest), GIMP_VIEWABLE (info)); gimp_controller_list_edit_clicked (NULL, list); }
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_get_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_VIEW (widget)->viewable); } return FALSE; }
static void gimp_container_combo_box_init (GimpContainerComboBox *combo) { GtkTreeModel *model; GtkCellLayout *layout; GtkCellRenderer *cell; GType types[GIMP_CONTAINER_TREE_STORE_N_COLUMNS]; gint n_types = 0; gimp_container_tree_store_columns_init (types, &n_types); model = gimp_container_tree_store_new (GIMP_CONTAINER_VIEW (combo), n_types, types); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), model); g_object_unref (model); layout = GTK_CELL_LAYOUT (combo); cell = gimp_cell_renderer_viewable_new (); gtk_cell_layout_pack_start (layout, cell, FALSE); gtk_cell_layout_set_attributes (layout, cell, "renderer", GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, NULL); gimp_container_tree_store_add_renderer_cell (GIMP_CONTAINER_TREE_STORE (model), cell); combo->viewable_renderer = cell; cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (layout, cell, TRUE); gtk_cell_layout_set_attributes (layout, cell, "text", GIMP_CONTAINER_TREE_STORE_COLUMN_NAME, NULL); combo->text_renderer = cell; g_signal_connect (combo, "changed", G_CALLBACK (gimp_container_combo_box_changed), combo); gtk_widget_set_sensitive (GTK_WIDGET (combo), FALSE); }
static void gimp_tool_view_destroy (GtkObject *object) { GimpToolView *tool_view = GIMP_TOOL_VIEW (object); if (tool_view->visible_handler_id) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (tool_view); GimpContainerView *view = GIMP_CONTAINER_VIEW (editor->view); gimp_container_remove_handler (gimp_container_view_get_container (view), tool_view->visible_handler_id); tool_view->visible_handler_id = 0; } GTK_OBJECT_CLASS (parent_class)->destroy (object); }
GtkWidget * gimp_font_view_new (GimpViewType view_type, GimpContainer *container, GimpContext *context, gint view_size, gint view_border_width, GimpMenuFactory *menu_factory) { GimpFontView *font_view; GimpContainerEditor *editor; g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); 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); g_return_val_if_fail (menu_factory == NULL || GIMP_IS_MENU_FACTORY (menu_factory), NULL); font_view = g_object_new (GIMP_TYPE_FONT_VIEW, "view-type", view_type, "container", container, "context", context, "view-size", view_size, "view-border-width", view_border_width, "menu-factory", menu_factory, "menu-identifier", "<Fonts>", "ui-path", "/fonts-popup", NULL); editor = GIMP_CONTAINER_EDITOR (font_view); gimp_container_view_set_reorderable (GIMP_CONTAINER_VIEW (editor->view), FALSE); font_view->refresh_button = gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "fonts", "fonts-refresh", NULL); gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor->view)), editor); return GTK_WIDGET (font_view); }
void gimp_container_box_set_size_request (GimpContainerBox *box, gint width, gint height) { GimpContainerView *view; GtkScrolledWindowClass *sw_class; GtkRequisition req; gint view_size; gint scrollbar_width; gint border_x; gint border_y; g_return_if_fail (GIMP_IS_CONTAINER_BOX (box)); view = GIMP_CONTAINER_VIEW (box); view_size = gimp_container_view_get_view_size (view, NULL); g_return_if_fail (width <= 0 || width >= view_size); g_return_if_fail (height <= 0 || height >= view_size); sw_class = GTK_SCROLLED_WINDOW_GET_CLASS (box->scrolled_win); if (sw_class->scrollbar_spacing >= 0) scrollbar_width = sw_class->scrollbar_spacing; else gtk_widget_style_get (GTK_WIDGET (box->scrolled_win), "scrollbar-spacing", &scrollbar_width, NULL); gtk_widget_size_request (GTK_SCROLLED_WINDOW (box->scrolled_win)->vscrollbar, &req); scrollbar_width += req.width; border_x = GTK_CONTAINER (box)->border_width; border_y = GTK_CONTAINER (box)->border_width; border_x += box->scrolled_win->style->xthickness * 2 + scrollbar_width; border_y += box->scrolled_win->style->ythickness * 2; gtk_widget_set_size_request (box->scrolled_win, width > 0 ? width + border_x : -1, height > 0 ? height + border_y : -1); }
static void gimp_tool_view_visible_notify (GimpToolInfo *tool_info, GParamSpec *pspec, GimpContainerTreeView *tree_view) { GtkTreeIter *iter; iter = gimp_container_view_lookup (GIMP_CONTAINER_VIEW (tree_view), (GimpViewable *) tool_info); if (iter) { GtkTreePath *path; path = gtk_tree_model_get_path (tree_view->model, iter); gtk_tree_model_row_changed (tree_view->model, path, iter); gtk_tree_path_free (path); } }
static void gimp_vectors_tree_view_set_container (GimpContainerView *view, GimpContainer *container) { GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view); GimpContainer *old_container; old_container = gimp_container_view_get_container (GIMP_CONTAINER_VIEW (view)); if (old_container && ! container) { gimp_dnd_svg_source_remove (GTK_WIDGET (tree_view->view)); } parent_view_iface->set_container (view, container); if (! old_container && container) { gimp_dnd_svg_source_add (GTK_WIDGET (tree_view->view), gimp_vectors_tree_view_drag_svg, tree_view); } }
static void gimp_container_combo_box_set (GimpContainerComboBox *combo_box, GtkTreeIter *iter, GimpViewable *viewable) { GimpContainerView *view = GIMP_CONTAINER_VIEW (combo_box); GtkTreeModel *model; GimpViewRenderer *renderer; gchar *name; gint view_size; gint border_width; model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)); view_size = gimp_container_view_get_view_size (view, &border_width); name = gimp_viewable_get_description (viewable, NULL); renderer = gimp_view_renderer_new (gimp_container_view_get_context (view), G_TYPE_FROM_INSTANCE (viewable), view_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), view); gtk_list_store_set (GTK_LIST_STORE (model), iter, COLUMN_RENDERER, renderer, COLUMN_NAME, name, -1); g_object_unref (renderer); g_free (name); }
static gboolean gimp_container_grid_view_move_cursor (GimpContainerGridView *grid_view, GtkMovementStep step, gint count) { GimpContainerView *view = GIMP_CONTAINER_VIEW (grid_view); GimpContainer *container; GimpViewable *item; if (! gtk_widget_has_focus (GTK_WIDGET (grid_view)) || count == 0) return FALSE; container = gimp_container_view_get_container (view); switch (step) { case GTK_MOVEMENT_PAGES: return gimp_container_grid_view_move_by (grid_view, 0, count * grid_view->visible_rows); case GTK_MOVEMENT_BUFFER_ENDS: count = count < 0 ? 0 : gimp_container_get_n_children (container) - 1; item = (GimpViewable *) gimp_container_get_child_by_index (container, count); if (item) gimp_container_view_item_selected (view, item); return TRUE; default: break; } return FALSE; }
static GtkWidget * gimp_container_box_get_preview (GimpDocked *docked, GimpContext *context, GtkIconSize size) { GimpContainerBox *box = GIMP_CONTAINER_BOX (docked); GimpContainerView *view = GIMP_CONTAINER_VIEW (docked); GimpContainer *container; GtkWidget *preview; gint width; gint height; gint border_width = 1; const gchar *prop_name; container = gimp_container_view_get_container (view); g_return_val_if_fail (container != NULL, NULL); gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (box)), size, &width, &height); prop_name = gimp_context_type_to_prop_name (container->children_type); preview = gimp_prop_view_new (G_OBJECT (context), prop_name, context, height); GIMP_VIEW (preview)->renderer->size = -1; gimp_container_view_get_view_size (view, &border_width); border_width = MIN (1, border_width); gimp_view_renderer_set_size_full (GIMP_VIEW (preview)->renderer, width, height, border_width); return preview; }
static GtkWidget * quit_close_all_dialog_new (Gimp *gimp, gboolean do_quit) { GimpContainer *images; GimpContext *context; GimpMessageBox *box; GtkWidget *dialog; GtkWidget *label; GtkWidget *button; GtkWidget *view; GtkWidget *dnd_widget; gint rows; gint view_size; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); #ifdef __GNUC__ #warning FIXME: need container of dirty images #endif images = gimp_displays_get_dirty_images (gimp); context = gimp_context_new (gimp, "close-all-dialog", gimp_get_user_context (gimp)); g_return_val_if_fail (images != NULL, NULL); dialog = gimp_message_dialog_new (do_quit ? _("Quit GIMP") : _("Close All Images"), GIMP_STOCK_WARNING, NULL, 0, gimp_standard_help_func, do_quit ? GIMP_HELP_FILE_QUIT : GIMP_HELP_FILE_CLOSE_ALL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); g_object_set_data_full (G_OBJECT (dialog), "dirty-images", images, (GDestroyNotify) g_object_unref); g_object_set_data_full (G_OBJECT (dialog), "dirty-images-context", context, (GDestroyNotify) g_object_unref); g_signal_connect (dialog, "response", G_CALLBACK (quit_close_all_dialog_response), gimp); box = GIMP_MESSAGE_DIALOG (dialog)->box; button = gtk_dialog_add_button (GTK_DIALOG (dialog), "", GTK_RESPONSE_OK); g_object_set_data (G_OBJECT (box), "ok-button", button); g_object_set_data (G_OBJECT (box), "do-quit", GINT_TO_POINTER (do_quit)); g_signal_connect_object (images, "add", G_CALLBACK (quit_close_all_dialog_container_changed), box, 0); g_signal_connect_object (images, "remove", G_CALLBACK (quit_close_all_dialog_container_changed), box, 0); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); view_size = gimp->config->layer_preview_size; rows = CLAMP (gimp_container_num_children (images), 3, 6); view = gimp_container_tree_view_new (images, context, view_size, 1); gimp_container_box_set_size_request (GIMP_CONTAINER_BOX (view), -1, rows * (view_size + 2)); gtk_box_pack_start (GTK_BOX (box), view, TRUE, TRUE, 0); gtk_widget_show (view); g_signal_connect (view, "activate-item", G_CALLBACK (quit_close_all_dialog_image_activated), gimp); dnd_widget = gimp_container_view_get_dnd_widget (GIMP_CONTAINER_VIEW (view)); gimp_dnd_xds_source_add (dnd_widget, (GimpDndDragViewableFunc) gimp_dnd_get_drag_data, NULL); if (do_quit) label = gtk_label_new (_("If you quit GIMP now, " "these changes will be lost.")); else label = gtk_label_new (_("If you close these images now, " "changes will be lost.")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); g_object_set_data (G_OBJECT (box), "lost-label", label); quit_close_all_dialog_container_changed (images, NULL, GIMP_MESSAGE_DIALOG (dialog)->box); return dialog; }
static void gimp_text_style_editor_constructed (GObject *object) { GimpTextStyleEditor *editor = GIMP_TEXT_STYLE_EDITOR (object); if (G_OBJECT_CLASS (parent_class)->constructed) G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_GIMP (editor->gimp)); g_assert (GIMP_IS_FONT_LIST (editor->fonts)); g_assert (GIMP_IS_TEXT (editor->text)); g_assert (GIMP_IS_TEXT_BUFFER (editor->buffer)); editor->context = gimp_context_new (editor->gimp, "text style editor", NULL); g_signal_connect (editor->context, "font-changed", G_CALLBACK (gimp_text_style_editor_font_changed), editor); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (editor->size_entry), 0, editor->resolution_y, TRUE); /* use the global user context so we get the global FG/BG colors */ gimp_color_panel_set_context (GIMP_COLOR_PANEL (editor->color_button), gimp_get_user_context (editor->gimp)); gimp_container_view_set_container (GIMP_CONTAINER_VIEW (editor->font_entry), editor->fonts); gimp_container_view_set_context (GIMP_CONTAINER_VIEW (editor->font_entry), editor->context); gimp_text_style_editor_create_toggle (editor, editor->buffer->bold_tag, GTK_STOCK_BOLD, _("Bold")); gimp_text_style_editor_create_toggle (editor, editor->buffer->italic_tag, GTK_STOCK_ITALIC, _("Italic")); gimp_text_style_editor_create_toggle (editor, editor->buffer->underline_tag, GTK_STOCK_UNDERLINE, _("Underline")); gimp_text_style_editor_create_toggle (editor, editor->buffer->strikethrough_tag, GTK_STOCK_STRIKETHROUGH, _("Strikethrough")); g_signal_connect_swapped (editor->text, "notify::font", G_CALLBACK (gimp_text_style_editor_update), editor); g_signal_connect_swapped (editor->text, "notify::font-size", G_CALLBACK (gimp_text_style_editor_update), editor); g_signal_connect_swapped (editor->text, "notify::font-size-unit", G_CALLBACK (gimp_text_style_editor_update), editor); g_signal_connect_swapped (editor->text, "notify::color", G_CALLBACK (gimp_text_style_editor_update), editor); g_signal_connect_data (editor->buffer, "changed", G_CALLBACK (gimp_text_style_editor_update), editor, 0, G_CONNECT_AFTER | G_CONNECT_SWAPPED); g_signal_connect_data (editor->buffer, "apply-tag", G_CALLBACK (gimp_text_style_editor_update), editor, 0, G_CONNECT_AFTER | G_CONNECT_SWAPPED); g_signal_connect_data (editor->buffer, "remove-tag", G_CALLBACK (gimp_text_style_editor_update), editor, 0, G_CONNECT_AFTER | G_CONNECT_SWAPPED); g_signal_connect_data (editor->buffer, "mark-set", G_CALLBACK (gimp_text_style_editor_update), editor, 0, G_CONNECT_AFTER | G_CONNECT_SWAPPED); }
static void gimp_container_box_set_context (GimpDocked *docked, GimpContext *context) { gimp_container_view_set_context (GIMP_CONTAINER_VIEW (docked), context); }