void
view_dot_for_dot_cmd_callback (GtkAction *action,
gpointer data)
{
GimpDisplay *display;
GimpDisplayShell *shell;
gboolean active;
return_if_no_display (display, data);
shell = gimp_display_get_shell (display);
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (active != shell->dot_for_dot)
{
GimpImageWindow *window = gimp_display_shell_get_window (shell);
gimp_display_shell_scale_set_dot_for_dot (shell, active);
if (window)
SET_ACTIVE (gimp_image_window_get_ui_manager (window),
"view-dot-for-dot", shell->dot_for_dot);
if (IS_ACTIVE_DISPLAY (display))
SET_ACTIVE (shell->popup_manager, "view-dot-for-dot",
shell->dot_for_dot);
}
}
void
windows_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpGuiConfig *config = GIMP_GUI_CONFIG (group->gimp->config);
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
SET_ACTIVE ("windows-use-single-window-mode", config->single_window_mode);
SET_ACTIVE ("windows-hide-docks", config->hide_docks);
#undef SET_ACTIVE
}
void
dock_actions_update (GimpActionGroup *group,
gpointer data)
{
GtkWidget *widget = action_data_get_widget (data);
GtkWidget *toplevel = NULL;
if (widget)
toplevel = gtk_widget_get_toplevel (widget);
#define SET_ACTIVE(action,active) \
gimp_action_group_set_action_active (group, action, (active) != 0)
#define SET_VISIBLE(action,active) \
gimp_action_group_set_action_visible (group, action, (active) != 0)
if (GIMP_IS_DOCK_WINDOW (toplevel))
{
GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (toplevel);
gboolean show_image_menu = ! gimp_dock_window_has_toolbox (dock_window);
if (show_image_menu)
{
SET_VISIBLE ("dock-show-image-menu", TRUE);
SET_VISIBLE ("dock-auto-follow-active", TRUE);
SET_ACTIVE ("dock-show-image-menu", gimp_dock_window_get_show_image_menu (dock_window));
SET_ACTIVE ("dock-auto-follow-active", gimp_dock_window_get_auto_follow_active (dock_window));
}
else
{
SET_VISIBLE ("dock-show-image-menu", FALSE);
SET_VISIBLE ("dock-auto-follow-active", FALSE);
}
/* update the window actions only in the context of their
* own window (not in the context of some display or NULL)
* (see view-actions.c)
*/
window_actions_update (group, toplevel);
}
else if (GIMP_IS_IMAGE_WINDOW (toplevel))
{
SET_VISIBLE ("dock-show-image-menu", FALSE);
SET_VISIBLE ("dock-auto-follow-active", FALSE);
}
#undef SET_ACTIVE
#undef SET_VISIBLE
}
void
dynamics_editor_actions_update (GimpActionGroup *group,
gpointer user_data)
{
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (user_data);
GimpData *data;
gboolean editable = FALSE;
gboolean edit_active = FALSE;
data = data_editor->data;
if (data)
{
if (data_editor->data_editable)
editable = TRUE;
}
edit_active = gimp_data_editor_get_edit_active (data_editor);
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
SET_ACTIVE ("dynamics-editor-edit-active", edit_active);
#undef SET_SENSITIVE
#undef SET_ACTIVE
}
void
window_actions_update (GimpActionGroup *group,
GtkWidget *window)
{
const gchar *group_name;
gint show_menu = FALSE;
gchar *name;
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
#define SET_ACTIVE(action,active) \
gimp_action_group_set_action_active (group, action, (active) != 0)
#define SET_VISIBLE(action,active) \
gimp_action_group_set_action_visible (group, action, (active) != 0)
if (GTK_IS_WINDOW (window))
{
GdkDisplay *display;
GdkScreen *screen;
gchar *screen_name;
display = gtk_widget_get_display (window);
show_menu = (gdk_display_get_n_screens (display) > 1);
#ifdef GIMP_UNSTABLE
show_menu = TRUE;
#endif
if (! show_menu)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
GSList *displays;
displays = gdk_display_manager_list_displays (manager);
show_menu = (displays->next != NULL);
g_slist_free (displays);
}
screen = gtk_widget_get_screen (window);
screen_name = gdk_screen_make_display_name (screen);
name = g_strdup_printf ("%s-move-to-screen-%s", group_name, screen_name);
g_free (screen_name);
SET_ACTIVE (name, TRUE);
g_free (name);
}
name = g_strdup_printf ("%s-move-to-screen-menu", group_name);
SET_VISIBLE (name, show_menu);
g_free (name);
#undef SET_ACTIVE
#undef SET_VISIBLE
}
void
palette_editor_actions_update (GimpActionGroup *group,
gpointer user_data)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (user_data);
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (user_data);
GimpData *data;
gboolean editable = FALSE;
GimpRGB fg;
GimpRGB bg;
gboolean edit_active = FALSE;
data = data_editor->data;
if (data)
{
if (data_editor->data_editable)
editable = TRUE;
}
if (data_editor->context)
{
gimp_context_get_foreground (data_editor->context, &fg);
gimp_context_get_background (data_editor->context, &bg);
}
edit_active = gimp_data_editor_get_edit_active (data_editor);
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, color, FALSE);
SET_SENSITIVE ("palette-editor-edit-color", editable && editor->color);
SET_SENSITIVE ("palette-editor-delete-color", editable && editor->color);
SET_SENSITIVE ("palette-editor-new-color-fg", editable);
SET_SENSITIVE ("palette-editor-new-color-bg", editable);
SET_COLOR ("palette-editor-new-color-fg", data_editor->context ? &fg : NULL);
SET_COLOR ("palette-editor-new-color-bg", data_editor->context ? &bg : NULL);
SET_SENSITIVE ("palette-editor-zoom-out", data);
SET_SENSITIVE ("palette-editor-zoom-in", data);
SET_SENSITIVE ("palette-editor-zoom-all", data);
SET_ACTIVE ("palette-editor-edit-active", edit_active);
#undef SET_SENSITIVE
#undef SET_ACTIVE
#undef SET_COLOR
}
void
brush_editor_actions_update (GimpActionGroup *group,
gpointer user_data)
{
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (user_data);
gboolean edit_active = FALSE;
edit_active = gimp_data_editor_get_edit_active (data_editor);
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
SET_ACTIVE ("brush-editor-edit-active", edit_active);
#undef SET_SENSITIVE
#undef SET_ACTIVE
}
void
view_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpDisplay *display = action_data_get_display (data);
GimpImage *image = NULL;
GimpDisplayShell *shell = NULL;
GimpDisplayOptions *options = NULL;
gchar *label = NULL;
gboolean fullscreen = FALSE;
gboolean revert_enabled = FALSE; /* able to revert zoom? */
gboolean use_gegl = FALSE;
if (display)
{
GimpImageWindow *window;
image = gimp_display_get_image (display);
shell = gimp_display_get_shell (display);
window = gimp_display_shell_get_window (shell);
if (window)
fullscreen = gimp_image_window_get_fullscreen (window);
options = (image ?
(fullscreen ? shell->fullscreen_options : shell->options) :
shell->no_image_options);
revert_enabled = gimp_display_shell_scale_can_revert (shell);
if (image)
use_gegl = gimp_image_get_projection (image)->use_gegl;
}
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, color, FALSE)
SET_SENSITIVE ("view-new", image);
SET_SENSITIVE ("view-close", image);
SET_SENSITIVE ("view-dot-for-dot", image);
SET_ACTIVE ("view-dot-for-dot", display && shell->dot_for_dot);
SET_SENSITIVE ("view-zoom-revert", revert_enabled);
if (revert_enabled)
{
label = g_strdup_printf (_("Re_vert Zoom (%d%%)"),
ROUND (shell->last_scale * 100));
gimp_action_group_set_action_label (group, "view-zoom-revert", label);
g_free (label);
}
else
{
gimp_action_group_set_action_label (group, "view-zoom-revert",
_("Re_vert Zoom"));
}
SET_SENSITIVE ("view-zoom-out", image);
SET_SENSITIVE ("view-zoom-in", image);
SET_SENSITIVE ("view-zoom-fit-in", image);
SET_SENSITIVE ("view-zoom-fill", image);
SET_SENSITIVE ("view-zoom-16-1", image);
SET_SENSITIVE ("view-zoom-8-1", image);
SET_SENSITIVE ("view-zoom-4-1", image);
SET_SENSITIVE ("view-zoom-2-1", image);
SET_SENSITIVE ("view-zoom-1-1", image);
SET_SENSITIVE ("view-zoom-1-2", image);
SET_SENSITIVE ("view-zoom-1-4", image);
SET_SENSITIVE ("view-zoom-1-8", image);
SET_SENSITIVE ("view-zoom-1-16", image);
SET_SENSITIVE ("view-zoom-other", image);
if (image)
view_actions_set_zoom (group, shell);
SET_SENSITIVE ("view-navigation-window", image);
SET_SENSITIVE ("view-display-filters", image);
SET_SENSITIVE ("view-show-selection", image);
SET_ACTIVE ("view-show-selection", display && options->show_selection);
SET_SENSITIVE ("view-show-layer-boundary", image);
SET_ACTIVE ("view-show-layer-boundary", display && options->show_layer_boundary);
SET_SENSITIVE ("view-show-guides", image);
SET_ACTIVE ("view-show-guides", display && options->show_guides);
SET_SENSITIVE ("view-show-grid", image);
SET_ACTIVE ("view-show-grid", display && options->show_grid);
SET_SENSITIVE ("view-show-sample-points", image);
SET_ACTIVE ("view-show-sample-points", display && options->show_sample_points);
SET_SENSITIVE ("view-snap-to-guides", image);
SET_ACTIVE ("view-snap-to-guides", display && shell->snap_to_guides);
SET_SENSITIVE ("view-snap-to-grid", image);
SET_ACTIVE ("view-snap-to-grid", display && shell->snap_to_grid);
SET_SENSITIVE ("view-snap-to-canvas", image);
SET_ACTIVE ("view-snap-to-canvas", display && shell->snap_to_canvas);
SET_SENSITIVE ("view-snap-to-vectors", image);
SET_ACTIVE ("view-snap-to-vectors", display && shell->snap_to_vectors);
SET_SENSITIVE ("view-padding-color-theme", image);
SET_SENSITIVE ("view-padding-color-light-check", image);
SET_SENSITIVE ("view-padding-color-dark-check", image);
SET_SENSITIVE ("view-padding-color-custom", image);
SET_SENSITIVE ("view-padding-color-prefs", image);
if (display)
{
SET_COLOR ("view-padding-color-menu", &options->padding_color);
if (shell->canvas)
{
GtkStyle *style = gtk_widget_get_style (shell->canvas);
GimpRGB color;
gtk_widget_ensure_style (shell->canvas);
gimp_rgb_set_gdk_color (&color, style->bg + GTK_STATE_NORMAL);
gimp_rgb_set_alpha (&color, GIMP_OPACITY_OPAQUE);
SET_COLOR ("view-padding-color-theme", &color);
}
}
SET_SENSITIVE ("view-show-menubar", image);
SET_ACTIVE ("view-show-menubar", display && options->show_menubar);
SET_SENSITIVE ("view-show-rulers", image);
SET_ACTIVE ("view-show-rulers", display && options->show_rulers);
SET_SENSITIVE ("view-show-scrollbars", image);
SET_ACTIVE ("view-show-scrollbars", display && options->show_scrollbars);
SET_SENSITIVE ("view-show-statusbar", image);
SET_ACTIVE ("view-show-statusbar", display && options->show_statusbar);
SET_SENSITIVE ("view-shrink-wrap", image);
SET_SENSITIVE ("view-fullscreen", image);
SET_ACTIVE ("view-fullscreen", display && fullscreen);
SET_ACTIVE ("view-use-gegl", use_gegl);
if (GIMP_IS_IMAGE_WINDOW (group->user_data) ||
GIMP_IS_GIMP (group->user_data))
{
GtkWidget *window = NULL;
if (shell)
window = gtk_widget_get_toplevel (GTK_WIDGET (shell));
/* see view_actions_setup() */
if (GTK_IS_WINDOW (window))
window_actions_update (group, window);
}
#undef SET_ACTIVE
#undef SET_SENSITIVE
#undef SET_COLOR
}
template <typename captype, typename tcaptype, typename flowtype> flowtype IBFSGraph<captype, tcaptype, flowtype>::maxflow()
{
node *i, *j, *i_tmp, *prevSrc, *prevSink;
arc *a, *a_end, *a_tmp;
AugmentationInfo augInfo;
prepareGraph();
#ifdef STATS
numAugs = 0;
numOrphans = 0;
grownSinkTree = 0;
grownSourceTree = 0;
numPushes = 0;
orphanArcs1 = 0;
orphanArcs2 = 0;
orphanArcs3 = 0;
growthArcs = 0;
skippedGrowth = 0;
numOrphans0 = 0;
numOrphans1 = 0;
numOrphans2 = 0;
augLenMin = 999999;
augLenMax = 0;
#endif
//
// init
//
orphanFirst = END_OF_ORPHANS;
activeFirst1 = END_OF_LIST_NODE;
activeLevel = 1;
for (i=nodes; i<nodeLast; i++)
{
i->nextActive = NULL;
i->firstSon = NULL;
if (i->terminalCap == 0)
{
i->parent = NULL;
}
else
{
i->parent = TERMINAL;
if (i->terminalCap > 0)
{
i->label = 1;
SET_ACTIVE(i);
}
else
{
i->label = -1;
SET_ACTIVE(i);
}
}
}
activeFirst0 = activeFirst1;
activeFirst1 = END_OF_LIST_NODE;
//
// growth + augment
//
prevSrc = NULL;
prevSink = NULL;
augInfo.flowDeficit = 0;
augInfo.flowExcess = 0;
while (activeFirst0 != END_OF_LIST_NODE)
{
//
// BFS level
//
while (activeFirst0 != END_OF_LIST_NODE)
{
/*
i = active_src_first0;
while (i->nextActive != END_OF_LIST_NODE)
{
if (i->parent &&
i->nextActive->parent &&
i->label > 0 &&
i->label != activeLevel_src &&
i->label != activeLevel_src+1)
{
i = active_src_first0;
printf("flow=%d, active_label=%d, src active ",
flow, activeLevel_src);
while (i != END_OF_LIST_NODE)
{
if (i->parent &&
(i->nextActive == END_OF_LIST_NODE ||
i->nextActive->parent == NULL ||
i->label != i->nextActive->label))
{
printf("%d ", i->label);
}
i = i->nextActive;
}
printf("\n");
break;
}
i = i->nextActive;
}
*/
i = activeFirst0;
activeFirst0 = i->nextActive;
i->nextActive = NULL;
if (i->parent == NULL)
{
#ifdef STATS
skippedGrowth++;
#endif
continue;
}
//if (ABS(i->label) != activeLevel &&
// ABS(i->label) != (activeLevel+1))
//{
//#ifdef FLOATS
// printf("ERROR, flow=%f, label=%d, active_label=%d\n",
// flow, i->label, activeLevel);
//#else
// printf("ERROR, flow=%d, label=%d, active_label=%d\n",
// flow, i->label, activeLevel);
//#endif
// exit(1);
//}
if (i->label > 0)
{
//
// GROWTH SRC
//
if (i->label != activeLevel)
{
#ifdef STATS
skippedGrowth++;
#endif
SET_ACTIVE(i);
continue;
}
#ifdef STATS
grownSourceTree++;
#endif
a_end = (i+1)->firstArc;
for (a=i->firstArc; a != a_end; a++)
{
#ifdef STATS
growthArcs++;
#endif
if (a->rCap != 0)
{
j = a->head;
if (j->parent == NULL)
{
j->label = i->label+1;
j->parent = a->sister;
j->nextSibling = NODE_PTR_TO_INDEX(i->firstSon);
i->firstSon = j;
SET_ACTIVE(j);
}
else if (j->label < 0)
{
i->nextActive = activeFirst0;
activeFirst0 = i;
if (prevSrc != i)
{
augInfo.remainingExcess = 0;
if (augInfo.flowExcess != 0)
{
i_tmp = prevSrc;
for (; ; i_tmp=a_tmp->head)
{
a_tmp = i_tmp->parent;
if (a_tmp == TERMINAL) break;
a_tmp->rCap += augInfo.flowExcess;
a_tmp->sister->sister_rCap = 1;
a_tmp->sister->rCap -= augInfo.flowExcess;
}
i_tmp->terminalCap -= augInfo.flowExcess;
augInfo.flowExcess = 0;
}
}
if (prevSrc != i || prevSink != j)
{
augInfo.remainingDeficit = 0;
if (augInfo.flowDeficit != 0)
{
i_tmp = prevSink;
for (; ; i_tmp=a_tmp->head)
{
a_tmp = i_tmp->parent;
if (a_tmp == TERMINAL) break;
a_tmp->sister->rCap += augInfo.flowDeficit;
a_tmp->sister_rCap = 1;
a_tmp->rCap -= augInfo.flowDeficit;
}
i_tmp->terminalCap += augInfo.flowDeficit;
augInfo.flowDeficit = 0;
}
}
augment(a, &augInfo);
prevSrc = i;
prevSink = j;
break;
}
}
}
}
else
{
//
// GROWTH SINK
//
if (-(i->label) != activeLevel)
{
#ifdef STATS
skippedGrowth++;
#endif
SET_ACTIVE(i);
continue;
}
#ifdef STATS
grownSinkTree++;
#endif
a_end = (i+1)->firstArc;
for (a=i->firstArc; a != a_end; a++)
{
#ifdef STATS
growthArcs++;
#endif
if (a->sister_rCap != 0)
{
j = a->head;
if (j->parent == NULL)
{
j->label = i->label-1;
j->parent = a->sister;
j->nextSibling = NODE_PTR_TO_INDEX(i->firstSon);
i->firstSon = j;
SET_ACTIVE(j);
}
else if (j->label > 0)
{
i->nextActive = activeFirst0;
activeFirst0 = i;
if (prevSink != i)
{
augInfo.remainingDeficit = 0;
if (augInfo.flowDeficit != 0)
{
i_tmp = prevSink;
for (; ; i_tmp=a_tmp->head)
{
a_tmp = i_tmp->parent;
if (a_tmp == TERMINAL) break;
a_tmp->sister->rCap += augInfo.flowDeficit;
a_tmp->sister_rCap = 1;
a_tmp->rCap -= augInfo.flowDeficit;
}
i_tmp->terminalCap += augInfo.flowDeficit;
augInfo.flowDeficit = 0;
}
}
if (prevSink != i || prevSrc != j)
{
augInfo.remainingExcess = 0;
if (augInfo.flowExcess != 0)
{
i_tmp = prevSrc;
for (; ; i_tmp=a_tmp->head)
{
a_tmp = i_tmp->parent;
if (a_tmp == TERMINAL) break;
a_tmp->rCap += augInfo.flowExcess;
a_tmp->sister->sister_rCap = 1;
a_tmp->sister->rCap -= augInfo.flowExcess;
}
i_tmp->terminalCap -= augInfo.flowExcess;
augInfo.flowExcess = 0;
}
}
augment(a->sister, &augInfo);
prevSrc = j;
prevSink = i;
break;
}
}
}
}
}
augInfo.remainingDeficit = 0;
if (augInfo.flowDeficit != 0)
{
i_tmp = prevSink;
for (; ; i_tmp=a_tmp->head)
{
a_tmp = i_tmp->parent;
if (a_tmp == TERMINAL) break;
a_tmp->sister->rCap += augInfo.flowDeficit;
a_tmp->sister_rCap = 1;
a_tmp->rCap -= augInfo.flowDeficit;
}
i_tmp->terminalCap += augInfo.flowDeficit;
augInfo.flowDeficit = 0;
prevSink = NULL;
}
augInfo.remainingExcess = 0;
if (augInfo.flowExcess != 0)
{
i_tmp = prevSrc;
for (; ; i_tmp=a_tmp->head)
{
a_tmp = i_tmp->parent;
if (a_tmp == TERMINAL) break;
a_tmp->rCap += augInfo.flowExcess;
a_tmp->sister->sister_rCap = 1;
a_tmp->sister->rCap -= augInfo.flowExcess;
}
i_tmp->terminalCap -= augInfo.flowExcess;
augInfo.flowExcess = 0;
prevSrc = NULL;
}
//
// switch to next level
//
#ifdef COUNT_RELABELS
for (int k=0; k<scanIndices.size(); k++)
{
total++;
if (scans[scanIndices[k]] <= 10)
{
counts[scans[scanIndices[k]]-1]++;
}
}
#endif
activeFirst0 = activeFirst1;
activeFirst1 = END_OF_LIST_NODE;
activeLevel++;
}
return flow;
}
void
layers_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpLayer *layer = NULL;
GimpLayerMask *mask = NULL; /* layer mask */
gboolean fs = FALSE; /* floating sel */
gboolean ac = FALSE; /* active channel */
gboolean sel = FALSE;
gboolean alpha = FALSE; /* alpha channel present */
gboolean indexed = FALSE; /* is indexed */
gboolean lock_alpha = FALSE;
gboolean text_layer = FALSE;
GList *next = NULL;
GList *prev = NULL;
if (image)
{
fs = (gimp_image_floating_sel (image) != NULL);
ac = (gimp_image_get_active_channel (image) != NULL);
sel = ! gimp_channel_is_empty (gimp_image_get_mask (image));
indexed = (gimp_image_base_type (image) == GIMP_INDEXED);
layer = gimp_image_get_active_layer (image);
if (layer)
{
GList *list;
mask = gimp_layer_get_mask (layer);
lock_alpha = gimp_layer_get_lock_alpha (layer);
alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
list = g_list_find (GIMP_LIST (image->layers)->list, layer);
if (list)
{
prev = g_list_previous (list);
next = g_list_next (list);
}
if (layer)
text_layer = gimp_drawable_is_text_layer (GIMP_DRAWABLE (layer));
}
}
#define SET_VISIBLE(action,condition) \
gimp_action_group_set_action_visible (group, action, (condition) != 0)
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
SET_VISIBLE ("layers-text-tool", text_layer && !ac);
SET_SENSITIVE ("layers-edit-attributes", layer && !fs && !ac);
SET_SENSITIVE ("layers-new", image);
SET_SENSITIVE ("layers-new-last-values", image);
SET_SENSITIVE ("layers-duplicate", layer && !fs && !ac);
SET_SENSITIVE ("layers-delete", layer && !ac);
SET_SENSITIVE ("layers-select-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-select-previous", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-next", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-raise", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-raise-to-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-lower", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-lower-to-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-anchor", layer && fs && !ac);
SET_SENSITIVE ("layers-merge-down", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-merge-layers", layer && !fs && !ac);
SET_SENSITIVE ("layers-flatten-image", layer && !fs && !ac);
SET_VISIBLE ("layers-text-discard", text_layer && !ac);
SET_VISIBLE ("layers-text-to-vectors", text_layer && !ac);
SET_VISIBLE ("layers-text-along-vectors", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-replace", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-add", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-subtract", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-intersect", text_layer && !ac);
SET_SENSITIVE ("layers-resize", layer && !ac);
SET_SENSITIVE ("layers-resize-to-image", layer && !ac);
SET_SENSITIVE ("layers-scale", layer && !ac);
SET_SENSITIVE ("layers-crop", layer && sel);
SET_SENSITIVE ("layers-alpha-add", layer && !fs && !alpha);
SET_SENSITIVE ("layers-alpha-remove", layer && !fs && alpha);
SET_SENSITIVE ("layers-lock-alpha", layer);
SET_ACTIVE ("layers-lock-alpha", lock_alpha);
SET_SENSITIVE ("layers-mask-add", layer && !fs && !ac && !mask);
SET_SENSITIVE ("layers-mask-apply", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-delete", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-edit", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-show", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-disable", layer && !fs && !ac && mask);
SET_ACTIVE ("layers-mask-edit", mask && gimp_layer_mask_get_edit (mask));
SET_ACTIVE ("layers-mask-show", mask && gimp_layer_mask_get_show (mask));
SET_ACTIVE ("layers-mask-disable", mask && !gimp_layer_mask_get_apply (mask));
SET_SENSITIVE ("layers-mask-selection-replace", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-add", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-subtract", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-intersect", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-alpha-selection-replace", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-add", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-subtract", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-intersect", layer && !fs && !ac);
#undef SET_VISIBLE
#undef SET_SENSITIVE
#undef SET_ACTIVE
}
void
view_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpDisplay *display = action_data_get_display (data);
GimpImage *image = NULL;
GimpDisplayShell *shell = NULL;
GimpDisplayOptions *options = NULL;
GimpColorConfig *color_config = NULL;
gchar *label = NULL;
gboolean fullscreen = FALSE;
gboolean revert_enabled = FALSE; /* able to revert zoom? */
gboolean flip_horizontally = FALSE;
gboolean flip_vertically = FALSE;
gboolean cm = FALSE;
gboolean sp = FALSE;
if (display)
{
GimpImageWindow *window;
GimpColorRenderingIntent intent = GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL;
gboolean bpc = TRUE;
const gchar *action = NULL;
image = gimp_display_get_image (display);
shell = gimp_display_get_shell (display);
window = gimp_display_shell_get_window (shell);
if (window)
fullscreen = gimp_image_window_get_fullscreen (window);
options = (image ?
(fullscreen ? shell->fullscreen_options : shell->options) :
shell->no_image_options);
revert_enabled = gimp_display_shell_scale_can_revert (shell);
flip_horizontally = shell->flip_horizontally;
flip_vertically = shell->flip_vertically;
color_config = gimp_display_shell_get_color_config (shell);
switch (color_config->mode)
{
case GIMP_COLOR_MANAGEMENT_OFF:
action = "view-color-management-mode-off";
break;
case GIMP_COLOR_MANAGEMENT_DISPLAY:
action = "view-color-management-mode-display";
intent = color_config->display_intent;
bpc = color_config->display_use_black_point_compensation;
cm = TRUE;
break;
case GIMP_COLOR_MANAGEMENT_SOFTPROOF:
action = "view-color-management-mode-softproof";
intent = color_config->simulation_intent;
bpc = color_config->simulation_use_black_point_compensation;
cm = TRUE;
sp = TRUE;
break;
}
gimp_action_group_set_action_active (group, action, TRUE);
switch (intent)
{
case GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL:
action = "view-color-management-intent-perceptual";
break;
case GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC:
action = "view-color-management-intent-relative-colorimetric";
break;
case GIMP_COLOR_RENDERING_INTENT_SATURATION:
action = "view-color-management-intent-saturation";
break;
case GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC:
action = "view-color-management-intent-absolute-colorimetric";
break;
}
gimp_action_group_set_action_active (group, action, TRUE);
gimp_action_group_set_action_active (group,
"view-color-management-black-point-compensation",
bpc);
gimp_action_group_set_action_active (group,
"view-color-management-gamut-check",
color_config->simulation_gamut_check);
}
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, color, FALSE)
SET_SENSITIVE ("view-new", image);
SET_SENSITIVE ("view-close", image);
SET_SENSITIVE ("view-dot-for-dot", image);
SET_ACTIVE ("view-dot-for-dot", display && shell->dot_for_dot);
SET_SENSITIVE ("view-zoom-revert", revert_enabled);
if (revert_enabled)
{
label = g_strdup_printf (_("Re_vert Zoom (%d%%)"),
ROUND (shell->last_scale * 100));
gimp_action_group_set_action_label (group, "view-zoom-revert", label);
g_free (label);
}
else
{
gimp_action_group_set_action_label (group, "view-zoom-revert",
_("Re_vert Zoom"));
}
SET_SENSITIVE ("view-zoom", image);
SET_SENSITIVE ("view-zoom-minimum", image);
SET_SENSITIVE ("view-zoom-maximum", image);
SET_SENSITIVE ("view-zoom-in", image);
SET_SENSITIVE ("view-zoom-in-accel", image);
SET_SENSITIVE ("view-zoom-in-skip", image);
SET_SENSITIVE ("view-zoom-out", image);
SET_SENSITIVE ("view-zoom-out-accel", image);
SET_SENSITIVE ("view-zoom-out-skip", image);
SET_SENSITIVE ("view-zoom-fit-in", image);
SET_SENSITIVE ("view-zoom-fill", image);
SET_SENSITIVE ("view-zoom-selection", image);
SET_SENSITIVE ("view-zoom-revert", image);
SET_SENSITIVE ("view-zoom-16-1", image);
SET_SENSITIVE ("view-zoom-16-1-accel", image);
SET_SENSITIVE ("view-zoom-8-1", image);
SET_SENSITIVE ("view-zoom-8-1-accel", image);
SET_SENSITIVE ("view-zoom-4-1", image);
SET_SENSITIVE ("view-zoom-4-1-accel", image);
SET_SENSITIVE ("view-zoom-2-1", image);
SET_SENSITIVE ("view-zoom-2-1-accel", image);
SET_SENSITIVE ("view-zoom-1-1", image);
SET_SENSITIVE ("view-zoom-1-1-accel", image);
SET_SENSITIVE ("view-zoom-1-2", image);
SET_SENSITIVE ("view-zoom-1-4", image);
SET_SENSITIVE ("view-zoom-1-8", image);
SET_SENSITIVE ("view-zoom-1-16", image);
SET_SENSITIVE ("view-zoom-other", image);
SET_SENSITIVE ("view-flip-horizontally", image);
SET_ACTIVE ("view-flip-horizontally", flip_horizontally);
SET_SENSITIVE ("view-flip-vertically", image);
SET_ACTIVE ("view-flip-vertically", flip_vertically);
SET_SENSITIVE ("view-rotate-reset", image);
SET_SENSITIVE ("view-rotate-15", image);
SET_SENSITIVE ("view-rotate-345", image);
SET_SENSITIVE ("view-rotate-90", image);
SET_SENSITIVE ("view-rotate-180", image);
SET_SENSITIVE ("view-rotate-270", image);
SET_SENSITIVE ("view-rotate-other", image);
if (image)
{
view_actions_set_zoom (group, shell);
view_actions_set_rotate (group, shell);
}
SET_SENSITIVE ("view-navigation-window", image);
SET_SENSITIVE ("view-display-filters", image);
SET_SENSITIVE ("view-color-management-mode-off", image);
SET_SENSITIVE ("view-color-management-mode-display", image);
SET_SENSITIVE ("view-color-management-mode-softproof", image);
SET_SENSITIVE ("view-color-management-intent-perceptual", cm);
SET_SENSITIVE ("view-color-management-intent-relative-colorimetric", cm);
SET_SENSITIVE ("view-color-management-intent-saturation", cm);
SET_SENSITIVE ("view-color-management-intent-absolute-colorimetric", cm);
SET_SENSITIVE ("view-color-management-black-point-compensation", cm);
SET_SENSITIVE ("view-color-management-gamut-check", sp);
SET_SENSITIVE ("view-color-management-reset", image);
SET_SENSITIVE ("view-show-selection", image);
SET_ACTIVE ("view-show-selection", display && options->show_selection);
SET_SENSITIVE ("view-show-layer-boundary", image);
SET_ACTIVE ("view-show-layer-boundary", display && options->show_layer_boundary);
SET_SENSITIVE ("view-show-guides", image);
SET_ACTIVE ("view-show-guides", display && options->show_guides);
SET_SENSITIVE ("view-show-grid", image);
SET_ACTIVE ("view-show-grid", display && options->show_grid);
SET_SENSITIVE ("view-show-sample-points", image);
SET_ACTIVE ("view-show-sample-points", display && options->show_sample_points);
SET_SENSITIVE ("view-snap-to-guides", image);
SET_ACTIVE ("view-snap-to-guides", display && options->snap_to_guides);
SET_SENSITIVE ("view-snap-to-grid", image);
SET_ACTIVE ("view-snap-to-grid", display && options->snap_to_grid);
SET_SENSITIVE ("view-snap-to-canvas", image);
SET_ACTIVE ("view-snap-to-canvas", display && options->snap_to_canvas);
SET_SENSITIVE ("view-snap-to-vectors", image);
SET_ACTIVE ("view-snap-to-vectors", display && options->snap_to_path);
SET_SENSITIVE ("view-padding-color-theme", image);
SET_SENSITIVE ("view-padding-color-light-check", image);
SET_SENSITIVE ("view-padding-color-dark-check", image);
SET_SENSITIVE ("view-padding-color-custom", image);
SET_SENSITIVE ("view-padding-color-prefs", image);
if (display)
{
SET_COLOR ("view-padding-color-menu", &options->padding_color);
if (shell->canvas)
{
GtkStyle *style = gtk_widget_get_style (shell->canvas);
GimpRGB color;
gtk_widget_ensure_style (shell->canvas);
gimp_rgb_set_gdk_color (&color, style->bg + GTK_STATE_NORMAL);
gimp_rgb_set_alpha (&color, GIMP_OPACITY_OPAQUE);
SET_COLOR ("view-padding-color-theme", &color);
}
}
SET_SENSITIVE ("view-show-menubar", image);
SET_ACTIVE ("view-show-menubar", display && options->show_menubar);
SET_SENSITIVE ("view-show-rulers", image);
SET_ACTIVE ("view-show-rulers", display && options->show_rulers);
SET_SENSITIVE ("view-show-scrollbars", image);
SET_ACTIVE ("view-show-scrollbars", display && options->show_scrollbars);
SET_SENSITIVE ("view-show-statusbar", image);
SET_ACTIVE ("view-show-statusbar", display && options->show_statusbar);
SET_SENSITIVE ("view-shrink-wrap", image);
SET_ACTIVE ("view-fullscreen", display && fullscreen);
if (GIMP_IS_IMAGE_WINDOW (group->user_data) ||
GIMP_IS_GIMP (group->user_data))
{
GtkWidget *window = NULL;
if (shell)
window = gtk_widget_get_toplevel (GTK_WIDGET (shell));
/* see view_actions_setup() */
if (GTK_IS_WINDOW (window))
window_actions_update (group, window);
}
#undef SET_ACTIVE
#undef SET_SENSITIVE
#undef SET_COLOR
}
void owl_context_set_editmulti(owl_context *ctx, owl_editwin *ew)
{
ctx->data = (void*)ew;
SET_ACTIVE(ctx, OWL_CTX_EDITMULTI);
}
template <typename captype, typename tcaptype, typename flowtype> flowtype IBFSGraph<captype, tcaptype, flowtype>::maxflowClean()
{
node *x, *y, *xTmp, *prevTarget;
arc *a, *aEnd, *aTmp;
AugmentationInfo augInfo;
#ifdef STATS
numAugs = 0;
numOrphans = 0;
grownSinkTree = 0;
grownSourceTree = 0;
numPushes = 0;
orphanArcs1 = 0;
orphanArcs2 = 0;
orphanArcs3 = 0;
growthArcs = 0;
augLenMin = 999999;
augLenMax = 0;
#endif
//
// init
//
orphanFirst = END_OF_ORPHANS;
activeFirst1 = END_OF_LIST_NODE;
activeLevel = 1;
for (x=nodes; x<nodeLast; x++)
{
x->nextActive = NULL;
x->firstSon = NULL;
if (x->srcSinkCap == 0)
{
x->parent = NULL;
}
else
{
x->parent = PARENT_SRC_SINK;
if (x->srcSinkCap > 0)
{
x->label = 1;
SET_ACTIVE(x);
}
else
{
x->label = -1;
SET_ACTIVE(x);
}
}
}
activeFirst0 = activeFirst1;
activeFirst1 = END_OF_LIST_NODE;
//
// IBFS
//
prevTarget = NULL;
augInfo.flowDeficit = 0;
augInfo.flowExcess = 0;
while (activeFirst0 != END_OF_LIST_NODE)
{
//
// BFS level
//
while (activeFirst0 != END_OF_LIST_NODE)
{
x = activeFirst0;
activeFirst0 = x->nextActive;
x->nextActive = NULL;
if (x->parent == NULL)
{
continue;
}
if (x->label > 0)
{
//
// Source Tree
//
if (x->label != activeLevel)
{
SET_ACTIVE(x);
continue;
}
#ifdef STATS
grownSourceTree++;
#endif
aEnd = (x+1)->firstArc;
for (a=x->firstArc; a != aEnd; a++)
{
#ifdef STATS
growthArcs++;
#endif
if (a->rCap != 0)
{
y = a->head;
if (y->parent == NULL)
{
y->label = x->label+1;
y->parent = a->sister;
y->nextSibling = NODE_PTR_TO_INDEX(x->firstSon);
x->firstSon = y;
SET_ACTIVE(y);
}
else if (y->label < 0)
{
x->nextActive = activeFirst0;
activeFirst0 = x;
if (prevTarget != y)
{
// clear deficit
augInfo.remainingDeficit = 0;
if (augInfo.flowDeficit != 0)
{
xTmp = prevTarget;
for (; ; xTmp=aTmp->head)
{
aTmp = xTmp->parent;
if (aTmp == PARENT_SRC_SINK) break;
aTmp->sister->rCap += augInfo.flowDeficit;
aTmp->sister_rCap = 1;
aTmp->rCap -= augInfo.flowDeficit;
}
xTmp->srcSinkCap += augInfo.flowDeficit;
augInfo.flowDeficit = 0;
}
}
augment(a, &augInfo);
prevTarget = y;
if (x->parent == NULL || x->label != activeLevel)
{
break;
}
activeFirst0 = activeFirst0->nextActive;
x->nextActive = NULL;
a = ((x->firstArc)-1);
}
}
}
// clear excess
augInfo.remainingExcess = 0;
if (augInfo.flowExcess != 0)
{
xTmp = x;
for (; ; xTmp=aTmp->head)
{
aTmp = xTmp->parent;
if (aTmp == PARENT_SRC_SINK) break;
aTmp->rCap += augInfo.flowExcess;
aTmp->sister->sister_rCap = 1;
aTmp->sister->rCap -= augInfo.flowExcess;
}
xTmp->srcSinkCap -= augInfo.flowExcess;
augInfo.flowExcess = 0;
}
// clear deficit
augInfo.remainingDeficit = 0;
if (augInfo.flowDeficit != 0)
{
xTmp = prevTarget;
for (; ; xTmp=aTmp->head)
{
aTmp = xTmp->parent;
if (aTmp == PARENT_SRC_SINK) break;
aTmp->sister->rCap += augInfo.flowDeficit;
aTmp->sister_rCap = 1;
aTmp->rCap -= augInfo.flowDeficit;
}
xTmp->srcSinkCap += augInfo.flowDeficit;
augInfo.flowDeficit = 0;
}
prevTarget = NULL;
}
else
{
//
// GROWTH SINK
//
if (-(x->label) != activeLevel)
{
SET_ACTIVE(x);
continue;
}
#ifdef STATS
grownSinkTree++;
#endif
aEnd = (x+1)->firstArc;
for (a=x->firstArc; a != aEnd; a++)
{
#ifdef STATS
growthArcs++;
#endif
if (a->sister_rCap != 0)
{
y = a->head;
if (y->parent == NULL)
{
y->label = x->label-1;
y->parent = a->sister;
y->nextSibling = NODE_PTR_TO_INDEX(x->firstSon);
x->firstSon = y;
SET_ACTIVE(y);
}
else if (y->label > 0)
{
x->nextActive = activeFirst0;
activeFirst0 = x;
// if (prevTarget != j)
// {
// // clear excess
// augInfo.remainingExcess = 0;
// if (augInfo.flowExcess != 0)
// {
// i_tmp = prevTarget;
// for (; ; i_tmp=a_tmp->head)
// {
// a_tmp = i_tmp->parent;
// if (a_tmp == PARENT_SRC_SINK) break;
// a_tmp->rCap += augInfo.flowExcess;
// a_tmp->sister->sister_rCap = 1;
// a_tmp->sister->rCap -= augInfo.flowExcess;
// }
// i_tmp->srcSinkCap -= augInfo.flowExcess;
// augInfo.flowExcess = 0;
// }
// }
augment(a->sister, &augInfo);
prevTarget = y;
if (x->parent == NULL || x->label != activeLevel)
{
break;
}
activeFirst0 = activeFirst0->nextActive;
x->nextActive = NULL;
a = ((x->firstArc)-1);
}
}
}
// clear excess
augInfo.remainingExcess = 0;
if (augInfo.flowExcess != 0)
{
xTmp = prevTarget;
for (; ; xTmp=aTmp->head)
{
aTmp = xTmp->parent;
if (aTmp == PARENT_SRC_SINK) break;
aTmp->rCap += augInfo.flowExcess;
aTmp->sister->sister_rCap = 1;
aTmp->sister->rCap -= augInfo.flowExcess;
}
xTmp->srcSinkCap -= augInfo.flowExcess;
augInfo.flowExcess = 0;
}
prevTarget = NULL;
// clear deficit
augInfo.remainingDeficit = 0;
if (augInfo.flowDeficit != 0)
{
xTmp = x;
for (; ; xTmp=aTmp->head)
{
aTmp = xTmp->parent;
if (aTmp == PARENT_SRC_SINK) break;
aTmp->sister->rCap += augInfo.flowDeficit;
aTmp->sister_rCap = 1;
aTmp->rCap -= augInfo.flowDeficit;
}
xTmp->srcSinkCap += augInfo.flowDeficit;
augInfo.flowDeficit = 0;
}
}
}
//
// switch to next level
//
activeFirst0 = activeFirst1;
activeFirst1 = END_OF_LIST_NODE;
activeLevel++;
}
return flow;
}
template <typename captype, typename tcaptype, typename flowtype> void IBFSGraph<captype, tcaptype, flowtype>::adoptionSink()
{
node *x, *y;
arc *a, *aEnd;
arc aTmp;
int minLabel;
while (orphanFirst != END_OF_ORPHANS)
{
x = orphanFirst;
orphanFirst = x->nextOrphan;
// we need PREVIOUSLY_ORPHAN vs NULL
// in order to establish whether the node
// has already started a "new parent" scan
// while in this level or not (used in ADD_ORPHAN)
x->nextOrphan = PREVIOUSLY_ORPHAN;
a = x->parent;
x->parent = NULL;
aEnd = (x+1)->firstArc;
// check for rehook
if (x->label != -1)
{
minLabel = x->label + 1;
for (; a != aEnd; a++)
{
#ifdef STATS
orphanArcs1++;
#endif
y = a->head;
if (a->rCap != 0 &&
y->parent != NULL &&
y->label == minLabel)
{
x->parent = a;
x->nextSibling = NODE_PTR_TO_INDEX(y->firstSon);
y->firstSon = x;
break;
}
}
}
// give up on node - relabel it!
if (x->parent == NULL)
{
minLabel = -(activeLevel+1);
for (a=x->firstArc; a != aEnd; a++)
{
#ifdef STATS
orphanArcs2++;
#endif
y = a->head;
if (a->rCap != 0 &&
y->parent != NULL &&
y->label < 0 &&
y->label > minLabel)
{
minLabel = y->label;
x->parent = a;
if (minLabel == x->label) break;
}
}
// create orphan sons
for (y=x->firstSon; y; y=NODE_INDEX_TO_PTR(y->nextSibling))
{
#ifdef STATS
orphanArcs3++;
#endif
if (minLabel == x->label &&
y->parent != y->firstArc)
{
aTmp = *(y->parent);
*(y->parent) = *(y->firstArc);
*(y->firstArc) = aTmp;
y->parent->sister->sister = y->parent;
y->firstArc->sister->sister = y->firstArc;
}
ADD_ORPHAN_BACK(y);
}
x->firstSon = NULL;
if (x->parent == NULL)
{
x->nextOrphan = NULL;
}
else
{
x->label = (minLabel-1);
x->nextSibling = NODE_PTR_TO_INDEX(x->parent->head->firstSon);
x->parent->head->firstSon = x;
if (minLabel == -activeLevel)
{
SET_ACTIVE(x);
}
}
}
}
}
void
items_actions_update (GimpActionGroup *group,
const gchar *prefix,
GimpItem *item)
{
GEnumClass *enum_class;
GEnumValue *value;
gchar action[32];
gboolean visible = FALSE;
gboolean linked = FALSE;
gboolean has_color_tag = FALSE;
gboolean locked = FALSE;
gboolean can_lock = FALSE;
gboolean locked_pos = FALSE;
gboolean can_lock_pos = FALSE;
GimpRGB tag_color;
if (item)
{
visible = gimp_item_get_visible (item);
linked = gimp_item_get_linked (item);
locked = gimp_item_get_lock_content (item);
can_lock = gimp_item_can_lock_content (item);
locked_pos = gimp_item_get_lock_position (item);
can_lock_pos = gimp_item_can_lock_position (item);
has_color_tag = gimp_get_color_tag_color (gimp_item_get_color_tag (item),
&tag_color, FALSE);
}
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, color, FALSE)
g_snprintf (action, sizeof (action), "%s-visible", prefix);
SET_SENSITIVE (action, item);
SET_ACTIVE (action, visible);
g_snprintf (action, sizeof (action), "%s-linked", prefix);
SET_SENSITIVE (action, item);
SET_ACTIVE (action, linked);
g_snprintf (action, sizeof (action), "%s-lock-content", prefix);
SET_SENSITIVE (action, can_lock);
SET_ACTIVE (action, locked);
g_snprintf (action, sizeof (action), "%s-lock-position", prefix);
SET_SENSITIVE (action, can_lock_pos);
SET_ACTIVE (action, locked_pos);
g_snprintf (action, sizeof (action), "%s-color-tag-menu", prefix);
SET_COLOR (action, has_color_tag ? &tag_color : NULL);
enum_class = g_type_class_ref (GIMP_TYPE_COLOR_TAG);
for (value = enum_class->values; value->value_name; value++)
{
g_snprintf (action, sizeof (action),
"%s-color-tag-%s", prefix, value->value_nick);
SET_SENSITIVE (action, item);
}
g_type_class_unref (enum_class);
#undef SET_SENSITIVE
#undef SET_ACTIVE
#undef SET_COLOR
}
void
drawable_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image;
GimpDrawable *drawable = NULL;
gboolean is_rgb = FALSE;
gboolean is_gray = FALSE;
gboolean is_indexed = FALSE;
gboolean visible = FALSE;
gboolean linked = FALSE;
gboolean locked = FALSE;
gboolean can_lock = FALSE;
gboolean writable = FALSE;
gboolean children = FALSE;
image = action_data_get_image (data);
if (image)
{
drawable = gimp_image_get_active_drawable (image);
if (drawable)
{
GimpImageType drawable_type = gimp_drawable_type (drawable);
GimpItem *item;
is_rgb = GIMP_IMAGE_TYPE_IS_RGB (drawable_type);
is_gray = GIMP_IMAGE_TYPE_IS_GRAY (drawable_type);
is_indexed = GIMP_IMAGE_TYPE_IS_INDEXED (drawable_type);
if (GIMP_IS_LAYER_MASK (drawable))
item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable)));
else
item = GIMP_ITEM (drawable);
visible = gimp_item_get_visible (item);
linked = gimp_item_get_linked (item);
locked = gimp_item_get_lock_content (item);
can_lock = gimp_item_can_lock_content (item);
writable = ! gimp_item_is_content_locked (item);
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
children = TRUE;
}
}
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
SET_SENSITIVE ("drawable-equalize", writable && !children && !is_indexed);
SET_SENSITIVE ("drawable-invert", writable && !children && !is_indexed);
SET_SENSITIVE ("drawable-levels-stretch", writable && !children && is_rgb);
SET_SENSITIVE ("drawable-offset", writable && !children);
SET_SENSITIVE ("drawable-visible", drawable);
SET_SENSITIVE ("drawable-linked", drawable);
SET_SENSITIVE ("drawable-lock-content", can_lock);
SET_ACTIVE ("drawable-visible", visible);
SET_ACTIVE ("drawable-linked", linked);
SET_ACTIVE ("drawable-lock-content", locked);
SET_SENSITIVE ("drawable-flip-horizontal", writable);
SET_SENSITIVE ("drawable-flip-vertical", writable);
SET_SENSITIVE ("drawable-rotate-90", writable);
SET_SENSITIVE ("drawable-rotate-180", writable);
SET_SENSITIVE ("drawable-rotate-270", writable);
#undef SET_SENSITIVE
#undef SET_ACTIVE
}
void
vectors_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpVectors *vectors = NULL;
GimpDrawable *drawable = NULL;
gint n_vectors = 0;
gboolean mask_empty = TRUE;
gboolean visible = FALSE;
gboolean linked = FALSE;
gboolean locked = FALSE;
gboolean can_lock = FALSE;
gboolean locked_pos = FALSE;
gboolean can_lock_pos = FALSE;
gboolean dr_writable = FALSE;
gboolean dr_children = FALSE;
GList *next = NULL;
GList *prev = NULL;
if (image)
{
n_vectors = gimp_image_get_n_vectors (image);
mask_empty = gimp_channel_is_empty (gimp_image_get_mask (image));
vectors = gimp_image_get_active_vectors (image);
if (vectors)
{
GimpItem *item = GIMP_ITEM (vectors);
GList *vectors_list;
GList *list;
visible = gimp_item_get_visible (item);
linked = gimp_item_get_linked (item);
locked = gimp_item_get_lock_content (item);
can_lock = gimp_item_can_lock_content (item);
locked_pos = gimp_item_get_lock_position (item);
can_lock_pos = gimp_item_can_lock_position (item);
vectors_list = gimp_item_get_container_iter (item);
list = g_list_find (vectors_list, vectors);
if (list)
{
prev = g_list_previous (list);
next = g_list_next (list);
}
}
drawable = gimp_image_get_active_drawable (image);
if (drawable)
{
GimpItem *item = GIMP_ITEM (drawable);
dr_writable = ! gimp_item_is_content_locked (item);
if (gimp_viewable_get_children (GIMP_VIEWABLE (item)))
dr_children = TRUE;
}
}
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
SET_SENSITIVE ("vectors-path-tool", vectors);
SET_SENSITIVE ("vectors-edit-attributes", vectors);
SET_SENSITIVE ("vectors-new", image);
SET_SENSITIVE ("vectors-new-last-values", image);
SET_SENSITIVE ("vectors-duplicate", vectors);
SET_SENSITIVE ("vectors-delete", vectors);
SET_SENSITIVE ("vectors-merge-visible", n_vectors > 1);
SET_SENSITIVE ("vectors-raise", vectors && prev);
SET_SENSITIVE ("vectors-raise-to-top", vectors && prev);
SET_SENSITIVE ("vectors-lower", vectors && next);
SET_SENSITIVE ("vectors-lower-to-bottom", vectors && next);
SET_SENSITIVE ("vectors-copy", vectors);
SET_SENSITIVE ("vectors-paste", image);
SET_SENSITIVE ("vectors-export", vectors);
SET_SENSITIVE ("vectors-import", image);
SET_SENSITIVE ("vectors-visible", vectors);
SET_SENSITIVE ("vectors-linked", vectors);
SET_SENSITIVE ("vectors-lock-content", can_lock);
SET_SENSITIVE ("vectors-lock-position", can_lock_pos);
SET_ACTIVE ("vectors-visible", visible);
SET_ACTIVE ("vectors-linked", linked);
SET_ACTIVE ("vectors-lock-content", locked);
SET_ACTIVE ("vectors-lock-position", locked_pos);
SET_SENSITIVE ("vectors-selection-to-vectors", image && !mask_empty);
SET_SENSITIVE ("vectors-selection-to-vectors-short", image && !mask_empty);
SET_SENSITIVE ("vectors-selection-to-vectors-advanced", image && !mask_empty);
SET_SENSITIVE ("vectors-fill", vectors &&
dr_writable &&
!dr_children);
SET_SENSITIVE ("vectors-fill-last-values", vectors &&
dr_writable &&
!dr_children);
SET_SENSITIVE ("vectors-stroke", vectors &&
dr_writable &&
!dr_children);
SET_SENSITIVE ("vectors-stroke-last-values", vectors &&
dr_writable &&
!dr_children);
SET_SENSITIVE ("vectors-selection-replace", vectors);
SET_SENSITIVE ("vectors-selection-from-vectors", vectors);
SET_SENSITIVE ("vectors-selection-add", vectors);
SET_SENSITIVE ("vectors-selection-subtract", vectors);
SET_SENSITIVE ("vectors-selection-intersect", vectors);
#undef SET_SENSITIVE
#undef SET_ACTIVE
}
void owl_context_set_popless(owl_context *ctx, owl_viewwin *vw)
{
ctx->data = (void*)vw;
SET_ACTIVE(ctx, OWL_CTX_POPLESS);
}
void owl_context_set_recv(owl_context *ctx)
{
SET_ACTIVE(ctx, OWL_CTX_RECV);
}
void owl_context_set_editresponse(owl_context *ctx, owl_editwin *ew)
{
ctx->data = (void*)ew;
SET_ACTIVE(ctx, OWL_CTX_EDITRESPONSE);
}
void owl_context_set_editline(owl_context *ctx, owl_editwin *ew)
{
ctx->data = (void*)ew;
SET_ACTIVE(ctx, OWL_CTX_EDITLINE);
}
template <typename captype, typename tcaptype, typename flowtype> void IBFSGraph<captype, tcaptype, flowtype>::adoptionSink()
{
node *i, *j;
arc *a, *a_end;
arc tmp_a;
int min_label;
while (orphanFirst != END_OF_ORPHANS)
{
// terminalCap is used as a next pointer for the orphans list
i = orphanFirst;
orphanFirst = i->nextOrphan;
#ifdef STATS
statsNumOrphans++;
// if (orphanPhaseNodesHash[i-nodes] == false)
// {
// orphanPhaseNodesHash[i-nodes] = true;
// orphanPhaseLabels[numOrphanPhaseNodes] = -(i->label);
// orphanPhaseNodes[numOrphanPhaseNodes] = i;
// numOrphanPhaseNodes++;
// }
#endif
// we need PREVIOUSLY_ORPHAN vs NULL
// in order to establish whether the node
// has already started a "new parent" scan
// while in this level or not (used in ADD_ORPHAN)
i->nextOrphan = PREVIOUSLY_ORPHAN;
a = i->parent;
i->parent = NULL;
a_end = (i+1)->firstArc;
#ifdef COUNT_RELABELS
if (scans[i-nodes] == 0)
{
scanIndices.push_back(i-nodes);
}
if ((scans[i-nodes]%2) == 0)
{
scans[i-nodes]++;
}
#endif
// check for rehook
if (i->label != -1)
{
min_label = i->label + 1;
for (; a != a_end; a++)
{
#ifdef STATS
orphanArcs1++;
#endif
j = a->head;
if (a->rCap != 0 &&
j->parent != NULL &&
j->label == min_label)
{
i->parent = a;
i->nextSibling = NODE_PTR_TO_INDEX(j->firstSon);
j->firstSon = i;
break;
}
}
}
// give up on node - relabel it!
if (i->parent == NULL)
{
#ifdef COUNT_RELABELS
scans[i-nodes]++;
#endif
min_label = -(activeLevel+1);
for (a=i->firstArc; a != a_end; a++)
{
#ifdef STATS
orphanArcs2++;
#endif
j = a->head;
if (a->rCap != 0 &&
j->parent != NULL &&
j->label < 0 &&
j->label > min_label)
{
min_label = j->label;
i->parent = a;
if (min_label == i->label) break;
}
}
for (j=i->firstSon; j; j=NODE_INDEX_TO_PTR(j->nextSibling))
{
#ifdef STATS
orphanArcs3++;
#endif
if (min_label == i->label &&
j->parent != j->firstArc)
{
tmp_a = *(j->parent);
*(j->parent) = *(j->firstArc);
*(j->firstArc) = tmp_a;
j->parent->sister->sister = j->parent;
j->firstArc->sister->sister = j->firstArc;
}
ADD_ORPHAN_BACK(j);
}
i->firstSon = NULL;
if (i->parent == NULL)
{
i->nextOrphan = NULL;
}
else
{
i->label = (min_label-1);
i->nextSibling = NODE_PTR_TO_INDEX(i->parent->head->firstSon);
i->parent->head->firstSon = i;
if (min_label == -activeLevel)
{
SET_ACTIVE(i);
}
}
}
}
}
void
layers_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpLayer *layer = NULL;
GimpLayerMask *mask = NULL; /* layer mask */
gboolean fs = FALSE; /* floating sel */
gboolean ac = FALSE; /* active channel */
gboolean sel = FALSE;
gboolean alpha = FALSE; /* alpha channel present */
gboolean indexed = FALSE; /* is indexed */
gboolean lock_alpha = FALSE;
gboolean can_lock_alpha = FALSE;
gboolean text_layer = FALSE;
gboolean writable = FALSE;
gboolean children = FALSE;
GList *next = NULL;
GList *next_visible = NULL;
GList *prev = NULL;
if (image)
{
fs = (gimp_image_get_floating_selection (image) != NULL);
ac = (gimp_image_get_active_channel (image) != NULL);
sel = ! gimp_channel_is_empty (gimp_image_get_mask (image));
indexed = (gimp_image_base_type (image) == GIMP_INDEXED);
layer = gimp_image_get_active_layer (image);
if (layer)
{
GList *layer_list;
GList *list;
mask = gimp_layer_get_mask (layer);
lock_alpha = gimp_layer_get_lock_alpha (layer);
can_lock_alpha = gimp_layer_can_lock_alpha (layer);
alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
writable = ! gimp_item_is_content_locked (GIMP_ITEM (layer));
if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))
children = TRUE;
layer_list = gimp_item_get_container_iter (GIMP_ITEM (layer));
list = g_list_find (layer_list, layer);
if (list)
{
prev = g_list_previous (list);
next = g_list_next (list);
for (next_visible = next;
next_visible;
next_visible = g_list_next (next_visible))
{
if (gimp_item_get_visible (next_visible->data))
{
/* "next_visible" is actually "next_visible" and
* "writable" and "not group"
*/
if (gimp_item_is_content_locked (next_visible->data) ||
gimp_viewable_get_children (next_visible->data))
next_visible = NULL;
break;
}
}
}
text_layer = gimp_item_is_text_layer (GIMP_ITEM (layer));
}
}
#define SET_VISIBLE(action,condition) \
gimp_action_group_set_action_visible (group, action, (condition) != 0)
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_LABEL(action,label) \
gimp_action_group_set_action_label (group, action, label)
SET_VISIBLE ("layers-text-tool", text_layer && !ac);
SET_SENSITIVE ("layers-edit-attributes", layer && !fs && !ac);
if (layer && gimp_layer_is_floating_sel (layer))
{
SET_LABEL ("layers-new", C_("layers-action", "To _New Layer"));
SET_LABEL ("layers-new-last-values", C_("layers-action", "To _New Layer"));
}
else
{
SET_LABEL ("layers-new", C_("layers-action", "_New Layer..."));
SET_LABEL ("layers-new-last-values", C_("layers-action", "_New Layer"));
}
SET_SENSITIVE ("layers-new", image);
SET_SENSITIVE ("layers-new-last-values", image);
SET_SENSITIVE ("layers-new-from-visible", image);
SET_SENSITIVE ("layers-new-group", image && !indexed);
SET_SENSITIVE ("layers-duplicate", layer && !fs && !ac);
SET_SENSITIVE ("layers-delete", layer && !ac);
SET_SENSITIVE ("layers-select-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-select-previous", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-next", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-raise", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-raise-to-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-lower", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-lower-to-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-anchor", layer && fs && !ac);
SET_SENSITIVE ("layers-merge-down", layer && !fs && !ac && next_visible);
SET_VISIBLE ("layers-merge-group", children);
SET_SENSITIVE ("layers-merge-group", layer && !fs && !ac && children);
SET_SENSITIVE ("layers-merge-layers", layer && !fs && !ac);
SET_SENSITIVE ("layers-flatten-image", layer && !fs && !ac);
SET_VISIBLE ("layers-text-discard", text_layer && !ac);
SET_VISIBLE ("layers-text-to-vectors", text_layer && !ac);
SET_VISIBLE ("layers-text-along-vectors", text_layer && !ac);
SET_SENSITIVE ("layers-resize", writable && !ac);
SET_SENSITIVE ("layers-resize-to-image", writable && !ac);
SET_SENSITIVE ("layers-scale", writable && !ac);
SET_SENSITIVE ("layers-crop", writable && sel);
SET_SENSITIVE ("layers-alpha-add", writable && !children && !fs && !alpha);
SET_SENSITIVE ("layers-alpha-remove", writable && !children && !fs && alpha);
SET_SENSITIVE ("layers-lock-alpha", can_lock_alpha);
SET_ACTIVE ("layers-lock-alpha", lock_alpha);
SET_SENSITIVE ("layers-mask-add", layer && !fs && !ac && !mask && !children);
SET_SENSITIVE ("layers-mask-apply", writable && !fs && !ac && mask && !children);
SET_SENSITIVE ("layers-mask-delete", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-edit", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-show", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-disable", layer && !fs && !ac && mask);
SET_ACTIVE ("layers-mask-edit", mask && gimp_layer_mask_get_edit (mask));
SET_ACTIVE ("layers-mask-show", mask && gimp_layer_mask_get_show (mask));
SET_ACTIVE ("layers-mask-disable", mask && !gimp_layer_mask_get_apply (mask));
SET_SENSITIVE ("layers-mask-selection-replace", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-add", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-subtract", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-intersect", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-alpha-selection-replace", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-add", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-subtract", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-intersect", layer && !fs && !ac);
#undef SET_VISIBLE
#undef SET_SENSITIVE
#undef SET_ACTIVE
#undef SET_LABEL
}
void
dockable_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpDockable *dockable;
GimpDockbook *dockbook;
GimpDocked *docked;
GimpDialogFactoryEntry *entry;
GimpContainerView *view;
GimpViewType view_type = -1;
gboolean list_view_available = FALSE;
gboolean grid_view_available = FALSE;
GimpViewSize view_size = -1;
GimpTabStyle tab_style = -1;
gint n_pages = 0;
gint n_books = 0;
if (GIMP_IS_DOCKBOOK (data))
{
gint page_num;
dockbook = GIMP_DOCKBOOK (data);
page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
dockable = (GimpDockable *)
gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook), page_num);
}
else if (GIMP_IS_DOCKABLE (data))
{
dockable = GIMP_DOCKABLE (data);
dockbook = dockable->dockbook;
}
else
{
return;
}
docked = GIMP_DOCKED (gtk_bin_get_child (GTK_BIN (dockable)));
gimp_dialog_factory_from_widget (GTK_WIDGET (dockable), &entry);
if (entry)
{
gchar *identifier;
gchar *substring = NULL;
identifier = g_strdup (entry->identifier);
if ((substring = strstr (identifier, "grid")))
view_type = GIMP_VIEW_TYPE_GRID;
else if ((substring = strstr (identifier, "list")))
view_type = GIMP_VIEW_TYPE_LIST;
if (substring)
{
memcpy (substring, "list", 4);
if (gimp_dialog_factory_find_entry (dockbook->dock->dialog_factory,
identifier))
list_view_available = TRUE;
memcpy (substring, "grid", 4);
if (gimp_dialog_factory_find_entry (dockbook->dock->dialog_factory,
identifier))
grid_view_available = TRUE;
}
g_free (identifier);
}
view = gimp_container_view_get_by_dockable (dockable);
if (view)
view_size = gimp_container_view_get_view_size (view, NULL);
tab_style = dockable->tab_style;
n_pages = gtk_notebook_get_n_pages (GTK_NOTEBOOK (dockbook));
n_books = g_list_length (dockbook->dock->dockbooks);
#define SET_ACTIVE(action,active) \
gimp_action_group_set_action_active (group, action, (active) != 0)
#define SET_VISIBLE(action,active) \
gimp_action_group_set_action_visible (group, action, (active) != 0)
#define SET_SENSITIVE(action,sensitive) \
gimp_action_group_set_action_sensitive (group, action, (sensitive) != 0)
SET_SENSITIVE ("dockable-detach-tab", n_pages > 1 || n_books > 1);
SET_VISIBLE ("dockable-preview-size-menu", view_size != -1);
if (view_size != -1)
{
if (view_size >= GIMP_VIEW_SIZE_GIGANTIC)
{
SET_ACTIVE ("dockable-preview-size-gigantic", TRUE);
}
else if (view_size >= GIMP_VIEW_SIZE_ENORMOUS)
{
SET_ACTIVE ("dockable-preview-size-enormous", TRUE);
}
else if (view_size >= GIMP_VIEW_SIZE_HUGE)
{
SET_ACTIVE ("dockable-preview-size-huge", TRUE);
}
else if (view_size >= GIMP_VIEW_SIZE_EXTRA_LARGE)
{
SET_ACTIVE ("dockable-preview-size-extra-large", TRUE);
}
else if (view_size >= GIMP_VIEW_SIZE_LARGE)
{
SET_ACTIVE ("dockable-preview-size-large", TRUE);
}
else if (view_size >= GIMP_VIEW_SIZE_MEDIUM)
{
SET_ACTIVE ("dockable-preview-size-medium", TRUE);
}
else if (view_size >= GIMP_VIEW_SIZE_SMALL)
{
SET_ACTIVE ("dockable-preview-size-small", TRUE);
}
else if (view_size >= GIMP_VIEW_SIZE_EXTRA_SMALL)
{
SET_ACTIVE ("dockable-preview-size-extra-small", TRUE);
}
else if (view_size >= GIMP_VIEW_SIZE_TINY)
{
SET_ACTIVE ("dockable-preview-size-tiny", TRUE);
}
}
SET_VISIBLE ("dockable-tab-style-menu", n_pages > 1);
if (n_pages > 1)
{
GimpDockedInterface *docked_iface = GIMP_DOCKED_GET_INTERFACE (docked);
if (tab_style == GIMP_TAB_STYLE_ICON)
SET_ACTIVE ("dockable-tab-style-icon", TRUE);
else if (tab_style == GIMP_TAB_STYLE_PREVIEW)
SET_ACTIVE ("dockable-tab-style-preview", TRUE);
else if (tab_style == GIMP_TAB_STYLE_NAME)
SET_ACTIVE ("dockable-tab-style-name", TRUE);
else if (tab_style == GIMP_TAB_STYLE_ICON_NAME)
SET_ACTIVE ("dockable-tab-style-icon-name", TRUE);
else if (tab_style == GIMP_TAB_STYLE_PREVIEW_NAME)
SET_ACTIVE ("dockable-tab-style-preview-name", TRUE);
SET_SENSITIVE ("dockable-tab-style-preview",
docked_iface->get_preview);
SET_SENSITIVE ("dockable-tab-style-preview-name",
docked_iface->get_preview);
}
SET_VISIBLE ("dockable-view-type-grid", view_type != -1);
SET_VISIBLE ("dockable-view-type-list", view_type != -1);
if (view_type != -1)
{
if (view_type == GIMP_VIEW_TYPE_LIST)
SET_ACTIVE ("dockable-view-type-list", TRUE);
else
SET_ACTIVE ("dockable-view-type-grid", TRUE);
SET_SENSITIVE ("dockable-view-type-grid", grid_view_available);
SET_SENSITIVE ("dockable-view-type-list", list_view_available);
}
SET_VISIBLE ("dockable-show-button-bar", gimp_docked_has_button_bar (docked));
SET_ACTIVE ("dockable-show-button-bar",
gimp_docked_get_show_button_bar (docked));
#undef SET_ACTIVE
#undef SET_VISIBLE
#undef SET_SENSITIVE
}