summaryrefslogtreecommitdiff
path: root/src/CheckerboardLayout.vala
diff options
context:
space:
mode:
Diffstat (limited to 'src/CheckerboardLayout.vala')
-rw-r--r--src/CheckerboardLayout.vala1912
1 files changed, 1912 insertions, 0 deletions
diff --git a/src/CheckerboardLayout.vala b/src/CheckerboardLayout.vala
new file mode 100644
index 0000000..6d0ce61
--- /dev/null
+++ b/src/CheckerboardLayout.vala
@@ -0,0 +1,1912 @@
+/* Copyright 2009-2014 Yorba Foundation
+ *
+ * This software is licensed under the GNU LGPL (version 2.1 or later).
+ * See the COPYING file in this distribution.
+ */
+
+private class CheckerboardItemText {
+ private static int one_line_height = 0;
+
+ private string text;
+ private bool marked_up;
+ private Pango.Alignment alignment;
+ private Pango.Layout layout = null;
+ private bool single_line = true;
+ private int height = 0;
+
+ public Gdk.Rectangle allocation = Gdk.Rectangle();
+
+ public CheckerboardItemText(string text, Pango.Alignment alignment = Pango.Alignment.LEFT,
+ bool marked_up = false) {
+ this.text = text;
+ this.marked_up = marked_up;
+ this.alignment = alignment;
+
+ single_line = is_single_line();
+ }
+
+ private bool is_single_line() {
+ return !String.contains_char(text, '\n');
+ }
+
+ public bool is_marked_up() {
+ return marked_up;
+ }
+
+ public bool is_set_to(string text, bool marked_up, Pango.Alignment alignment) {
+ return (this.marked_up == marked_up && this.alignment == alignment && this.text == text);
+ }
+
+ public string get_text() {
+ return text;
+ }
+
+ public int get_height() {
+ if (height == 0)
+ update_height();
+
+ return height;
+ }
+
+ public Pango.Layout get_pango_layout(int max_width = 0) {
+ if (layout == null)
+ create_pango();
+
+ if (max_width > 0)
+ layout.set_width(max_width * Pango.SCALE);
+
+ return layout;
+ }
+
+ public void clear_pango_layout() {
+ layout = null;
+ }
+
+ private void update_height() {
+ if (one_line_height != 0 && single_line)
+ height = one_line_height;
+ else
+ create_pango();
+ }
+
+ private void create_pango() {
+ // create layout for this string and ellipsize so it never extends past its laid-down width
+ layout = AppWindow.get_instance().create_pango_layout(null);
+ if (!marked_up)
+ layout.set_text(text, -1);
+ else
+ layout.set_markup(text, -1);
+
+ layout.set_ellipsize(Pango.EllipsizeMode.END);
+ layout.set_alignment(alignment);
+
+ // getting pixel size is expensive, and we only need the height, so use cached values
+ // whenever possible
+ if (one_line_height != 0 && single_line) {
+ height = one_line_height;
+ } else {
+ int width;
+ layout.get_pixel_size(out width, out height);
+
+ // cache first one-line height discovered
+ if (one_line_height == 0 && single_line)
+ one_line_height = height;
+ }
+ }
+}
+
+public abstract class CheckerboardItem : ThumbnailView {
+ // Collection properties CheckerboardItem understands
+ // SHOW_TITLES (bool)
+ public const string PROP_SHOW_TITLES = "show-titles";
+ // SHOW_COMMENTS (bool)
+ public const string PROP_SHOW_COMMENTS = "show-comments";
+ // SHOW_SUBTITLES (bool)
+ public const string PROP_SHOW_SUBTITLES = "show-subtitles";
+
+ public const int FRAME_WIDTH = 8;
+ public const int LABEL_PADDING = 4;
+ public const int BORDER_WIDTH = 1;
+
+ public const int SHADOW_RADIUS = 4;
+ public const float SHADOW_INITIAL_ALPHA = 0.5f;
+
+ public const int TRINKET_SCALE = 12;
+ public const int TRINKET_PADDING = 1;
+
+ public const int BRIGHTEN_SHIFT = 0x18;
+
+ public Dimensions requisition = Dimensions();
+ public Gdk.Rectangle allocation = Gdk.Rectangle();
+
+ private bool exposure = false;
+ private CheckerboardItemText? title = null;
+ private bool title_visible = true;
+ private CheckerboardItemText? comment = null;
+ private bool comment_visible = true;
+ private CheckerboardItemText? subtitle = null;
+ private bool subtitle_visible = false;
+ private bool is_cursor = false;
+ private Gdk.Pixbuf pixbuf = null;
+ private Gdk.Pixbuf display_pixbuf = null;
+ private Gdk.Pixbuf brightened = null;
+ private Dimensions pixbuf_dim = Dimensions();
+ private int col = -1;
+ private int row = -1;
+ private int horizontal_trinket_offset = 0;
+
+ public CheckerboardItem(ThumbnailSource source, Dimensions initial_pixbuf_dim, string title, string? comment,
+ bool marked_up = false, Pango.Alignment alignment = Pango.Alignment.LEFT) {
+ base(source);
+
+ pixbuf_dim = initial_pixbuf_dim;
+ this.title = new CheckerboardItemText(title, alignment, marked_up);
+ // on the checkboard page we display the comment in
+ // one line, i.e., replacing all newlines with spaces.
+ // that means that the display will contain "..." if the comment
+ // is too long.
+ // warning: changes here have to be done in set_comment, too!
+ if (comment != null)
+ this.comment = new CheckerboardItemText(comment.replace("\n", " "), alignment,
+ marked_up);
+
+ // Don't calculate size here, wait for the item to be assigned to a ViewCollection
+ // (notify_membership_changed) and calculate when the collection's property settings
+ // are known
+ }
+
+ public override string get_name() {
+ return (title != null) ? title.get_text() : base.get_name();
+ }
+
+ public string get_title() {
+ return (title != null) ? title.get_text() : "";
+ }
+
+ public string get_comment() {
+ return (comment != null) ? comment.get_text() : "";
+ }
+
+ public void set_title(string text, bool marked_up = false,
+ Pango.Alignment alignment = Pango.Alignment.LEFT) {
+ if (title != null && title.is_set_to(text, marked_up, alignment))
+ return;
+
+ title = new CheckerboardItemText(text, alignment, marked_up);
+
+ if (title_visible) {
+ recalc_size("set_title");
+ notify_view_altered();
+ }
+ }
+
+ public void clear_title() {
+ if (title == null)
+ return;
+
+ title = null;
+
+ if (title_visible) {
+ recalc_size("clear_title");
+ notify_view_altered();
+ }
+ }
+
+ private void set_title_visible(bool visible) {
+ if (title_visible == visible)
+ return;
+
+ title_visible = visible;
+
+ recalc_size("set_title_visible");
+ notify_view_altered();
+ }
+
+ public void set_comment(string text, bool marked_up = false,
+ Pango.Alignment alignment = Pango.Alignment.LEFT) {
+ if (comment != null && comment.is_set_to(text, marked_up, alignment))
+ return;
+
+ comment = new CheckerboardItemText(text.replace("\n", " "), alignment, marked_up);
+
+ if (comment_visible) {
+ recalc_size("set_comment");
+ notify_view_altered();
+ }
+ }
+
+ public void clear_comment() {
+ if (comment == null)
+ return;
+
+ comment = null;
+
+ if (comment_visible) {
+ recalc_size("clear_comment");
+ notify_view_altered();
+ }
+ }
+
+ private void set_comment_visible(bool visible) {
+ if (comment_visible == visible)
+ return;
+
+ comment_visible = visible;
+
+ recalc_size("set_comment_visible");
+ notify_view_altered();
+ }
+
+
+ public string get_subtitle() {
+ return (subtitle != null) ? subtitle.get_text() : "";
+ }
+
+ public void set_subtitle(string text, bool marked_up = false,
+ Pango.Alignment alignment = Pango.Alignment.LEFT) {
+ if (subtitle != null && subtitle.is_set_to(text, marked_up, alignment))
+ return;
+
+ subtitle = new CheckerboardItemText(text, alignment, marked_up);
+
+ if (subtitle_visible) {
+ recalc_size("set_subtitle");
+ notify_view_altered();
+ }
+ }
+
+ public void clear_subtitle() {
+ if (subtitle == null)
+ return;
+
+ subtitle = null;
+
+ if (subtitle_visible) {
+ recalc_size("clear_subtitle");
+ notify_view_altered();
+ }
+ }
+
+ private void set_subtitle_visible(bool visible) {
+ if (subtitle_visible == visible)
+ return;
+
+ subtitle_visible = visible;
+
+ recalc_size("set_subtitle_visible");
+ notify_view_altered();
+ }
+
+ public void set_is_cursor(bool is_cursor) {
+ this.is_cursor = is_cursor;
+ }
+
+ public bool get_is_cusor() {
+ return is_cursor;
+ }
+
+ protected override void notify_membership_changed(DataCollection? collection) {
+ bool title_visible = (bool) get_collection_property(PROP_SHOW_TITLES, true);
+ bool comment_visible = (bool) get_collection_property(PROP_SHOW_COMMENTS, true);
+ bool subtitle_visible = (bool) get_collection_property(PROP_SHOW_SUBTITLES, false);
+
+ bool altered = false;
+ if (this.title_visible != title_visible) {
+ this.title_visible = title_visible;
+ altered = true;
+ }
+
+ if (this.comment_visible != comment_visible) {
+ this.comment_visible = comment_visible;
+ altered = true;
+ }
+
+ if (this.subtitle_visible != subtitle_visible) {
+ this.subtitle_visible = subtitle_visible;
+ altered = true;
+ }
+
+ if (altered || !requisition.has_area()) {
+ recalc_size("notify_membership_changed");
+ notify_view_altered();
+ }
+
+ base.notify_membership_changed(collection);
+ }
+
+ protected override void notify_collection_property_set(string name, Value? old, Value val) {
+ switch (name) {
+ case PROP_SHOW_TITLES:
+ set_title_visible((bool) val);
+ break;
+
+ case PROP_SHOW_COMMENTS:
+ set_comment_visible((bool) val);
+ break;
+
+ case PROP_SHOW_SUBTITLES:
+ set_subtitle_visible((bool) val);
+ break;
+ }
+
+ base.notify_collection_property_set(name, old, val);
+ }
+
+ // The alignment point is the coordinate on the y-axis (relative to the top of the
+ // CheckerboardItem) which this item should be aligned to. This allows for
+ // bottom-alignment along the bottom edge of the thumbnail.
+ public int get_alignment_point() {
+ return FRAME_WIDTH + BORDER_WIDTH + pixbuf_dim.height;
+ }
+
+ public virtual void exposed() {
+ exposure = true;
+ }
+
+ public virtual void unexposed() {
+ exposure = false;
+
+ if (title != null)
+ title.clear_pango_layout();
+
+ if (comment != null)
+ comment.clear_pango_layout();
+
+ if (subtitle != null)
+ subtitle.clear_pango_layout();
+ }
+
+ public virtual bool is_exposed() {
+ return exposure;
+ }
+
+ public bool has_image() {
+ return pixbuf != null;
+ }
+
+ public Gdk.Pixbuf? get_image() {
+ return pixbuf;
+ }
+
+ public void set_image(Gdk.Pixbuf pixbuf) {
+ this.pixbuf = pixbuf;
+ display_pixbuf = pixbuf;
+ pixbuf_dim = Dimensions.for_pixbuf(pixbuf);
+
+ recalc_size("set_image");
+ notify_view_altered();
+ }
+
+ public void clear_image(Dimensions dim) {
+ bool had_image = pixbuf != null;
+
+ pixbuf = null;
+ display_pixbuf = null;
+ pixbuf_dim = dim;
+
+ recalc_size("clear_image");
+
+ if (had_image)
+ notify_view_altered();
+ }
+
+ public static int get_max_width(int scale) {
+ // width is frame width (two sides) + frame padding (two sides) + width of pixbuf (text
+ // never wider)
+ return (FRAME_WIDTH * 2) + scale;
+ }
+
+ private void recalc_size(string reason) {
+ Dimensions old_requisition = requisition;
+
+ // only add in the text heights if they're displayed
+ int title_height = (title != null && title_visible)
+ ? title.get_height() + LABEL_PADDING : 0;
+ int comment_height = (comment != null && comment_visible)
+ ? comment.get_height() + LABEL_PADDING : 0;
+ int subtitle_height = (subtitle != null && subtitle_visible)
+ ? subtitle.get_height() + LABEL_PADDING : 0;
+
+ // width is frame width (two sides) + frame padding (two sides) + width of pixbuf
+ // (text never wider)
+ requisition.width = (FRAME_WIDTH * 2) + (BORDER_WIDTH * 2) + pixbuf_dim.width;
+
+ // height is frame width (two sides) + frame padding (two sides) + height of pixbuf
+ // + height of text + label padding (between pixbuf and text)
+ requisition.height = (FRAME_WIDTH * 2) + (BORDER_WIDTH * 2)
+ + pixbuf_dim.height + title_height + comment_height + subtitle_height;
+
+#if TRACE_REFLOW_ITEMS
+ debug("recalc_size %s: %s title_height=%d comment_height=%d subtitle_height=%d requisition=%s",
+ get_source().get_name(), reason, title_height, comment_height, subtitle_height,
+ requisition.to_string());
+#endif
+
+ if (!requisition.approx_equals(old_requisition)) {
+#if TRACE_REFLOW_ITEMS
+ debug("recalc_size %s: %s notifying geometry altered", get_source().get_name(), reason);
+#endif
+ notify_geometry_altered();
+ }
+ }
+
+ protected static Dimensions get_border_dimensions(Dimensions object_dim, int border_width) {
+ Dimensions dimensions = Dimensions();
+ dimensions.width = object_dim.width + (border_width * 2);
+ dimensions.height = object_dim.height + (border_width * 2);
+ return dimensions;
+ }
+
+ protected static Gdk.Point get_border_origin(Gdk.Point object_origin, int border_width) {
+ Gdk.Point origin = Gdk.Point();
+ origin.x = object_origin.x - border_width;
+ origin.y = object_origin.y - border_width;
+ return origin;
+ }
+
+ protected virtual void paint_shadow(Cairo.Context ctx, Dimensions dimensions, Gdk.Point origin,
+ int radius, float initial_alpha) {
+ double rgb_all = 0.0;
+
+ // top right corner
+ paint_shadow_in_corner(ctx, origin.x + dimensions.width, origin.y + radius, rgb_all, radius,
+ initial_alpha, -0.5 * Math.PI, 0);
+ // bottom right corner
+ paint_shadow_in_corner(ctx, origin.x + dimensions.width, origin.y + dimensions.height, rgb_all,
+ radius, initial_alpha, 0, 0.5 * Math.PI);
+ // bottom left corner
+ paint_shadow_in_corner(ctx, origin.x + radius, origin.y + dimensions.height, rgb_all, radius,
+ initial_alpha, 0.5 * Math.PI, Math.PI);
+
+ // left right
+ Cairo.Pattern lr = new Cairo.Pattern.linear(0, origin.y + dimensions.height,
+ 0, origin.y + dimensions.height + radius);
+ lr.add_color_stop_rgba(0.0, rgb_all, rgb_all, rgb_all, initial_alpha);
+ lr.add_color_stop_rgba(1.0, rgb_all, rgb_all, rgb_all, 0.0);
+ ctx.set_source(lr);
+ ctx.rectangle(origin.x + radius, origin.y + dimensions.height, dimensions.width - radius, radius);
+ ctx.fill();
+
+ // top down
+ Cairo.Pattern td = new Cairo.Pattern.linear(origin.x + dimensions.width,
+ 0, origin.x + dimensions.width + radius, 0);
+ td.add_color_stop_rgba(0.0, rgb_all, rgb_all, rgb_all, initial_alpha);
+ td.add_color_stop_rgba(1.0, rgb_all, rgb_all, rgb_all, 0.0);
+ ctx.set_source(td);
+ ctx.rectangle(origin.x + dimensions.width, origin.y + radius,
+ radius, dimensions.height - radius);
+ ctx.fill();
+ }
+
+ protected void paint_shadow_in_corner(Cairo.Context ctx, int x, int y,
+ double rgb_all, float radius, float initial_alpha, double arc1, double arc2) {
+ Cairo.Pattern p = new Cairo.Pattern.radial(x, y, 0, x, y, radius);
+ p.add_color_stop_rgba(0.0, rgb_all, rgb_all, rgb_all, initial_alpha);
+ p.add_color_stop_rgba(1.0, rgb_all, rgb_all, rgb_all, 0);
+ ctx.set_source(p);
+ ctx.move_to(x, y);
+ ctx.arc(x, y, radius, arc1, arc2);
+ ctx.close_path();
+ ctx.fill();
+ }
+
+ protected virtual void paint_border(Cairo.Context ctx, Dimensions object_dimensions,
+ Gdk.Point object_origin, int border_width) {
+ if (border_width == 1) {
+ ctx.rectangle(object_origin.x - border_width, object_origin.y - border_width,
+ object_dimensions.width + (border_width * 2),
+ object_dimensions.height + (border_width * 2));
+ ctx.fill();
+ } else {
+ Dimensions dimensions = get_border_dimensions(object_dimensions, border_width);
+ Gdk.Point origin = get_border_origin(object_origin, border_width);
+
+ // amount of rounding needed on corners varies by size of object
+ double scale = int.max(object_dimensions.width, object_dimensions.height);
+ draw_rounded_corners_filled(ctx, dimensions, origin, 0.25 * scale);
+ }
+ }
+
+ protected virtual void paint_image(Cairo.Context ctx, Gdk.Pixbuf pixbuf, Gdk.Point origin) {
+ if (pixbuf.get_has_alpha()) {
+ ctx.rectangle(origin.x, origin.y, pixbuf.get_width(), pixbuf.get_height());
+ ctx.fill();
+ }
+ Gdk.cairo_set_source_pixbuf(ctx, pixbuf, origin.x, origin.y);
+ ctx.paint();
+ }
+
+ private int get_selection_border_width(int scale) {
+ return ((scale <= ((Thumbnail.MIN_SCALE + Thumbnail.MAX_SCALE) / 3)) ? 2 : 3)
+ + BORDER_WIDTH;
+ }
+
+ protected virtual Gdk.Pixbuf? get_top_left_trinket(int scale) {
+ return null;
+ }
+
+ protected virtual Gdk.Pixbuf? get_top_right_trinket(int scale) {
+ return null;
+ }
+
+ protected virtual Gdk.Pixbuf? get_bottom_left_trinket(int scale) {
+ return null;
+ }
+
+ protected virtual Gdk.Pixbuf? get_bottom_right_trinket(int scale) {
+ return null;
+ }
+
+ public void paint(Cairo.Context ctx, Gdk.RGBA bg_color, Gdk.RGBA selected_color,
+ Gdk.RGBA text_color, Gdk.RGBA? border_color) {
+ // calc the top-left point of the pixbuf
+ Gdk.Point pixbuf_origin = Gdk.Point();
+ pixbuf_origin.x = allocation.x + FRAME_WIDTH + BORDER_WIDTH;
+ pixbuf_origin.y = allocation.y + FRAME_WIDTH + BORDER_WIDTH;
+
+ ctx.set_line_width(FRAME_WIDTH);
+ ctx.set_source_rgba(selected_color.red, selected_color.green, selected_color.blue,
+ selected_color.alpha);
+
+ // draw shadow
+ if (border_color != null) {
+ ctx.save();
+ Dimensions shadow_dim = Dimensions();
+ shadow_dim.width = pixbuf_dim.width + BORDER_WIDTH;
+ shadow_dim.height = pixbuf_dim.height + BORDER_WIDTH;
+ paint_shadow(ctx, shadow_dim, pixbuf_origin, SHADOW_RADIUS, SHADOW_INITIAL_ALPHA);
+ ctx.restore();
+ }
+
+ // draw a border for the cursor with the selection width and normal border color
+ if (is_cursor) {
+ ctx.save();
+ ctx.set_source_rgba(border_color.red, border_color.green, border_color.blue,
+ border_color.alpha);
+ paint_border(ctx, pixbuf_dim, pixbuf_origin,
+ get_selection_border_width(int.max(pixbuf_dim.width, pixbuf_dim.height)));
+ ctx.restore();
+ }
+
+ // draw selection border
+ if (is_selected()) {
+ // border thickness depends on the size of the thumbnail
+ ctx.save();
+ paint_border(ctx, pixbuf_dim, pixbuf_origin,
+ get_selection_border_width(int.max(pixbuf_dim.width, pixbuf_dim.height)));
+ ctx.restore();
+ }
+
+ // draw border
+ if (border_color != null) {
+ ctx.save();
+ ctx.set_source_rgba(border_color.red, border_color.green, border_color.blue,
+ border_color.alpha);
+ paint_border(ctx, pixbuf_dim, pixbuf_origin, BORDER_WIDTH);
+ ctx.restore();
+ }
+
+ if (display_pixbuf != null) {
+ ctx.save();
+ ctx.set_source_rgba(bg_color.red, bg_color.green, bg_color.blue, bg_color.alpha);
+ paint_image(ctx, display_pixbuf, pixbuf_origin);
+ ctx.restore();
+ }
+
+ ctx.set_source_rgba(text_color.red, text_color.green, text_color.blue, text_color.alpha);
+
+ // title and subtitles are LABEL_PADDING below bottom of pixbuf
+ int text_y = allocation.y + FRAME_WIDTH + pixbuf_dim.height + FRAME_WIDTH + LABEL_PADDING;
+ if (title != null && title_visible) {
+ // get the layout sized so its with is no more than the pixbuf's
+ // resize the text width to be no more than the pixbuf's
+ title.allocation.x = allocation.x + FRAME_WIDTH;
+ title.allocation.y = text_y;
+ title.allocation.width = pixbuf_dim.width;
+ title.allocation.height = title.get_height();
+
+ ctx.move_to(title.allocation.x, title.allocation.y);
+ Pango.cairo_show_layout(ctx, title.get_pango_layout(pixbuf_dim.width));
+
+ text_y += title.get_height() + LABEL_PADDING;
+ }
+
+ if (comment != null && comment_visible) {
+ comment.allocation.x = allocation.x + FRAME_WIDTH;
+ comment.allocation.y = text_y;
+ comment.allocation.width = pixbuf_dim.width;
+ comment.allocation.height = comment.get_height();
+
+ ctx.move_to(comment.allocation.x, comment.allocation.y);
+ Pango.cairo_show_layout(ctx, comment.get_pango_layout(pixbuf_dim.width));
+
+ text_y += comment.get_height() + LABEL_PADDING;
+ }
+
+ if (subtitle != null && subtitle_visible) {
+ subtitle.allocation.x = allocation.x + FRAME_WIDTH;
+ subtitle.allocation.y = text_y;
+ subtitle.allocation.width = pixbuf_dim.width;
+ subtitle.allocation.height = subtitle.get_height();
+
+ ctx.move_to(subtitle.allocation.x, subtitle.allocation.y);
+ Pango.cairo_show_layout(ctx, subtitle.get_pango_layout(pixbuf_dim.width));
+
+ // increment text_y if more text lines follow
+ }
+
+ ctx.set_source_rgba(selected_color.red, selected_color.green, selected_color.blue,
+ selected_color.alpha);
+
+ // draw trinkets last
+ Gdk.Pixbuf? trinket = get_bottom_left_trinket(TRINKET_SCALE);
+ if (trinket != null) {
+ int x = pixbuf_origin.x + TRINKET_PADDING + get_horizontal_trinket_offset();
+ int y = pixbuf_origin.y + pixbuf_dim.height - trinket.get_height() -
+ TRINKET_PADDING;
+ Gdk.cairo_set_source_pixbuf(ctx, trinket, x, y);
+ ctx.rectangle(x, y, trinket.get_width(), trinket.get_height());
+ ctx.fill();
+ }
+
+ trinket = get_top_left_trinket(TRINKET_SCALE);
+ if (trinket != null) {
+ int x = pixbuf_origin.x + TRINKET_PADDING + get_horizontal_trinket_offset();
+ int y = pixbuf_origin.y + TRINKET_PADDING;
+ Gdk.cairo_set_source_pixbuf(ctx, trinket, x, y);
+ ctx.rectangle(x, y, trinket.get_width(), trinket.get_height());
+ ctx.fill();
+ }
+
+ trinket = get_top_right_trinket(TRINKET_SCALE);
+ if (trinket != null) {
+ int x = pixbuf_origin.x + pixbuf_dim.width - trinket.width -
+ get_horizontal_trinket_offset() - TRINKET_PADDING;
+ int y = pixbuf_origin.y + TRINKET_PADDING;
+ Gdk.cairo_set_source_pixbuf(ctx, trinket, x, y);
+ ctx.rectangle(x, y, trinket.get_width(), trinket.get_height());
+ ctx.fill();
+ }
+
+ trinket = get_bottom_right_trinket(TRINKET_SCALE);
+ if (trinket != null) {
+ int x = pixbuf_origin.x + pixbuf_dim.width - trinket.width -
+ get_horizontal_trinket_offset() - TRINKET_PADDING;
+ int y = pixbuf_origin.y + pixbuf_dim.height - trinket.height -
+ TRINKET_PADDING;
+ Gdk.cairo_set_source_pixbuf(ctx, trinket, x, y);
+ ctx.rectangle(x, y, trinket.get_width(), trinket.get_height());
+ ctx.fill();
+ }
+ }
+
+ protected void set_horizontal_trinket_offset(int horizontal_trinket_offset) {
+ assert(horizontal_trinket_offset >= 0);
+ this.horizontal_trinket_offset = horizontal_trinket_offset;
+ }
+
+ protected int get_horizontal_trinket_offset() {
+ return horizontal_trinket_offset;
+ }
+
+ public void set_grid_coordinates(int col, int row) {
+ this.col = col;
+ this.row = row;
+ }
+
+ public int get_column() {
+ return col;
+ }
+
+ public int get_row() {
+ return row;
+ }
+
+ public void brighten() {
+ // "should" implies "can" and "didn't already"
+ if (brightened != null || pixbuf == null)
+ return;
+
+ // create a new lightened pixbuf to display
+ brightened = pixbuf.copy();
+ shift_colors(brightened, BRIGHTEN_SHIFT, BRIGHTEN_SHIFT, BRIGHTEN_SHIFT, 0);
+
+ display_pixbuf = brightened;
+
+ notify_view_altered();
+ }
+
+ public void unbrighten() {
+ // "should", "can", "didn't already"
+ if (brightened == null || pixbuf == null)
+ return;
+
+ brightened = null;
+
+ // return to the normal image
+ display_pixbuf = pixbuf;
+
+ notify_view_altered();
+ }
+
+ public override void visibility_changed(bool visible) {
+ // if going from visible to hidden, unbrighten
+ if (!visible)
+ unbrighten();
+
+ base.visibility_changed(visible);
+ }
+
+ private bool query_tooltip_on_text(CheckerboardItemText text, Gtk.Tooltip tooltip) {
+ if (!text.get_pango_layout().is_ellipsized())
+ return false;
+
+ if (text.is_marked_up())
+ tooltip.set_markup(text.get_text());
+ else
+ tooltip.set_text(text.get_text());
+
+ return true;
+ }
+
+ public bool query_tooltip(int x, int y, Gtk.Tooltip tooltip) {
+ if (title != null && title_visible && coord_in_rectangle(x, y, title.allocation))
+ return query_tooltip_on_text(title, tooltip);
+
+ if (comment != null && comment_visible && coord_in_rectangle(x, y, comment.allocation))
+ return query_tooltip_on_text(comment, tooltip);
+
+ if (subtitle != null && subtitle_visible && coord_in_rectangle(x, y, subtitle.allocation))
+ return query_tooltip_on_text(subtitle, tooltip);
+
+ return false;
+ }
+}
+
+public class CheckerboardLayout : Gtk.DrawingArea {
+ public const int TOP_PADDING = 16;
+ public const int BOTTOM_PADDING = 16;
+ public const int ROW_GUTTER_PADDING = 24;
+
+ // the following are minimums, as the pads and gutters expand to fill up the window width
+ public const int COLUMN_GUTTER_PADDING = 24;
+
+ // For a 40% alpha channel
+ private const double SELECTION_ALPHA = 0.40;
+
+ // The number of pixels that the scrollbars of Gtk.ScrolledWindows allocate for themselves
+ // before their final size is computed. This must be taken into account when computing
+ // the width of this widget. This value was 0 in Gtk+ 2.x but is 1 in Gtk+ 3.x. See
+ // ticket #3870 (http://redmine.yorba.org/issues/3870) for more information
+ private const int SCROLLBAR_PLACEHOLDER_WIDTH = 1;
+
+ private class LayoutRow {
+ public int y;
+ public int height;
+ public CheckerboardItem[] items;
+
+ public LayoutRow(int y, int height, int num_in_row) {
+ this.y = y;
+ this.height = height;
+ this.items = new CheckerboardItem[num_in_row];
+ }
+ }
+
+ private ViewCollection view;
+ private string page_name = "";
+ private LayoutRow[] item_rows = null;
+ private Gee.HashSet<CheckerboardItem> exposed_items = new Gee.HashSet<CheckerboardItem>();
+ private Gtk.Adjustment hadjustment = null;
+ private Gtk.Adjustment vadjustment = null;
+ private string message = null;
+ private Gdk.RGBA selected_color;
+ private Gdk.RGBA unselected_color;
+ private Gdk.RGBA border_color;
+ private Gdk.RGBA bg_color;
+ private Gdk.Rectangle visible_page = Gdk.Rectangle();
+ private int last_width = 0;
+ private int columns = 0;
+ private int rows = 0;
+ private Gdk.Point drag_origin = Gdk.Point();
+ private Gdk.Point drag_endpoint = Gdk.Point();
+ private Gdk.Rectangle selection_band = Gdk.Rectangle();
+ private int scale = 0;
+ private bool flow_scheduled = false;
+ private bool exposure_dirty = true;
+ private CheckerboardItem? anchor = null;
+ private CheckerboardItem? cursor = null;
+ private bool in_center_on_anchor = false;
+ private bool size_allocate_due_to_reflow = false;
+ private bool is_in_view = false;
+ private bool reflow_needed = false;
+
+ public CheckerboardLayout(ViewCollection view) {
+ this.view = view;
+
+ clear_drag_select();
+
+ // subscribe to the new collection
+ view.contents_altered.connect(on_contents_altered);
+ view.items_altered.connect(on_items_altered);
+ view.items_state_changed.connect(on_items_state_changed);
+ view.items_visibility_changed.connect(on_items_visibility_changed);
+ view.ordering_changed.connect(on_ordering_changed);
+ view.views_altered.connect(on_views_altered);
+ view.geometries_altered.connect(on_geometries_altered);
+ view.items_selected.connect(on_items_selection_changed);
+ view.items_unselected.connect(on_items_selection_changed);
+
+ override_background_color(Gtk.StateFlags.NORMAL, Config.Facade.get_instance().get_bg_color());
+
+ Config.Facade.get_instance().colors_changed.connect(on_colors_changed);
+
+ // CheckerboardItems offer tooltips
+ has_tooltip = true;
+ }
+
+ ~CheckerboardLayout() {
+#if TRACE_DTORS
+ debug("DTOR: CheckerboardLayout for %s", view.to_string());
+#endif
+
+ view.contents_altered.disconnect(on_contents_altered);
+ view.items_altered.disconnect(on_items_altered);
+ view.items_state_changed.disconnect(on_items_state_changed);
+ view.items_visibility_changed.disconnect(on_items_visibility_changed);
+ view.ordering_changed.disconnect(on_ordering_changed);
+ view.views_altered.disconnect(on_views_altered);
+ view.geometries_altered.disconnect(on_geometries_altered);
+ view.items_selected.disconnect(on_items_selection_changed);
+ view.items_unselected.disconnect(on_items_selection_changed);
+
+ if (hadjustment != null)
+ hadjustment.value_changed.disconnect(on_viewport_shifted);
+
+ if (vadjustment != null)
+ vadjustment.value_changed.disconnect(on_viewport_shifted);
+
+ if (parent != null)
+ parent.size_allocate.disconnect(on_viewport_resized);
+
+ Config.Facade.get_instance().colors_changed.disconnect(on_colors_changed);
+ }
+
+ public void set_adjustments(Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment) {
+ this.hadjustment = hadjustment;
+ this.vadjustment = vadjustment;
+
+ // monitor adjustment changes to report when the visible page shifts
+ hadjustment.value_changed.connect(on_viewport_shifted);
+ vadjustment.value_changed.connect(on_viewport_shifted);
+
+ // monitor parent's size changes for a similar reason
+ parent.size_allocate.connect(on_viewport_resized);
+ }
+
+ // This method allows for some optimizations to occur in reflow() by using the known max.
+ // width of all items in the layout.
+ public void set_scale(int scale) {
+ this.scale = scale;
+ }
+
+ public int get_scale() {
+ return scale;
+ }
+
+ public void set_name(string name) {
+ page_name = name;
+ }
+
+ private void on_viewport_resized() {
+ Gtk.Requisition req;
+ get_preferred_size(null, out req);
+
+ Gtk.Allocation parent_allocation;
+ parent.get_allocation(out parent_allocation);
+
+ if (message == null) {
+ // set the layout's new size to be the same as the parent's width but maintain
+ // it's own height
+#if TRACE_REFLOW
+ debug("on_viewport_resized: due_to_reflow=%s set_size_request %dx%d",
+ size_allocate_due_to_reflow.to_string(), parent_allocation.width, req.height);
+#endif
+ set_size_request(parent_allocation.width - SCROLLBAR_PLACEHOLDER_WIDTH, req.height);
+ } else {
+ // set the layout's width and height to always match the parent's
+ set_size_request(parent_allocation.width, parent_allocation.height);
+ }
+
+ // possible for this widget's size_allocate not to be called, so need to update the page
+ // rect here
+ viewport_resized();
+
+ if (!size_allocate_due_to_reflow)
+ clear_anchor();
+ else
+ size_allocate_due_to_reflow = false;
+ }
+
+ private void on_viewport_shifted() {
+ update_visible_page();
+ need_exposure("on_viewport_shift");
+
+ clear_anchor();
+ }
+
+ private void on_items_selection_changed() {
+ clear_anchor();
+ }
+
+ private void clear_anchor() {
+ if (in_center_on_anchor)
+ return;
+
+ anchor = null;
+ }
+
+ private void update_anchor() {
+ assert(!in_center_on_anchor);
+
+ Gee.List<CheckerboardItem> items_on_page = intersection(visible_page);
+ if (items_on_page.size == 0) {
+ anchor = null;
+ return;
+ }
+
+ foreach (CheckerboardItem item in items_on_page) {
+ if (item.is_selected()) {
+ anchor = item;
+ return;
+ }
+ }
+
+ if (vadjustment.get_value() == 0) {
+ anchor = null;
+ return;
+ }
+
+ // this could be improved to always find the visual center...in the case where only
+ // a few photos are in the last visible row, this can choose a photo near the right
+ anchor = items_on_page.get((int) items_on_page.size / 2);
+ }
+
+ private void center_on_anchor(double upper) {
+ if (anchor == null)
+ return;
+
+ in_center_on_anchor = true;
+
+ double anchor_pos = anchor.allocation.y + (anchor.allocation.height / 2) -
+ (vadjustment.get_page_size() / 2);
+ vadjustment.set_value(anchor_pos.clamp(vadjustment.get_lower(),
+ vadjustment.get_upper() - vadjustment.get_page_size()));
+
+ in_center_on_anchor = false;
+ }
+
+ public void set_cursor(CheckerboardItem item) {
+ Gee.HashSet<DataView> collection = new Gee.HashSet<DataView>();
+ if (cursor != null) {
+ cursor.set_is_cursor(false);
+ // Bug #732334, the cursor DataView might have disappeared when user drags a full screen Photo to another event
+ if (view.contains(cursor)) {
+ collection.add(cursor);
+ }
+ }
+ item.set_is_cursor(true);
+ cursor = item;
+ collection.add(item);
+ on_items_state_changed(collection);
+ }
+
+ public CheckerboardItem get_cursor() {
+ return cursor;
+ }
+
+
+ private void on_contents_altered(Gee.Iterable<DataObject>? added,
+ Gee.Iterable<DataObject>? removed) {
+ if (added != null)
+ message = null;
+
+ if (removed != null) {
+ foreach (DataObject object in removed)
+ exposed_items.remove((CheckerboardItem) object);
+ }
+
+ // release spatial data structure ... contents_altered means a reflow is required, and since
+ // items may be removed, this ensures we're not holding the ref on a removed view
+ item_rows = null;
+
+ need_reflow("on_contents_altered");
+ }
+
+ private void on_items_altered() {
+ need_reflow("on_items_altered");
+ }
+
+ private void on_items_state_changed(Gee.Iterable<DataView> changed) {
+ items_dirty("on_items_state_changed", changed);
+ }
+
+ private void on_items_visibility_changed(Gee.Iterable<DataView> changed) {
+ need_reflow("on_items_visibility_changed");
+ }
+
+ private void on_ordering_changed() {
+ need_reflow("on_ordering_changed");
+ }
+
+ private void on_views_altered(Gee.Collection<DataView> altered) {
+ items_dirty("on_views_altered", altered);
+ }
+
+ private void on_geometries_altered() {
+ need_reflow("on_geometries_altered");
+ }
+
+ private void need_reflow(string caller) {
+ if (flow_scheduled)
+ return;
+
+ if (!is_in_view) {
+ reflow_needed = true;
+ return;
+ }
+
+#if TRACE_REFLOW
+ debug("need_reflow %s: %s", page_name, caller);
+#endif
+ flow_scheduled = true;
+ Idle.add_full(Priority.HIGH, do_reflow);
+ }
+
+ private bool do_reflow() {
+ reflow("do_reflow");
+ need_exposure("do_reflow");
+
+ flow_scheduled = false;
+
+ return false;
+ }
+
+ private void need_exposure(string caller) {
+#if TRACE_REFLOW
+ debug("need_exposure %s: %s", page_name, caller);
+#endif
+ exposure_dirty = true;
+ queue_draw();
+ }
+
+ public void set_message(string? text) {
+ if (text == message)
+ return;
+
+ message = text;
+
+ if (text != null) {
+ // message is being set, change size to match parent's; if no parent, then the size
+ // will be set later when added to the parent
+ if (parent != null) {
+ Gtk.Allocation parent_allocation;
+ parent.get_allocation(out parent_allocation);
+
+ set_size_request(parent_allocation.width, parent_allocation.height);
+ }
+ } else {
+ // message is being cleared, layout all the items again
+ need_reflow("set_message");
+ }
+ }
+
+ public void unset_message() {
+ set_message(null);
+ }
+
+ private void update_visible_page() {
+ if (hadjustment != null && vadjustment != null)
+ visible_page = get_adjustment_page(hadjustment, vadjustment);
+ }
+
+ public void set_in_view(bool in_view) {
+ is_in_view = in_view;
+
+ if (in_view) {
+ if (reflow_needed)
+ need_reflow("set_in_view (true)");
+ else
+ need_exposure("set_in_view (true)");
+ } else
+ unexpose_items("set_in_view (false)");
+ }
+
+ public CheckerboardItem? get_item_at_pixel(double xd, double yd) {
+ if (message != null || item_rows == null)
+ return null;
+
+ int x = (int) xd;
+ int y = (int) yd;
+
+ // binary search the rows for the one in range of the pixel
+ LayoutRow in_range = null;
+ int min = 0;
+ int max = item_rows.length;
+ for(;;) {
+ int mid = min + ((max - min) / 2);
+ LayoutRow row = item_rows[mid];
+
+ if (row == null || y < row.y) {
+ // undershot
+ // row == null happens when there is an exact number of elements to fill the last row
+ max = mid - 1;
+ } else if (y > (row.y + row.height)) {
+ // undershot
+ min = mid + 1;
+ } else {
+ // bingo
+ in_range = row;
+
+ break;
+ }
+
+ if (min > max)
+ break;
+ }
+
+ if (in_range == null)
+ return null;
+
+ // look for item in row's column in range of the pixel
+ foreach (CheckerboardItem item in in_range.items) {
+ // this happens on an incompletely filled-in row (usually the last one with empty
+ // space remaining)
+ if (item == null)
+ continue;
+
+ if (x < item.allocation.x) {
+ // overshot ... this happens because there's gaps in the columns
+ break;
+ }
+
+ // need to verify actually over item's full dimensions, since they vary in size inside
+ // a row
+ if (x <= (item.allocation.x + item.allocation.width) && y >= item.allocation.y
+ && y <= (item.allocation.y + item.allocation.height))
+ return item;
+ }
+
+ return null;
+ }
+
+ public Gee.List<CheckerboardItem> get_visible_items() {
+ return intersection(visible_page);
+ }
+
+ public Gee.List<CheckerboardItem> intersection(Gdk.Rectangle area) {
+ Gee.ArrayList<CheckerboardItem> intersects = new Gee.ArrayList<CheckerboardItem>();
+
+ Gtk.Allocation allocation;
+ get_allocation(out allocation);
+
+ Gdk.Rectangle bitbucket = Gdk.Rectangle();
+ foreach (LayoutRow row in item_rows) {
+ if (row == null)
+ continue;
+
+ if ((area.y + area.height) < row.y) {
+ // overshoot
+ break;
+ }
+
+ if ((row.y + row.height) < area.y) {
+ // haven't reached it yet
+ continue;
+ }
+
+ // see if the row intersects the area
+ Gdk.Rectangle row_rect = Gdk.Rectangle();
+ row_rect.x = 0;
+ row_rect.y = row.y;
+ row_rect.width = allocation.width;
+ row_rect.height = row.height;
+
+ if (area.intersect(row_rect, out bitbucket)) {
+ // see what elements, if any, intersect the area
+ foreach (CheckerboardItem item in row.items) {
+ if (item == null)
+ continue;
+
+ if (area.intersect(item.allocation, out bitbucket))
+ intersects.add(item);
+ }
+ }
+ }
+
+ return intersects;
+ }
+
+ public CheckerboardItem? get_item_relative_to(CheckerboardItem item, CompassPoint point) {
+ if (view.get_count() == 0)
+ return null;
+
+ assert(columns > 0);
+ assert(rows > 0);
+
+ int col = item.get_column();
+ int row = item.get_row();
+
+ if (col < 0 || row < 0) {
+ critical("Attempting to locate item not placed in layout: %s", item.get_title());
+
+ return null;
+ }
+
+ switch (point) {
+ case CompassPoint.NORTH:
+ if (--row < 0)
+ row = 0;
+ break;
+
+ case CompassPoint.SOUTH:
+ if (++row >= rows)
+ row = rows - 1;
+ break;
+
+ case CompassPoint.EAST:
+ if (++col >= columns) {
+ if(++row >= rows) {
+ row = rows - 1;
+ col = columns - 1;
+ } else {
+ col = 0;
+ }
+ }
+ break;
+
+ case CompassPoint.WEST:
+ if (--col < 0) {
+ if (--row < 0) {
+ row = 0;
+ col = 0;
+ } else {
+ col = columns - 1;
+ }
+ }
+ break;
+
+ default:
+ error("Bad compass point %d", (int) point);
+ }
+
+ CheckerboardItem? new_item = get_item_at_coordinate(col, row);
+
+ if (new_item == null && point == CompassPoint.SOUTH) {
+ // nothing directly below, get last item on next row
+ new_item = (CheckerboardItem?) view.get_last();
+ if (new_item.get_row() <= item.get_row())
+ new_item = null;
+ }
+
+ return (new_item != null) ? new_item : item;
+ }
+
+ public CheckerboardItem? get_item_at_coordinate(int col, int row) {
+ if (row >= item_rows.length)
+ return null;
+
+ LayoutRow item_row = item_rows[row];
+ if (item_row == null)
+ return null;
+
+ if (col >= item_row.items.length)
+ return null;
+
+ return item_row.items[col];
+ }
+
+ public void set_drag_select_origin(int x, int y) {
+ clear_drag_select();
+
+ Gtk.Allocation allocation;
+ get_allocation(out allocation);
+
+ drag_origin.x = x.clamp(0, allocation.width);
+ drag_origin.y = y.clamp(0, allocation.height);
+ }
+
+ public void set_drag_select_endpoint(int x, int y) {
+ Gtk.Allocation allocation;
+ get_allocation(out allocation);
+
+ drag_endpoint.x = x.clamp(0, allocation.width);
+ drag_endpoint.y = y.clamp(0, allocation.height);
+
+ // drag_origin and drag_endpoint are maintained only to generate selection_band; all reporting
+ // and drawing functions refer to it, not drag_origin and drag_endpoint
+ Gdk.Rectangle old_selection_band = selection_band;
+ selection_band = Box.from_points(drag_origin, drag_endpoint).get_rectangle();
+
+ // force repaint of the union of the old and new, which covers the band reducing in size
+ if (get_window() != null) {
+ Gdk.Rectangle union;
+ selection_band.union(old_selection_band, out union);
+
+ queue_draw_area(union.x, union.y, union.width, union.height);
+ }
+ }
+
+ public Gee.List<CheckerboardItem>? items_in_selection_band() {
+ if (!Dimensions.for_rectangle(selection_band).has_area())
+ return null;
+
+ return intersection(selection_band);
+ }
+
+ public bool is_drag_select_active() {
+ return drag_origin.x >= 0 && drag_origin.y >= 0;
+ }
+
+ public void clear_drag_select() {
+ selection_band = Gdk.Rectangle();
+ drag_origin.x = -1;
+ drag_origin.y = -1;
+ drag_endpoint.x = -1;
+ drag_endpoint.y = -1;
+
+ // force a total repaint to clear the selection band
+ queue_draw();
+ }
+
+ private void viewport_resized() {
+ // update visible page rect
+ update_visible_page();
+
+ // only reflow() if the width has changed
+ if (visible_page.width != last_width) {
+ int old_width = last_width;
+ last_width = visible_page.width;
+
+ need_reflow("viewport_resized (%d -> %d)".printf(old_width, visible_page.width));
+ } else {
+ // don't need to reflow but exposure may have changed
+ need_exposure("viewport_resized (same width=%d)".printf(last_width));
+ }
+ }
+
+ private void expose_items(string caller) {
+ // create a new hash set of exposed items that represents an intersection of the old set
+ // and the new
+ Gee.HashSet<CheckerboardItem> new_exposed_items = new Gee.HashSet<CheckerboardItem>();
+
+ view.freeze_notifications();
+
+ Gee.List<CheckerboardItem> items = get_visible_items();
+ foreach (CheckerboardItem item in items) {
+ new_exposed_items.add(item);
+
+ // if not in the old list, then need to expose
+ if (!exposed_items.remove(item))
+ item.exposed();
+ }
+
+ // everything remaining in the old exposed list is now unexposed
+ foreach (CheckerboardItem item in exposed_items)
+ item.unexposed();
+
+ // swap out lists
+ exposed_items = new_exposed_items;
+ exposure_dirty = false;
+
+#if TRACE_REFLOW
+ debug("expose_items %s: exposed %d items, thawing", page_name, exposed_items.size);
+#endif
+ view.thaw_notifications();
+#if TRACE_REFLOW
+ debug("expose_items %s: thaw finished", page_name);
+#endif
+ }
+
+ private void unexpose_items(string caller) {
+ view.freeze_notifications();
+
+ foreach (CheckerboardItem item in exposed_items)
+ item.unexposed();
+
+ exposed_items.clear();
+ exposure_dirty = false;
+
+#if TRACE_REFLOW
+ debug("unexpose_items %s: thawing", page_name);
+#endif
+ view.thaw_notifications();
+#if TRACE_REFLOW
+ debug("unexpose_items %s: thawed", page_name);
+#endif
+ }
+
+ private void reflow(string caller) {
+ reflow_needed = false;
+
+ // if set in message mode, nothing to do here
+ if (message != null)
+ return;
+
+ Gtk.Allocation allocation;
+ get_allocation(out allocation);
+
+ int visible_width = (visible_page.width > 0) ? visible_page.width : allocation.width;
+
+#if TRACE_REFLOW
+ debug("reflow: Using visible page width of %d (allocated: %d)", visible_width,
+ allocation.width);
+#endif
+
+ // don't bother until layout is of some appreciable size (even this is too low)
+ if (visible_width <= 1)
+ return;
+
+ int total_items = view.get_count();
+
+ // need to set_size in case all items were removed and the viewport size has changed
+ if (total_items == 0) {
+ set_size_request(visible_width, 0);
+ item_rows = new LayoutRow[0];
+
+ return;
+ }
+
+#if TRACE_REFLOW
+ debug("reflow %s: %s (%d items)", page_name, caller, total_items);
+#endif
+
+ // look for anchor if there is none currently
+ if (anchor == null || !anchor.is_visible())
+ update_anchor();
+
+ // clear the rows data structure, as the reflow will completely rearrange it
+ item_rows = null;
+
+ // Step 1: Determine the widest row in the layout, and from it the number of columns.
+ // If owner supplies an image scaling for all items in the layout, then this can be
+ // calculated quickly.
+ int max_cols = 0;
+ if (scale > 0) {
+ // calculate interior width
+ int remaining_width = visible_width - (COLUMN_GUTTER_PADDING * 2);
+ int max_item_width = CheckerboardItem.get_max_width(scale);
+ max_cols = remaining_width / max_item_width;
+ if (max_cols <= 0)
+ max_cols = 1;
+
+ // if too large with gutters, decrease until columns fit
+ while (max_cols > 1
+ && ((max_cols * max_item_width) + ((max_cols - 1) * COLUMN_GUTTER_PADDING) > remaining_width)) {
+#if TRACE_REFLOW
+ debug("reflow %s: scaled cols estimate: reducing max_cols from %d to %d", page_name,
+ max_cols, max_cols - 1);
+#endif
+ max_cols--;
+ }
+
+ // special case: if fewer items than columns, they are the columns
+ if (total_items < max_cols)
+ max_cols = total_items;
+
+#if TRACE_REFLOW
+ debug("reflow %s: scaled cols estimate: max_cols=%d remaining_width=%d max_item_width=%d",
+ page_name, max_cols, remaining_width, max_item_width);
+#endif
+ } else {
+ int x = COLUMN_GUTTER_PADDING;
+ int col = 0;
+ int row_width = 0;
+ int widest_row = 0;
+
+ for (int ctr = 0; ctr < total_items; ctr++) {
+ CheckerboardItem item = (CheckerboardItem) view.get_at(ctr);
+ Dimensions req = item.requisition;
+
+ // the items must be requisitioned for this code to work
+ assert(req.has_area());
+
+ // carriage return (i.e. this item will overflow the view)
+ if ((x + req.width + COLUMN_GUTTER_PADDING) > visible_width) {
+ if (row_width > widest_row) {
+ widest_row = row_width;
+ max_cols = col;
+ }
+
+ col = 0;
+ x = COLUMN_GUTTER_PADDING;
+ row_width = 0;
+ }
+
+ x += req.width + COLUMN_GUTTER_PADDING;
+ row_width += req.width;
+
+ col++;
+ }
+
+ // account for dangling last row
+ if (row_width > widest_row)
+ max_cols = col;
+
+#if TRACE_REFLOW
+ debug("reflow %s: manual cols estimate: max_cols=%d widest_row=%d", page_name, max_cols,
+ widest_row);
+#endif
+ }
+
+ assert(max_cols > 0);
+ int max_rows = (total_items / max_cols) + 1;
+
+ // Step 2: Now that the number of columns is known, find the maximum height for each row
+ // and the maximum width for each column
+ int row = 0;
+ int tallest = 0;
+ int widest = 0;
+ int row_alignment_point = 0;
+ int total_width = 0;
+ int col = 0;
+ int[] column_widths = new int[max_cols];
+ int[] row_heights = new int[max_rows];
+ int[] alignment_points = new int[max_rows];
+ int gutter = 0;
+
+ for (;;) {
+ for (int ctr = 0; ctr < total_items; ctr++ ) {
+ CheckerboardItem item = (CheckerboardItem) view.get_at(ctr);
+ Dimensions req = item.requisition;
+ int alignment_point = item.get_alignment_point();
+
+ // alignment point better be sane
+ assert(alignment_point < req.height);
+
+ if (req.height > tallest)
+ tallest = req.height;
+
+ if (req.width > widest)
+ widest = req.width;
+
+ if (alignment_point > row_alignment_point)
+ row_alignment_point = alignment_point;
+
+ // store largest thumb size of each column as well as track the total width of the
+ // layout (which is the sum of the width of each column)
+ if (column_widths[col] < req.width) {
+ total_width -= column_widths[col];
+ column_widths[col] = req.width;
+ total_width += req.width;
+ }
+
+ if (++col >= max_cols) {
+ alignment_points[row] = row_alignment_point;
+ row_heights[row++] = tallest;
+
+ col = 0;
+ row_alignment_point = 0;
+ tallest = 0;
+ }
+ }
+
+ // account for final dangling row
+ if (col != 0) {
+ alignment_points[row] = row_alignment_point;
+ row_heights[row] = tallest;
+ }
+
+ // Step 3: Calculate the gutter between the items as being equidistant of the
+ // remaining space (adding one gutter to account for the right-hand one)
+ gutter = (visible_width - total_width) / (max_cols + 1);
+
+ // if only one column, gutter size could be less than minimums
+ if (max_cols == 1)
+ break;
+
+ // have to reassemble if the gutter is too small ... this happens because Step One
+ // takes a guess at the best column count, but when the max. widths of the columns are
+ // added up, they could overflow
+ if (gutter < COLUMN_GUTTER_PADDING) {
+ max_cols--;
+ max_rows = (total_items / max_cols) + 1;
+
+#if TRACE_REFLOW
+ debug("reflow %s: readjusting columns: alloc.width=%d total_width=%d widest=%d gutter=%d max_cols now=%d",
+ page_name, visible_width, total_width, widest, gutter, max_cols);
+#endif
+
+ col = 0;
+ row = 0;
+ tallest = 0;
+ widest = 0;
+ total_width = 0;
+ row_alignment_point = 0;
+ column_widths = new int[max_cols];
+ row_heights = new int[max_rows];
+ alignment_points = new int[max_rows];
+ } else {
+ break;
+ }
+ }
+
+#if TRACE_REFLOW
+ debug("reflow %s: width:%d total_width:%d max_cols:%d gutter:%d", page_name, visible_width,
+ total_width, max_cols, gutter);
+#endif
+
+ // Step 4: Recalculate the height of each row according to the row's alignment point (which
+ // may cause shorter items to extend below the bottom of the tallest one, extending the
+ // height of the row)
+ col = 0;
+ row = 0;
+
+ for (int ctr = 0; ctr < total_items; ctr++) {
+ CheckerboardItem item = (CheckerboardItem) view.get_at(ctr);
+ Dimensions req = item.requisition;
+
+ // this determines how much padding the item requires to be bottom-alignment along the
+ // alignment point; add to the height and you have the item's "true" height on the
+ // laid-down row
+ int true_height = req.height + (alignment_points[row] - item.get_alignment_point());
+ assert(true_height >= req.height);
+
+ // add that to its height to determine it's actual height on the laid-down row
+ if (true_height > row_heights[row]) {
+#if TRACE_REFLOW
+ debug("reflow %s: Adjusting height of row %d from %d to %d", page_name, row,
+ row_heights[row], true_height);
+#endif
+ row_heights[row] = true_height;
+ }
+
+ // carriage return
+ if (++col >= max_cols) {
+ col = 0;
+ row++;
+ }
+ }
+
+ // for the spatial structure
+ item_rows = new LayoutRow[max_rows];
+
+ // Step 5: Lay out the items in the space using all the information gathered
+ int x = gutter;
+ int y = TOP_PADDING;
+ col = 0;
+ row = 0;
+ LayoutRow current_row = null;
+
+ for (int ctr = 0; ctr < total_items; ctr++) {
+ CheckerboardItem item = (CheckerboardItem) view.get_at(ctr);
+ Dimensions req = item.requisition;
+
+ // this centers the item in the column
+ int xpadding = (column_widths[col] - req.width) / 2;
+ assert(xpadding >= 0);
+
+ // this bottom-aligns the item along the discovered alignment point
+ int ypadding = alignment_points[row] - item.get_alignment_point();
+ assert(ypadding >= 0);
+
+ // save pixel and grid coordinates
+ item.allocation.x = x + xpadding;
+ item.allocation.y = y + ypadding;
+ item.allocation.width = req.width;
+ item.allocation.height = req.height;
+ item.set_grid_coordinates(col, row);
+
+ // add to current row in spatial data structure
+ if (current_row == null)
+ current_row = new LayoutRow(y, row_heights[row], max_cols);
+
+ current_row.items[col] = item;
+
+ x += column_widths[col] + gutter;
+
+ // carriage return
+ if (++col >= max_cols) {
+ assert(current_row != null);
+ item_rows[row] = current_row;
+ current_row = null;
+
+ x = gutter;
+ y += row_heights[row] + ROW_GUTTER_PADDING;
+ col = 0;
+ row++;
+ }
+ }
+
+ // add last row to spatial data structure
+ if (current_row != null)
+ item_rows[row] = current_row;
+
+ // save dimensions of checkerboard
+ columns = max_cols;
+ rows = row + 1;
+ assert(rows == max_rows);
+
+ // Step 6: Define the total size of the page as the size of the visible width (to avoid
+ // the horizontal scrollbar from appearing) and the height of all the items plus padding
+ int total_height = y + row_heights[row] + BOTTOM_PADDING;
+ if (visible_width != allocation.width || total_height != allocation.height) {
+#if TRACE_REFLOW
+ debug("reflow %s: Changing layout dimensions from %dx%d to %dx%d", page_name,
+ allocation.width, allocation.height, visible_width, total_height);
+#endif
+ set_size_request(visible_width, total_height);
+ size_allocate_due_to_reflow = true;
+
+ // when height changes, center on the anchor to minimize amount of visual change
+ center_on_anchor(total_height);
+ }
+ }
+
+ private void items_dirty(string reason, Gee.Iterable<DataView> items) {
+ Gdk.Rectangle dirty = Gdk.Rectangle();
+ foreach (DataView data_view in items) {
+ CheckerboardItem item = (CheckerboardItem) data_view;
+
+ if (!item.is_visible())
+ continue;
+
+ assert(view.contains(item));
+
+ // if not allocated, need to reflow the entire layout; don't bother queueing a draw
+ // for any of these, reflow will handle that
+ if (item.allocation.width <= 0 || item.allocation.height <= 0) {
+ need_reflow("items_dirty: %s".printf(reason));
+
+ return;
+ }
+
+ // only mark area as dirty if visible in viewport
+ Gdk.Rectangle intersection = Gdk.Rectangle();
+ if (!visible_page.intersect(item.allocation, out intersection))
+ continue;
+
+ // grow the dirty area
+ if (dirty.width == 0 || dirty.height == 0)
+ dirty = intersection;
+ else
+ dirty.union(intersection, out dirty);
+ }
+
+ if (dirty.width > 0 && dirty.height > 0) {
+#if TRACE_REFLOW
+ debug("items_dirty %s (%s): Queuing draw of dirty area %s on visible_page %s",
+ page_name, reason, rectangle_to_string(dirty), rectangle_to_string(visible_page));
+#endif
+ queue_draw_area(dirty.x, dirty.y, dirty.width, dirty.height);
+ }
+ }
+
+ public override void map() {
+ base.map();
+
+ set_colors();
+ }
+
+ private void set_colors(bool in_focus = true) {
+ // set up selected/unselected colors
+ selected_color = Config.Facade.get_instance().get_selected_color(in_focus);
+ unselected_color = Config.Facade.get_instance().get_unselected_color();
+ border_color = Config.Facade.get_instance().get_border_color();
+ bg_color = get_style_context().get_background_color(Gtk.StateFlags.NORMAL);
+ }
+
+ public override void size_allocate(Gtk.Allocation allocation) {
+ base.size_allocate(allocation);
+
+ viewport_resized();
+ }
+
+ public override bool draw(Cairo.Context ctx) {
+ // Note: It's possible for draw to be called when in_view is false; this happens
+ // when pages are switched prior to switched_to() being called, and some of the other
+ // controls allow for events to be processed while they are orienting themselves. Since
+ // we want switched_to() to be the final call in the process (indicating that the page is
+ // now in place and should do its thing to update itself), have to be be prepared for
+ // GTK/GDK calls between the widgets being actually present on the screen and "switched to"
+
+ // watch for message mode
+ if (message == null) {
+#if TRACE_REFLOW
+ debug("draw %s: %s", page_name, rectangle_to_string(visible_page));
+#endif
+
+ if (exposure_dirty)
+ expose_items("draw");
+
+ // have all items in the exposed area paint themselves
+ foreach (CheckerboardItem item in intersection(visible_page)) {
+ item.paint(ctx, bg_color, item.is_selected() ? selected_color : unselected_color,
+ unselected_color, border_color);
+ }
+ } else {
+ // draw the message in the center of the window
+ Pango.Layout pango_layout = create_pango_layout(message);
+ int text_width, text_height;
+ pango_layout.get_pixel_size(out text_width, out text_height);
+
+ Gtk.Allocation allocation;
+ get_allocation(out allocation);
+
+ int x = allocation.width - text_width;
+ x = (x > 0) ? x / 2 : 0;
+
+ int y = allocation.height - text_height;
+ y = (y > 0) ? y / 2 : 0;
+
+ ctx.set_source_rgb(unselected_color.red, unselected_color.green, unselected_color.blue);
+ ctx.move_to(x, y);
+ Pango.cairo_show_layout(ctx, pango_layout);
+ }
+
+ bool result = (base.draw != null) ? base.draw(ctx) : true;
+
+ // draw the selection band last, so it appears floating over everything else
+ draw_selection_band(ctx);
+
+ return result;
+ }
+
+ private void draw_selection_band(Cairo.Context ctx) {
+ // no selection band, nothing to draw
+ if (selection_band.width <= 1 || selection_band.height <= 1)
+ return;
+
+ // This requires adjustments
+ if (hadjustment == null || vadjustment == null)
+ return;
+
+ // find the visible intersection of the viewport and the selection band
+ Gdk.Rectangle visible_page = get_adjustment_page(hadjustment, vadjustment);
+ Gdk.Rectangle visible_band = Gdk.Rectangle();
+ visible_page.intersect(selection_band, out visible_band);
+
+ // pixelate selection rectangle interior
+ if (visible_band.width > 1 && visible_band.height > 1) {
+ ctx.set_source_rgba(selected_color.red, selected_color.green, selected_color.blue,
+ SELECTION_ALPHA);
+ ctx.rectangle(visible_band.x, visible_band.y, visible_band.width,
+ visible_band.height);
+ ctx.fill();
+ }
+
+ // border
+ // See this for an explanation of the adjustments to the band's dimensions
+ // http://cairographics.org/FAQ/#sharp_lines
+ ctx.set_line_width(1.0);
+ ctx.set_line_cap(Cairo.LineCap.SQUARE);
+ ctx.set_source_rgb(selected_color.red, selected_color.green, selected_color.blue);
+ ctx.rectangle((double) selection_band.x + 0.5, (double) selection_band.y + 0.5,
+ (double) selection_band.width - 1.0, (double) selection_band.height - 1.0);
+ ctx.stroke();
+ }
+
+ public override bool query_tooltip(int x, int y, bool keyboard_mode, Gtk.Tooltip tooltip) {
+ CheckerboardItem? item = get_item_at_pixel(x, y);
+
+ return (item != null) ? item.query_tooltip(x, y, tooltip) : false;
+ }
+
+ private void on_colors_changed() {
+ override_background_color(Gtk.StateFlags.NORMAL, Config.Facade.get_instance().get_bg_color());
+ set_colors();
+ }
+
+ public override bool focus_in_event(Gdk.EventFocus event) {
+ set_colors(true);
+ items_dirty("focus_in_event", view.get_selected());
+
+ return base.focus_in_event(event);
+ }
+
+ public override bool focus_out_event(Gdk.EventFocus event) {
+ set_colors(false);
+ items_dirty("focus_out_event", view.get_selected());
+
+ return base.focus_out_event(event);
+ }
+}