static void
hippo_canvas_block_init(HippoCanvasBlock *block)
{
block->expandable = TRUE;
block->linkify_title = TRUE;
HIPPO_CANVAS_BOX(block)->border_left = 1;
HIPPO_CANVAS_BOX(block)->border_right = 1;
HIPPO_CANVAS_BOX(block)->border_top = 1;
HIPPO_CANVAS_BOX(block)->border_bottom = 1;
HIPPO_CANVAS_BOX(block)->border_color_rgba = 0xffffffff;
}
void
hippo_canvas_open_test_window(void)
{
GtkWidget *window;
GtkWidget *canvas;
HippoCanvasItem *root;
HippoCanvasItem *shape1;
HippoCanvasItem *shape2;
int i;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
canvas = hippo_canvas_new();
gtk_widget_show(canvas);
gtk_container_add(GTK_CONTAINER(window), canvas);
root = HIPPO_CANVAS_ITEM(hippo_canvas_box_new());
#if 0
shape1 = g_object_new(HIPPO_TYPE_CANVAS_SHAPE,
"width", 50, "height", 100,
NULL);
shape2 = g_object_new(HIPPO_TYPE_CANVAS_SHAPE,
"width", 70, "height", 40,
"color", 0x00ff00ff,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(root),
shape1, 0);
g_object_unref(shape1);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(root),
shape2, 0);
g_object_unref(shape2);
#endif
for (i = 0; i < (int) G_N_ELEMENTS(box_rows); ++i) {
HippoCanvasItem *row = create_row(box_rows[i]);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(root), row, 0);
g_object_unref(row);
}
hippo_canvas_set_root(HIPPO_CANVAS(canvas), root);
g_object_unref(root);
gtk_widget_show(window);
}
void
hippo_canvas_stack_update_hidden_blocks(HippoCanvasStack *canvas_stack)
{
UpdateHiddenData uhd;
/* The algorithm here isn't efficient; we walk through the entire
* stack each time a block is added or restacked and accumulate
* the set of music tracks that have been chatted on. Any music person
* block about these tracks that occurs after the music chat block
* is suppressed. This makes initial construction of the stack
* an O(N^2) operation, though the individual walks are pretty
* fast.
*
* A more efficient thing to do would be to keep a permanent list
* of chatted track ids for the stack, and update visibility only
* when a new track is added to that list or a music person block
* is restacked (and thus has a new play id).
*/
uhd.canvas_stack = canvas_stack;
uhd.chatted = g_hash_table_new(g_str_hash, g_str_equal);
hippo_canvas_box_foreach(HIPPO_CANVAS_BOX(canvas_stack),
foreach_update_hidden,
&uhd);
g_hash_table_destroy(uhd.chatted);
}
static void
set_surface_from_name(HippoCanvasImage *image)
{
if (image->image_name == NULL) {
set_surface(image, NULL);
} else {
cairo_surface_t *surface;
HippoCanvasContext *context;
context = hippo_canvas_box_get_context(HIPPO_CANVAS_BOX(image));
/* If context is NULL, we'll call set_surface_from_name again
* when a new context is set
*/
if (context != NULL) {
/* may return NULL */
surface = hippo_canvas_context_load_image(context,
image->image_name);
set_surface(image, surface);
if (surface != NULL)
cairo_surface_destroy(surface);
} else {
set_surface(image, NULL);
}
}
}
static void
hippo_canvas_control_set_context(HippoCanvasItem *item,
HippoCanvasContext *context)
{
HippoCanvasBox *box = HIPPO_CANVAS_BOX(item);
if (context == box->context)
return;
if (box->context) {
hippo_canvas_context_unregister_widget_item(box->context, item);
g_signal_handlers_disconnect_by_func(box->context,
(gpointer)on_context_style_changed,
context);
}
/* chain up, which invalidates our old context */
item_parent_class->set_context(item, context);
if (box->context) {
hippo_canvas_context_register_widget_item(box->context, item);
g_signal_connect(box->context, "style-changed",
G_CALLBACK(on_context_style_changed), item);
}
on_context_style_changed(context, TRUE, HIPPO_CANVAS_CONTROL(item));
}
/* this is analogous to what pygtk does for GtkObject, GtkWindow, etc.
* but it just has to be a bug in pygtk that it works this way.
*/
static void
sink_hippocanvasbox(GObject *object)
{
if (HIPPO_CANVAS_BOX(object)->floating) {
g_object_ref(object);
hippo_canvas_item_sink(HIPPO_CANVAS_ITEM(object));
}
}
static GObject*
hippo_canvas_chat_preview_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *object = G_OBJECT_CLASS(hippo_canvas_chat_preview_parent_class)->constructor(type,
n_construct_properties,
construct_properties);
HippoCanvasChatPreview *chat_preview = HIPPO_CANVAS_CHAT_PREVIEW(object);
HippoCanvasBox *box;
HippoCanvasItem *item;
int i;
for (i = 0; i < MAX_PREVIEWED; ++i) {
chat_preview->message_previews[i] = g_object_new(HIPPO_TYPE_CANVAS_MESSAGE_PREVIEW,
"actions", chat_preview->actions,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(chat_preview),
chat_preview->message_previews[i],
0);
}
box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_HORIZONTAL,
"color", HIPPO_CANVAS_BLOCK_GRAY_TEXT_COLOR,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(chat_preview), HIPPO_CANVAS_ITEM(box), 0);
item = g_object_new(HIPPO_TYPE_CANVAS_LINK,
"tooltip", "View all quips and comments",
NULL);
chat_preview->chat_link = item;
hippo_canvas_box_append(box, item, 0);
g_signal_connect(G_OBJECT(item), "activated",
G_CALLBACK(on_chat_activated), chat_preview);
update_chat_messages_count(chat_preview);
update_chat_messages(chat_preview);
hippo_canvas_chat_preview_update_visibility(chat_preview);
return object;
}
static void
hippo_canvas_link_init(HippoCanvasLink *link)
{
HippoCanvasBox *box = HIPPO_CANVAS_BOX(link);
hippo_canvas_box_set_link_type(box, HIPPO_CANVAS_LINK_LINK);
hippo_canvas_box_set_clickable(box, TRUE);
}
HippoCanvasItem*
hippo_canvas_stack_new(void)
{
HippoCanvasStack *stack = g_object_new(HIPPO_TYPE_CANVAS_STACK, NULL);
HIPPO_CANVAS_BOX(stack)->background_color_rgba = 0xffffffff;
return HIPPO_CANVAS_ITEM(stack);
}
static GObject*
hippo_canvas_filter_area_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *object = G_OBJECT_CLASS(hippo_canvas_filter_area_parent_class)->constructor(type,
n_construct_properties,
construct_properties);
HippoCanvasFilterArea *area = HIPPO_CANVAS_FILTER_AREA(object);
HippoCanvasItem *item;
HippoCanvasBox *box;
box = g_object_new(HIPPO_TYPE_CANVAS_IMAGE,
"orientation", HIPPO_ORIENTATION_HORIZONTAL,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(area),
HIPPO_CANVAS_ITEM(box), 0);
box->background_color_rgba = 0xE4D0EDFF;
item = g_object_new(HIPPO_TYPE_CANVAS_TEXT,
"text", "Hide feeds: ",
"padding-left", 4,
"xalign", HIPPO_ALIGNMENT_START,
NULL);
hippo_canvas_box_append(box, item, 0);
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE_BUTTON,
"normal-image-name", "checkbox",
"xalign", HIPPO_ALIGNMENT_START,
"yalign", HIPPO_ALIGNMENT_CENTER,
"tooltip", "Whether or not to display group feed items",
NULL);
hippo_canvas_box_append(box, item, 0);
g_signal_connect(G_OBJECT(item), "activated", G_CALLBACK(on_nofeed_activated), area);
area->nofeed_item = item;
item = g_object_new(HIPPO_TYPE_CANVAS_TEXT,
"text", "Hide my items: ",
"padding-left", 40,
"xalign", HIPPO_ALIGNMENT_START,
NULL);
hippo_canvas_box_append(box, item, 0);
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE_BUTTON,
"normal-image-name", "checkbox",
"xalign", HIPPO_ALIGNMENT_START,
"yalign", HIPPO_ALIGNMENT_CENTER,
"tooltip", "Whether or not to show items from me",
NULL);
hippo_canvas_box_append(box, item, 0);
g_signal_connect(G_OBJECT(item), "activated", G_CALLBACK(on_noselfsource_activated), area);
area->noselfsource_item = item;
return object;
}
static void
remove_extra_children(HippoCanvasStack *canvas_stack)
{
if (canvas_stack->max_blocks < G_MAXINT) {
GList *children;
int count;
children = hippo_canvas_box_get_children(HIPPO_CANVAS_BOX(canvas_stack));
count = g_list_length(children);
if (count > canvas_stack->max_blocks)
children = g_list_reverse(children);
while (count > canvas_stack->max_blocks) {
g_assert(children != NULL);
hippo_canvas_box_remove(HIPPO_CANVAS_BOX(canvas_stack), children->data);
children = g_list_remove(children, children->data);
--count;
}
g_list_free(children);
}
}
void
hippo_canvas_stack_add_block(HippoCanvasStack *canvas_stack,
HippoBlock *block,
gboolean visible)
{
HippoCanvasItem *item;
gint64 sort_timestamp;
sort_timestamp = hippo_block_get_sort_timestamp(block);
if (sort_timestamp < canvas_stack->min_timestamp)
return;
item = find_block_item(canvas_stack, block);
if (item != NULL) {
g_object_ref(item);
hippo_canvas_box_remove(HIPPO_CANVAS_BOX(canvas_stack), item);
} else {
item = hippo_canvas_block_new(hippo_block_get_block_type(block),
canvas_stack->actions);
g_object_ref(item);
}
g_object_set(G_OBJECT(item), "block", block, NULL);
hippo_canvas_box_insert_sorted(HIPPO_CANVAS_BOX(canvas_stack), item, 0,
canvas_block_compare, canvas_stack);
hippo_canvas_box_set_child_visible(HIPPO_CANVAS_BOX(canvas_stack), item, visible);
remove_extra_children(canvas_stack);
g_object_unref(item);
/* Updating possibly visible blocks at this point doesn't take
* into account the possibility of a block changing in such a way
* to cause other blocks to be hidden without being restacked;
* (for example, a MUSIC_CHAT block changing play_id to match
* a MUSIC_PERSON block further down the stack). This is unlikely
* to happen currently.
*/
hippo_canvas_stack_update_hidden_blocks(canvas_stack);
}
static HippoCanvasItem*
create_row(BoxAttrs *boxes)
{
HippoCanvasItem *row;
int i;
row = g_object_new(HIPPO_TYPE_CANVAS_BOX, "orientation", HIPPO_ORIENTATION_HORIZONTAL, NULL);
for (i = 0; boxes[i].width > 0; ++i) {
BoxAttrs *attrs = &boxes[i];
HippoCanvasItem *shape;
HippoCanvasItem *label;
const char *text;
shape = g_object_new(HIPPO_TYPE_CANVAS_SHAPE,
"width", attrs->width,
"height", attrs->height,
"color", attrs->color,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(row), shape, attrs->flags);
g_object_unref(shape);
if (attrs->flags == (HIPPO_PACK_END | HIPPO_PACK_EXPAND))
text = "END | EXPAND";
else if (attrs->flags == HIPPO_PACK_END)
text = "END";
else if (attrs->flags == HIPPO_PACK_EXPAND)
text = "EXPAND";
else
text = "0";
label = g_object_new(HIPPO_TYPE_CANVAS_TEXT,
"text", text,
"background-color", 0x0000ff00,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(shape), label, HIPPO_PACK_EXPAND);
g_object_unref(label);
}
return row;
}
void
hippo_canvas_stack_set_min_timestamp(HippoCanvasStack *canvas_stack,
gint64 min_timestamp)
{
if (canvas_stack->min_timestamp == min_timestamp)
return;
canvas_stack->min_timestamp = min_timestamp;
hippo_canvas_box_foreach(HIPPO_CANVAS_BOX(canvas_stack),
foreach_update_min_timestamp,
canvas_stack);
}
static void
hippo_canvas_image_set_context(HippoCanvasItem *item,
HippoCanvasContext *context)
{
HippoCanvasImage *image = HIPPO_CANVAS_IMAGE(item);
HippoCanvasBox *box = HIPPO_CANVAS_BOX(item);
HippoCanvasContext *old = box->context;
item_parent_class->set_context(item, context);
if (old != box->context && image->image_name != NULL)
set_surface_from_name(image);
}
static HippoCanvasItem*
create_test_click_release_root(void)
{
HippoCanvasItem *box;
HippoCanvasItem *text;
box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_HORIZONTAL,
"border", 4,
"border-color", 0x000000ff,
"padding", 10,
"background-color", 0xffffffff,
"spacing", 10,
NULL);
text = g_object_new(HIPPO_TYPE_CANVAS_LINK,
"size-mode", HIPPO_CANVAS_SIZE_ELLIPSIZE_END,
"text", "Click Me!",
"background-color", 0xffaaaaff,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(box), text, 0);
g_signal_connect(G_OBJECT(text), "activated", G_CALLBACK(on_item_activated), NULL);
text = g_object_new(HIPPO_TYPE_CANVAS_LINK,
"size-mode", HIPPO_CANVAS_SIZE_ELLIPSIZE_END,
"text", "Click Me!",
"background-color", 0x00aaffff,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(box), text, 0);
g_signal_connect(G_OBJECT(text), "activated", G_CALLBACK(on_item_activated), NULL);
return box;
}
void
hippo_canvas_stack_remove_block(HippoCanvasStack *canvas_stack,
HippoBlock *block)
{
HippoCanvasItem *item;
item = find_block_item(canvas_stack, block);
if (item != NULL) {
g_object_set(G_OBJECT(item),
"block", NULL,
NULL);
hippo_canvas_box_remove(HIPPO_CANVAS_BOX(canvas_stack), item);
}
}
static HippoCanvasItem*
find_block_item(HippoCanvasStack *canvas_stack,
HippoBlock *block)
{
FindItemData fid;
fid.block = block;
fid.found = NULL;
hippo_canvas_box_foreach(HIPPO_CANVAS_BOX(canvas_stack),
foreach_find_item,
&fid);
return fid.found;
}
static void
hippo_canvas_link_set_visited(HippoCanvasLink *link,
gboolean visited)
{
visited = visited != FALSE;
if (visited != link->visited) {
HippoCanvasBox *box = HIPPO_CANVAS_BOX(link);
link->visited = visited;
hippo_canvas_box_set_link_type(box,
visited ? HIPPO_CANVAS_LINK_VISITED : HIPPO_CANVAS_LINK_LINK);
}
}
static void
foreach_update_min_timestamp(HippoCanvasItem *child,
void *data)
{
HippoCanvasStack *stack = data;
HippoBlock *child_block = NULL;
gint64 sort_timestamp;
g_object_get(G_OBJECT(child), "block", &child_block, NULL);
sort_timestamp = hippo_block_get_sort_timestamp(child_block);
if (sort_timestamp < stack->min_timestamp)
hippo_canvas_box_remove(HIPPO_CANVAS_BOX(stack), child);
g_object_unref(child_block);
}
static gboolean
notification_is_needed(StackManager *manager)
{
NotificationNeededInfo info;
info.manager = manager;
info.is_needed = FALSE;
g_debug("Checking if notification is needed\n");
hippo_canvas_box_foreach(HIPPO_CANVAS_BOX(manager->notification_item),
notification_is_needed_callback,
&info);
return info.is_needed;
}
static void
hippo_canvas_widget_set_context(HippoCanvasItem *item,
HippoCanvasContext *context)
{
HippoCanvasBox *box = HIPPO_CANVAS_BOX(item);
if (context == box->context)
return;
if (box->context)
hippo_canvas_context_unregister_widget_item(box->context, item);
/* chain up, which invalidates our old context */
item_parent_class->set_context(item, context);
if (box->context)
hippo_canvas_context_register_widget_item(box->context, item);
}
static void
foreach_update_hidden(HippoCanvasItem *child,
void *data)
{
UpdateHiddenData *uhd = data;
HippoBlock *child_block = NULL;
g_object_get(G_OBJECT(child), "block", &child_block, NULL);
if (HIPPO_IS_BLOCK_MUSIC_CHAT(child_block)) {
const char *play_id = NULL;
HippoTrack *track = NULL;
g_object_get(child_block, "track", &track, NULL);
if (track) {
play_id = hippo_track_get_play_id(track);
g_object_unref(track);
}
if (play_id)
g_hash_table_insert(uhd->chatted, (void *)play_id, GUINT_TO_POINTER(1));
} else if (HIPPO_IS_BLOCK_MUSIC_PERSON(child_block)) {
const char *play_id = NULL;
GSList *track_history = NULL;
gboolean seen_track = FALSE;
g_object_get(child_block, "track_history", &track_history, NULL);
if (track_history) {
HippoTrack *track = track_history->data;
play_id = hippo_track_get_play_id(track);
}
if (play_id)
seen_track = g_hash_table_lookup(uhd->chatted, play_id) != NULL;
hippo_canvas_box_set_child_visible(HIPPO_CANVAS_BOX(uhd->canvas_stack),
child, !seen_track);
}
if (child_block)
g_object_unref(child_block);
}
static void
hippo_canvas_widget_allocate(HippoCanvasItem *item,
int width,
int height,
gboolean origin_changed)
{
int x, y, w, h;
int widget_x, widget_y;
GtkAllocation child_allocation;
HippoCanvasWidget *widget;
HippoCanvasBox *box;
widget = HIPPO_CANVAS_WIDGET(item);
box = HIPPO_CANVAS_BOX(item);
/* get the box set up */
item_parent_class->allocate(item, width, height, origin_changed);
if (widget->widget == NULL)
return;
/* this probably queues a resize, which is not ideal */
update_widget_visibility(widget);
/* Now do the GTK allocation for the child widget */
w = widget->widget->requisition.width;
h = widget->widget->requisition.height;
hippo_canvas_box_align(box, w, h, &x, &y, &w, &h);
widget_x = 0;
widget_y = 0;
if (box->context)
hippo_canvas_context_translate_to_widget(box->context, item,
&widget_x, &widget_y);
child_allocation.x = widget_x + x;
child_allocation.y = widget_y + y;
child_allocation.width = MAX(w, 1);
child_allocation.height = MAX(h, 1);
gtk_widget_size_allocate(widget->widget, &child_allocation);
}
static char *
hippo_canvas_text_get_tooltip (HippoCanvasItem *item,
int x,
int y,
HippoRectangle *for_area)
{
HippoCanvasText *text = HIPPO_CANVAS_TEXT(item);
HippoCanvasBox *box = HIPPO_CANVAS_BOX(item);
if (text->is_ellipsized && text->text) {
for_area->x = 0;
for_area->y = 0;
for_area->width = box->allocated_width;
for_area->height = box->allocated_height;
return g_strdup(text->text);
} else
return item_parent_class->get_tooltip(item, x, y, for_area);
}
static void
hippo_canvas_text_set_context(HippoCanvasItem *item,
HippoCanvasContext *context)
{
HippoCanvasBox *box = HIPPO_CANVAS_BOX(item);
gboolean changed;
changed = context != box->context;
item_parent_class->set_context(item, context);
/* we can't create a layout until we have a context,
* so we have to queue a size change when the context
* is set.
*/
if (changed) {
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(item));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(item), 0, 0, -1, -1);
}
}
static void
hippo_canvas_widget_allocate(HippoCanvasItem *item,
int width,
int height,
gboolean origin_changed)
{
int x, y, w, h;
int widget_x, widget_y;
GtkAllocation child_allocation;
HippoCanvasWidget *widget;
HippoCanvasBox *box;
widget = HIPPO_CANVAS_WIDGET(item);
box = HIPPO_CANVAS_BOX(item);
/* get the box set up */
item_parent_class->allocate(item, width, height, origin_changed);
/* Now do the GTK allocation for the child widget */
if (widget->widget == NULL || !GTK_WIDGET_VISIBLE(widget->widget))
return;
w = widget->widget->requisition.width;
h = widget->widget->requisition.height;
hippo_canvas_box_align(box, w, h, &x, &y, &w, &h);
widget_x = 0;
widget_y = 0;
if (box->context)
hippo_canvas_context_translate_to_widget(box->context, item,
&widget_x, &widget_y);
child_allocation.x = widget_x + x;
child_allocation.y = widget_y + y;
child_allocation.width = w;
child_allocation.height = h;
gtk_widget_size_allocate(widget->widget, &child_allocation);
}
static void
hippo_canvas_control_position(HippoCanvasControl *control)
{
HippoCanvasItem *item = HIPPO_CANVAS_ITEM(control);
HippoCanvasBox *box = HIPPO_CANVAS_BOX(item);
int x, y, w, h;
int control_x, control_y;
if (control->control == NULL)
return;
control->control->getLastRequest(&w, &h);
hippo_canvas_box_align(box, w, h, &x, &y, &w, &h);
control_x = 0;
control_y = 0;
if (box->context)
hippo_canvas_context_translate_to_widget(box->context, item,
&control_x, &control_y);
control->control->sizeAllocate(control_x + x, control_y + y, w, h);
}
HippoStackManager*
hippo_stack_manager_new(DDMDataModel *model,
HippoStackerPlatform *platform)
{
StackManager *manager;
manager = g_new0(StackManager, 1);
manager->item_to_block = g_hash_table_new_full(g_direct_hash, NULL,
NULL, (GDestroyNotify)g_object_unref);
manager->model = g_object_ref(model);
manager->platform = g_object_ref(platform);
manager->actions = hippo_actions_new(manager->model, manager->platform, manager);
manager->browser_window = hippo_stacker_platform_create_window(manager->platform);
#ifdef WITH_MAEMO
g_object_set(manager->browser_window, "role", HIPPO_WINDOW_ROLE_NOTIFICATION, NULL);
#endif
g_signal_connect(manager->browser_window, "minimize",
G_CALLBACK(on_browser_minimize), manager);
hippo_window_set_resizable(manager->browser_window,
HIPPO_ORIENTATION_VERTICAL,
TRUE);
manager->browser_base_item = g_object_new(HIPPO_TYPE_CANVAS_BASE,
"actions", manager->actions,
"notification-mode", FALSE,
NULL);
g_signal_connect(manager->browser_base_item,
"title-bar-button-press-event",
G_CALLBACK(on_browser_title_bar_button_press),
manager);
manager->browser_filter_area_item = g_object_new(HIPPO_TYPE_CANVAS_FILTER_AREA,
"actions", manager->actions,
NULL);
manager->browser_item = g_object_new(HIPPO_TYPE_CANVAS_STACK,
"box-width", UI_WIDTH,
"actions", manager->actions,
"pin-messages", TRUE,
NULL);
manager->browser_scroll_item = hippo_canvas_scrollbars_new();
hippo_canvas_scrollbars_set_policy(HIPPO_CANVAS_SCROLLBARS(manager->browser_scroll_item),
HIPPO_ORIENTATION_HORIZONTAL,
HIPPO_SCROLLBAR_NEVER);
hippo_canvas_scrollbars_set_policy(HIPPO_CANVAS_SCROLLBARS(manager->browser_scroll_item),
HIPPO_ORIENTATION_VERTICAL,
HIPPO_SCROLLBAR_ALWAYS);
manager->browser_resize_grip = g_object_new(HIPPO_TYPE_CANVAS_GRIP,
NULL);
g_signal_connect(G_OBJECT(manager->browser_resize_grip),
"button-press-event",
G_CALLBACK(on_browser_resize_grip_button_press),
manager);
manager->browser_box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_VERTICAL,
"border", WINDOW_BORDER,
"border-color", 0x9c9c9cff,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(manager->browser_box),
manager->browser_base_item,
0);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(manager->browser_box),
manager->browser_filter_area_item,
0);
hippo_canvas_item_set_visible(manager->browser_filter_area_item, FALSE);
hippo_canvas_scrollbars_set_root(HIPPO_CANVAS_SCROLLBARS(manager->browser_scroll_item),
manager->browser_item);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(manager->browser_box),
manager->browser_scroll_item,
HIPPO_PACK_EXPAND);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(manager->browser_box),
manager->browser_resize_grip,
0);
hippo_window_set_contents(manager->browser_window, manager->browser_box);
manager->notification_window = hippo_stacker_platform_create_window(manager->platform);
/* Omit the window from the task-list and (for platforms where there is one) the pager */
g_object_set(manager->notification_window, "role", HIPPO_WINDOW_ROLE_NOTIFICATION, NULL);
manager->notification_base_item = g_object_new(HIPPO_TYPE_CANVAS_BASE,
"actions", manager->actions,
"notification-mode", TRUE,
NULL);
manager->notification_item = g_object_new(HIPPO_TYPE_CANVAS_STACK,
"box-width", UI_WIDTH,
"actions", manager->actions,
"max-blocks", 3,
NULL);
manager->notification_box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_VERTICAL,
"border", 1,
"border-color", 0x9c9c9cff,
NULL);
g_signal_connect(manager->notification_box, "motion-notify-event",
G_CALLBACK(on_notification_motion_notify), manager);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(manager->notification_box),
manager->notification_base_item, 0);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(manager->notification_box),
manager->notification_item, 0);
hippo_window_set_contents(manager->notification_window, manager->notification_box);
g_signal_connect(manager->model, "ready",
G_CALLBACK(on_ready), manager);
if (ddm_data_model_is_ready(manager->model))
on_ready(manager->model, manager);
return manager;
}
static void
update_for_screen_info (StackManager *manager,
HippoRectangle *monitor,
HippoRectangle *icon,
HippoOrientation icon_orientation,
gboolean position_browser,
gboolean position_notification)
{
HippoRectangle base;
gboolean is_west;
gboolean is_north;
#if 1
g_debug("SIZING: work area %d,%d %dx%d icon %d,%d %dx%d orientation %d",
monitor->x, monitor->y, monitor->width, monitor->height,
icon->x, icon->y, icon->width, icon->height,
icon_orientation);
#endif
is_west = ((icon->x + icon->width / 2) < (monitor->x + monitor->width / 2));
is_north = ((icon->y + icon->height / 2) < (monitor->y + monitor->height / 2));
/* We pretend the icon is always in the corner */
if (is_west) {
icon->x = monitor->x;
if (icon_orientation == HIPPO_ORIENTATION_VERTICAL)
icon->x -= icon->width;
} else {
icon->x = monitor->x + monitor->width - icon->width;
if (icon_orientation == HIPPO_ORIENTATION_VERTICAL)
icon->x += icon->width;
}
if (is_north) {
icon->y = monitor->y;
if (icon_orientation == HIPPO_ORIENTATION_HORIZONTAL)
icon->y -= icon->height;
} else {
icon->y = monitor->y + monitor->height - icon->height;
if (icon_orientation == HIPPO_ORIENTATION_HORIZONTAL)
icon->y += icon->height;
}
/* g_debug("base_on_bottom %d is_north %d", manager->base_on_bottom, is_north); */
if ((manager->base_on_bottom && is_north) ||
(!manager->base_on_bottom && !is_north)) {
hippo_canvas_box_reverse(HIPPO_CANVAS_BOX(manager->notification_box));
manager->base_on_bottom = !manager->base_on_bottom;
}
/* We only resize vertically, so we don't need to worry about EAST/WEST */
g_object_set(manager->notification_window,
"resize-gravity", is_north ? HIPPO_GRAVITY_NORTH_WEST : HIPPO_GRAVITY_SOUTH_WEST,
NULL);
if (position_browser)
position_alongside(manager->browser_window, 3, icon,
icon_orientation,
is_west, is_north, &base);
if (position_notification)
position_alongside(manager->notification_window, 3, icon,
icon_orientation,
is_west, is_north, &base);
}
