static void
hippo_canvas_block_update_item_expansion(HippoCanvasBlock *canvas_block)
{
if (canvas_block->sent_to_box)
hippo_canvas_item_set_visible(HIPPO_CANVAS_ITEM(canvas_block->sent_to_box),
canvas_block->expanded && canvas_block->sent_to_set);
if (canvas_block->age_prefix_item)
hippo_canvas_item_set_visible(canvas_block->age_prefix_item,
canvas_block->expanded && canvas_block->age_set);
if (canvas_block->original_age_box)
hippo_canvas_item_set_visible(HIPPO_CANVAS_ITEM(canvas_block->original_age_box),
canvas_block->expanded && canvas_block->original_age_set);
}
static void
hippo_canvas_control_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
HippoCanvasControl *control;
control = HIPPO_CANVAS_CONTROL(object);
switch (prop_id) {
case PROP_CONTROL:
{
HippoAbstractControl *w = (HippoAbstractControl*) g_value_get_pointer(value);
if (control->control != w) {
if (w) {
w->AddRef();
}
if (control->control) {
control->control->Release();
}
control->control = w;
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(control));
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
HippoCanvasItem*
hippo_canvas_link_new(void)
{
HippoCanvasLink *link = g_object_new(HIPPO_TYPE_CANVAS_LINK, NULL);
return HIPPO_CANVAS_ITEM(link);
}
static void
update_visibility(HippoCanvasBlockNetflixMovie *block_netflix)
{
HippoCanvasBlock *canvas_block = HIPPO_CANVAS_BLOCK(block_netflix);
HippoStackReason stack_reason;
gboolean have_chat_id;
hippo_canvas_item_set_visible(HIPPO_CANVAS_ITEM(block_netflix->queue_box), canvas_block->expanded);
if (canvas_block->block)
stack_reason = hippo_block_get_stack_reason(canvas_block->block);
else
stack_reason = HIPPO_STACK_BLOCK_UPDATE;
have_chat_id = FALSE;
if (canvas_block->block)
have_chat_id = hippo_block_get_chat_id(canvas_block->block) != NULL;
hippo_canvas_item_set_visible(block_netflix->quipper,
canvas_block->expanded && have_chat_id);
hippo_canvas_item_set_visible(block_netflix->last_message_preview,
!canvas_block->expanded && stack_reason == HIPPO_STACK_CHAT_MESSAGE);
hippo_canvas_item_set_visible(block_netflix->chat_preview,
canvas_block->expanded && have_chat_id);
}
static void
hippo_canvas_widget_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
HippoCanvasWidget *widget;
widget = HIPPO_CANVAS_WIDGET(object);
switch (prop_id) {
case PROP_WIDGET:
{
GtkWidget *w = (GtkWidget*) g_value_get_object(value);
if (widget->widget != w) {
if (w) {
gtk_object_ref(GTK_OBJECT(w));
gtk_object_sink(GTK_OBJECT(w));
}
if (widget->widget)
g_object_unref(widget->widget);
widget->widget = w;
update_widget_visibility(widget);
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(widget));
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
hippo_canvas_grip_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
HippoCanvasGrip *grip;
grip = HIPPO_CANVAS_GRIP(object);
switch (prop_id) {
case PROP_SIDE:
{
HippoSide side = g_value_get_int(value);
if (side != grip->side) {
grip->side = side;
g_object_set(G_OBJECT(grip),
"border-left", side == HIPPO_SIDE_LEFT ? 1 : 0,
"border-right", side == HIPPO_SIDE_RIGHT ? 1 : 0,
"border-top", side == HIPPO_SIDE_TOP ? 1 : 0,
"border-bottom", side == HIPPO_SIDE_BOTTOM ? 1 : 0,
NULL);
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(grip));
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
/* 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));
}
}
HippoCanvasItem*
hippo_canvas_image_new(void)
{
HippoCanvasImage *image = g_object_new(HIPPO_TYPE_CANVAS_IMAGE, NULL);
return HIPPO_CANVAS_ITEM(image);
}
HippoCanvasItem*
hippo_canvas_grip_new(void)
{
HippoCanvasGrip *grip = g_object_new(HIPPO_TYPE_CANVAS_GRIP, NULL);
return HIPPO_CANVAS_ITEM(grip);
}
HippoCanvasItem*
hippo_canvas_base_new(void)
{
HippoCanvasBase *base = g_object_new(HIPPO_TYPE_CANVAS_BASE, NULL);
return HIPPO_CANVAS_ITEM(base);
}
HippoCanvasItem*
hippo_canvas_widget_new(void)
{
HippoCanvasWidget *widget = g_object_new(HIPPO_TYPE_CANVAS_WIDGET, NULL);
return HIPPO_CANVAS_ITEM(widget);
}
static void
hippo_canvas_block_music_update_visibility(HippoCanvasBlockMusic *block_music)
{
HippoCanvasBlock *canvas_block = HIPPO_CANVAS_BLOCK(block_music);
hippo_canvas_box_set_child_visible(block_music->single_message_preview_parent,
block_music->single_message_preview,
!canvas_block->expanded && block_music->have_messages);
hippo_canvas_box_set_child_visible(block_music->chat_preview_parent,
block_music->chat_preview,
canvas_block->expanded);
hippo_canvas_box_set_child_visible(block_music->downloads_box_parent,
HIPPO_CANVAS_ITEM(block_music->downloads_box),
canvas_block->expanded);
hippo_canvas_box_set_child_visible(block_music->old_tracks_box_parent,
HIPPO_CANVAS_ITEM(block_music->old_tracks_box),
canvas_block->expanded);
}
HippoCanvasItem*
hippo_canvas_text_new(void)
{
HippoCanvasText *text = g_object_new(HIPPO_TYPE_CANVAS_TEXT, NULL);
return HIPPO_CANVAS_ITEM(text);
}
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);
}
HippoCanvasItem*
hippo_canvas_control_new(void)
{
HippoCanvasControl *control;
control = HIPPO_CANVAS_CONTROL(g_object_new(HIPPO_TYPE_CANVAS_CONTROL, NULL));
return HIPPO_CANVAS_ITEM(control);
}
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;
}
HippoCanvasItem*
hippo_canvas_block_new(HippoBlockType type,
HippoActions *actions)
{
HippoCanvasBlock *block;
GType object_type;
object_type = HIPPO_TYPE_CANVAS_BLOCK;
switch (type) {
case HIPPO_BLOCK_TYPE_UNKNOWN:
object_type = HIPPO_TYPE_CANVAS_BLOCK;
break;
case HIPPO_BLOCK_TYPE_ACCOUNT_QUESTION:
object_type = HIPPO_TYPE_CANVAS_BLOCK_ACCOUNT_QUESTION;
break;
case HIPPO_BLOCK_TYPE_POST:
object_type = HIPPO_TYPE_CANVAS_BLOCK_POST;
break;
case HIPPO_BLOCK_TYPE_GROUP_CHAT:
object_type = HIPPO_TYPE_CANVAS_BLOCK_GROUP_CHAT;
break;
case HIPPO_BLOCK_TYPE_MUSIC_CHAT:
case HIPPO_BLOCK_TYPE_MUSIC_PERSON:
object_type = HIPPO_TYPE_CANVAS_BLOCK_MUSIC;
break;
case HIPPO_BLOCK_TYPE_GROUP_MEMBER:
object_type = HIPPO_TYPE_CANVAS_BLOCK_GROUP_MEMBER;
break;
case HIPPO_BLOCK_TYPE_GROUP_REVISION:
object_type = HIPPO_TYPE_CANVAS_BLOCK_GROUP_REVISION;
break;
case HIPPO_BLOCK_TYPE_FACEBOOK_EVENT:
object_type = HIPPO_TYPE_CANVAS_BLOCK_FACEBOOK_EVENT;
break;
case HIPPO_BLOCK_TYPE_NETFLIX_MOVIE:
object_type = HIPPO_TYPE_CANVAS_BLOCK_NETFLIX_MOVIE;
break;
case HIPPO_BLOCK_TYPE_AMAZON_REVIEW:
case HIPPO_BLOCK_TYPE_AMAZON_WISH_LIST_ITEM:
object_type = HIPPO_TYPE_CANVAS_BLOCK_AMAZON_ACTIVITY;
break;
case HIPPO_BLOCK_TYPE_FLICKR_PERSON:
case HIPPO_BLOCK_TYPE_FLICKR_PHOTOSET:
case HIPPO_BLOCK_TYPE_YOUTUBE_PERSON:
case HIPPO_BLOCK_TYPE_GENERIC:
object_type = HIPPO_TYPE_CANVAS_BLOCK_GENERIC;
break;
}
block = g_object_new(object_type,
"actions", actions,
NULL);
return HIPPO_CANVAS_ITEM(block);
}
static void
set_surface(HippoCanvasImage *image,
cairo_surface_t *surface)
{
if (surface != image->surface) {
int old_width, old_height;
gboolean request_changed = FALSE;
#if 0
/* The FC5 version of Cairo doesn't have this API */
if (cairo_surface_get_type(surface) != CAIRO_SURFACE_TYPE_IMAGE) {
g_warning("Image canvas item only supports image surfaces");
return;
}
#endif
old_width = image->surface ? cairo_image_surface_get_width(image->surface) : 0;
old_height = image->surface ? cairo_image_surface_get_height(image->surface) : 0;
if (surface)
cairo_surface_reference(surface);
if (image->surface)
cairo_surface_destroy(image->surface);
image->surface = surface;
if (image->scale_width < 0) {
int width = image->surface ? cairo_image_surface_get_width(image->surface) : 0;
if (width != old_width)
request_changed = TRUE;
}
if (image->scale_height < 0) {
int height = image->surface ? cairo_image_surface_get_height(image->surface) : 0;
if (height != old_height)
request_changed = TRUE;
}
if (request_changed)
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(image));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(image), 0, 0, -1, -1);
g_object_notify(G_OBJECT(image), "image");
}
}
static void
hippo_canvas_block_music_append_right_items (HippoCanvasBlock *block,
HippoCanvasBox *parent_box)
{
HippoCanvasBlockMusic *block_music = HIPPO_CANVAS_BLOCK_MUSIC(block);
block_music->downloads_box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_VERTICAL,
NULL);
hippo_canvas_box_append(parent_box, HIPPO_CANVAS_ITEM(block_music->downloads_box), HIPPO_PACK_FLOAT_RIGHT);
}
static void
hippo_canvas_block_music_update_visibility(HippoCanvasBlockMusic *block_music)
{
HippoCanvasBlock *canvas_block = HIPPO_CANVAS_BLOCK(block_music);
HippoStackReason stack_reason;
if (canvas_block->block)
stack_reason = hippo_block_get_stack_reason(canvas_block->block);
else
stack_reason = HIPPO_STACK_BLOCK_UPDATE;
hippo_canvas_item_set_visible(block_music->last_message_preview,
!canvas_block->expanded && stack_reason == HIPPO_STACK_CHAT_MESSAGE);
hippo_canvas_item_set_visible(block_music->chat_preview,
canvas_block->expanded);
hippo_canvas_item_set_visible(HIPPO_CANVAS_ITEM(block_music->downloads_box),
canvas_block->expanded);
hippo_canvas_item_set_visible(HIPPO_CANVAS_ITEM(block_music->old_tracks_box),
canvas_block->expanded);
}
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
update_widget_visibility(HippoCanvasWidget *widget)
{
int w, h;
if (widget->widget == NULL)
return;
hippo_canvas_item_get_allocation(HIPPO_CANVAS_ITEM(widget), &w, &h);
if (w == 0 || h == 0)
gtk_widget_hide(widget->widget);
else
gtk_widget_show(widget->widget);
}
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);
}
static void
update_original_age(HippoCanvasBlock *canvas_block)
{
if (canvas_block->original_age_item) {
if (canvas_block->block == NULL)
canvas_block->original_age_set = FALSE;
else
canvas_block->original_age_set =
set_timestamp_item(canvas_block,
canvas_block->original_age_box,
canvas_block->original_age_item, canvas_block->original_age);
hippo_canvas_item_set_visible(HIPPO_CANVAS_ITEM(canvas_block->original_age_box),
canvas_block->expanded && canvas_block->original_age_set);
}
}
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
on_block_queue_changed(HippoBlock *block,
GParamSpec *arg, /* null when first calling this */
void *data)
{
HippoCanvasBlock *canvas_block = HIPPO_CANVAS_BLOCK(data);
HippoCanvasBlockNetflixMovie *block_netflix = HIPPO_CANVAS_BLOCK_NETFLIX_MOVIE(data);
GSList *queue = NULL;
GSList *l;
if (block)
queue = hippo_block_netflix_movie_get_queue(HIPPO_BLOCK_NETFLIX_MOVIE(block));
hippo_canvas_box_remove_all(block_netflix->queue_list_box);
for (l = queue; l; l = l->next) {
HippoNetflixMovie *movie;
HippoCanvasBox *box;
HippoCanvasItem *number, *title;
char *priority_str;
movie = l->data;
box = g_object_new(HIPPO_TYPE_CANVAS_BOX, "orientation", HIPPO_ORIENTATION_HORIZONTAL, NULL);
priority_str = g_strdup_printf("%d", hippo_netflix_movie_get_priority(movie));
number = g_object_new(HIPPO_TYPE_CANVAS_TEXT, "text", priority_str, NULL);
g_free(priority_str);
hippo_canvas_box_append(box, number, 0);
title = g_object_new(HIPPO_TYPE_CANVAS_URL_LINK,
"actions", hippo_canvas_block_get_actions(canvas_block),
"xalign", HIPPO_ALIGNMENT_START,
"size-mode", HIPPO_CANVAS_SIZE_ELLIPSIZE_END,
"text", hippo_netflix_movie_get_title(movie),
"url", hippo_netflix_movie_get_url(movie),
"underline", FALSE,
"padding-left", 4,
NULL);
hippo_canvas_box_append(box, title, 0);
hippo_canvas_box_append(block_netflix->queue_list_box, HIPPO_CANVAS_ITEM(box), 0);
}
}
static void
image_set_on_canvas_item_func(HippoSurface *surface,
void *data)
{
HippoCanvasItem *item = HIPPO_CANVAS_ITEM(data);
/* g_debug("Setting image on canvas item, surface=%p", surface); */
if (surface != NULL) {
g_object_set(G_OBJECT(item),
"image",
hippo_surface_get_surface(surface),
NULL);
}
/* this function held a ref */
g_object_unref(item);
}
static GObject*
hippo_canvas_block_group_chat_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *object = G_OBJECT_CLASS(hippo_canvas_block_group_chat_parent_class)->constructor(type,
n_construct_properties,
construct_properties);
HippoCanvasBlock *block = HIPPO_CANVAS_BLOCK(object);
HippoCanvasBlockGroupChat *block_group_chat = HIPPO_CANVAS_BLOCK_GROUP_CHAT(object);
HippoCanvasBox *box;
hippo_canvas_block_set_heading(block, _("Group chat: "));
box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
NULL);
block_group_chat->parent_box = box;
block_group_chat->single_message_preview = g_object_new(HIPPO_TYPE_CANVAS_MESSAGE_PREVIEW,
"actions", hippo_canvas_block_get_actions(block),
NULL);
hippo_canvas_box_append(block_group_chat->parent_box,
block_group_chat->single_message_preview, 0);
hippo_canvas_box_set_child_visible(block_group_chat->parent_box,
block_group_chat->single_message_preview,
TRUE); /* not expanded at first */
block_group_chat->chat_preview = g_object_new(HIPPO_TYPE_CANVAS_CHAT_PREVIEW,
"actions", hippo_canvas_block_get_actions(block),
NULL);
hippo_canvas_box_append(block_group_chat->parent_box,
block_group_chat->chat_preview, 0);
hippo_canvas_box_set_child_visible(block_group_chat->parent_box,
block_group_chat->chat_preview,
FALSE); /* not expanded at first */
hippo_canvas_block_set_content(block, HIPPO_CANVAS_ITEM(box));
return object;
}
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);
}
static GObject*
hippo_canvas_base_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *object = G_OBJECT_CLASS(hippo_canvas_base_parent_class)->constructor(type,
n_construct_properties,
construct_properties);
HippoCanvasBase *base = HIPPO_CANVAS_BASE(object);
HippoCanvasItem *item;
HippoCanvasBox *box;
/* Create top bar */
box = g_object_new(HIPPO_TYPE_CANVAS_IMAGE,
"orientation", HIPPO_ORIENTATION_HORIZONTAL,
"image-name", "bar_middle", /* tile this as background */
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(base),
HIPPO_CANVAS_ITEM(box), 0);
g_signal_connect_after(G_OBJECT(box), "button-press-event", G_CALLBACK(on_title_bar_button_press_event), base);
if (base->notification_mode) {
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE_BUTTON,
"normal-image-name", "arrow",
"prelight-image-name", "arrow2",
"xalign", HIPPO_ALIGNMENT_START,
"tooltip", "Browse all items",
NULL);
hippo_canvas_box_append(box, item, 0);
g_signal_connect(G_OBJECT(item), "activated", G_CALLBACK(on_expand_activated), base);
g_signal_connect(G_OBJECT(item), "button-press-event", G_CALLBACK(on_button_button_press_event), base);
add_pipe_bar(box, 0);
}
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE,
"image-name", "mugshotstacker",
"xalign", HIPPO_ALIGNMENT_START,
NULL);
hippo_canvas_box_append(box, item, 0);
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE_BUTTON,
"normal-image-name", "bar_x",
"prelight-image-name", "bar_x2",
"xalign", HIPPO_ALIGNMENT_END,
"tooltip", "Close",
NULL);
hippo_canvas_box_append(box, item, HIPPO_PACK_END);
g_signal_connect(G_OBJECT(item), "activated", G_CALLBACK(on_close_activated), base);
g_signal_connect(G_OBJECT(item), "button-press-event", G_CALLBACK(on_button_button_press_event), base);
add_pipe_bar(box, HIPPO_PACK_END);
if (base->notification_mode) {
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE_BUTTON,
"normal-image-name", "hush",
"prelight-image-name", "hush2",
"xalign", HIPPO_ALIGNMENT_END,
"tooltip", "Don't bug me for a while",
NULL);
hippo_canvas_box_append(box, item, HIPPO_PACK_END);
g_signal_connect(G_OBJECT(item), "activated", G_CALLBACK(on_hush_activated), base);
g_signal_connect(G_OBJECT(item), "button-press-event", G_CALLBACK(on_button_button_press_event), base);
add_pipe_bar(box, HIPPO_PACK_END);
}
if (!base->notification_mode) {
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE_BUTTON,
"normal-image-name", "home",
"prelight-image-name", "home2",
"xalign", HIPPO_ALIGNMENT_END,
"tooltip", "Open Mugshot home page",
NULL);
hippo_canvas_box_append(box, item, HIPPO_PACK_END);
g_signal_connect(G_OBJECT(item), "activated", G_CALLBACK(on_home_activated), base);
g_signal_connect(G_OBJECT(item), "button-press-event", G_CALLBACK(on_button_button_press_event), base);
add_pipe_bar(box, HIPPO_PACK_END);
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE_BUTTON,
"normal-image-name", "filter",
"prelight-image-name", "filter2",
"xalign", HIPPO_ALIGNMENT_END,
"tooltip", "Show filters",
NULL);
hippo_canvas_box_append(box, item, HIPPO_PACK_END);
g_signal_connect(G_OBJECT(item), "activated", G_CALLBACK(on_filter_activated), base);
g_signal_connect(G_OBJECT(item), "button-press-event", G_CALLBACK(on_button_button_press_event), base);
add_pipe_bar(box, HIPPO_PACK_END);
}
#if 0
/* Create "find" area */
box = g_object_new(HIPPO_TYPE_CANVAS_GRADIENT,
"orientation", HIPPO_ORIENTATION_HORIZONTAL,
"start-color", 0xb47accff,
"end-color", 0xa35abfff,
NULL);
hippo_canvas_box_append(HIPPO_CANVAS_BOX(base),
HIPPO_CANVAS_ITEM(box), HIPPO_PACK_EXPAND);
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE,
"image-name", "find",
"xalign", HIPPO_ALIGNMENT_START,
NULL);
hippo_canvas_box_append(box, item, 0);
item = g_object_new(HIPPO_TYPE_CANVAS_IMAGE,
"image-name", "search_x",
"xalign", HIPPO_ALIGNMENT_START,
NULL);
hippo_canvas_box_append(box, item, 0);
#endif
return object;
}
