static void property_changed(DBusGProxy *proxy, const char *property,
GValue *value, gpointer user_data)
{
adapter_data *adapter = user_data;
if (g_str_equal(property, "Powered") == TRUE) {
gboolean powered = g_value_get_boolean(value);
adapter->powered = powered;
if (powered == FALSE)
adapter->discoverable = FALSE;
update_visibility(adapter);
} else if (g_str_equal(property, "Discoverable") == TRUE) {
gboolean discoverable = g_value_get_boolean(value);
adapter->powered = TRUE;
adapter->discoverable = discoverable;
update_visibility(adapter);
} else if (g_str_equal(property, "DiscoverableTimeout") == TRUE) {
guint timeout = g_value_get_uint(value);
adapter->timeout_value = timeout;
update_visibility(adapter);
}
}
void move_container_to(swayc_t* container, swayc_t* destination) {
if (container == destination || swayc_is_parent_of(container, destination)) {
return;
}
swayc_t *parent = remove_child(container);
// reset container geometry
container->width = container->height = 0;
// Send to new destination
if (container->is_floating) {
add_floating(swayc_active_workspace_for(destination), container);
} else if (destination->type == C_WORKSPACE) {
add_child(destination, container);
} else {
add_sibling(destination, container);
}
// Destroy old container if we need to
parent = destroy_container(parent);
// Refocus
swayc_t *op1 = swayc_parent_by_type(destination, C_OUTPUT);
swayc_t *op2 = swayc_parent_by_type(parent, C_OUTPUT);
set_focused_container(get_focused_view(op1));
arrange_windows(op1, -1, -1);
update_visibility(op1);
if (op1 != op2) {
set_focused_container(get_focused_view(op2));
arrange_windows(op2, -1, -1);
update_visibility(op2);
}
}
// switches parent focus to c. will switch it accordingly
static void update_focus(swayc_t *c) {
// Handle if focus switches
swayc_t *parent = c->parent;
if (!parent) return;
if (parent->focused != c) {
// Get previous focus
swayc_t *prev = parent->focused;
// Set new focus
parent->focused = c;
switch (c->type) {
// Shouldn't happen
case C_ROOT: return;
// Case where output changes
case C_OUTPUT:
// update borders for views in prev
container_map(prev, map_update_view_border, NULL);
wlc_output_focus(c->handle);
break;
// Case where workspace changes
case C_WORKSPACE:
if (prev) {
ipc_event_workspace(prev, c, "focus");
// if the old workspace has no children, destroy it
if(prev->children->length == 0 && prev->floating->length == 0 && !suspend_workspace_cleanup) {
destroy_workspace(prev);
} else {
// update visibility of old workspace
update_visibility(prev);
}
}
// Update visibility of newly focused workspace
update_visibility(c);
break;
default:
case C_VIEW:
case C_CONTAINER:
// TODO whatever to do when container changes
// for example, stacked and tabbing change stuff.
break;
}
}
}
static void
hippo_canvas_block_netflix_movie_unexpand(HippoCanvasBlock *canvas_block)
{
HippoCanvasBlockNetflixMovie *block_netflix = HIPPO_CANVAS_BLOCK_NETFLIX_MOVIE(canvas_block);
HIPPO_CANVAS_BLOCK_CLASS(hippo_canvas_block_netflix_movie_parent_class)->unexpand(canvas_block);
update_visibility(block_netflix);
}
static void
on_block_chat_id_changed(HippoBlock *block,
GParamSpec *arg, /* null when first calling this */
void *data)
{
HippoCanvasBlockNetflixMovie *block_netflix = HIPPO_CANVAS_BLOCK_NETFLIX_MOVIE(data);
update_visibility(block_netflix);
}
void move_container_to(swayc_t* container, swayc_t* destination) {
if (container == destination || swayc_is_parent_of(container, destination)) {
return;
}
swayc_t *parent = remove_child(container);
// Send to new destination
if (container->is_floating) {
swayc_t *ws = swayc_active_workspace_for(destination);
add_floating(ws, container);
// If the workspace only has one child after adding one, it
// means that the workspace was just initialized.
if (ws->children->length + ws->floating->length == 1) {
ipc_event_workspace(NULL, ws, "init");
}
} else if (destination->type == C_WORKSPACE) {
// reset container geometry
container->width = container->height = 0;
add_child(destination, container);
// If the workspace only has one child after adding one, it
// means that the workspace was just initialized.
if (destination->children->length + destination->floating->length == 1) {
ipc_event_workspace(NULL, destination, "init");
}
} else {
// reset container geometry
container->width = container->height = 0;
add_sibling(destination, container);
}
// Destroy old container if we need to
parent = destroy_container(parent);
// Refocus
swayc_t *op1 = swayc_parent_by_type(destination, C_OUTPUT);
swayc_t *op2 = swayc_parent_by_type(parent, C_OUTPUT);
set_focused_container(get_focused_view(op1));
arrange_windows(op1, -1, -1);
update_visibility(op1);
if (op1 != op2) {
set_focused_container(get_focused_view(op2));
arrange_windows(op2, -1, -1);
update_visibility(op2);
}
}
static void
hippo_canvas_block_netflix_movie_stack_reason_changed(HippoCanvasBlock *canvas_block)
{
HippoCanvasBlockNetflixMovie *block_netflix = HIPPO_CANVAS_BLOCK_NETFLIX_MOVIE(canvas_block);
if (HIPPO_CANVAS_BLOCK_CLASS(hippo_canvas_block_netflix_movie_parent_class)->stack_reason_changed)
HIPPO_CANVAS_BLOCK_CLASS(hippo_canvas_block_netflix_movie_parent_class)->stack_reason_changed(canvas_block);
update_visibility(block_netflix);
}
void
qt_tm_widget_rep::set_full_screen(bool flag) {
full_screen = flag;
QWidget *win = mainwindow()->window();
if (win) {
if (flag ) {
#ifdef UNIFIED_TOOLBAR
if (use_unified_toolbar) {
//HACK: we disable unified toolbar since otherwise
// the application will crash when we return to normal mode
// (bug in Qt? present at least with 4.7.1)
mainwindow()->setUnifiedTitleAndToolBarOnMac(false);
mainwindow()->centralWidget()->layout()->setContentsMargins(0,0,0,0);
}
#endif
// mainwindow()->window()->setContentsMargins(0,0,0,0);
//win->showFullScreen();
win->setWindowState(win->windowState() ^ Qt::WindowFullScreen);
} else {
bool cache = visibility[0];
visibility[0] = false;
update_visibility();
// win->showNormal();
win->setWindowState(win->windowState() ^ Qt::WindowFullScreen);
visibility[0] = cache;
update_visibility();
#ifdef UNIFIED_TOOLBAR
if (use_unified_toolbar) {
mainwindow()->centralWidget()->layout()->setContentsMargins (0,1,0,0);
//HACK: we reenable unified toolbar (see above HACK)
// the application will crash when we return to normal mode
mainwindow()->setUnifiedTitleAndToolBarOnMac(true);
}
#endif
}
}
scrollarea()->setHorizontalScrollBarPolicy(flag ? Qt::ScrollBarAlwaysOff : Qt::ScrollBarAsNeeded);
scrollarea()->setVerticalScrollBarPolicy(flag ? Qt::ScrollBarAlwaysOff : Qt::ScrollBarAsNeeded);
}
void move_workspace_to(swayc_t* workspace, swayc_t* destination) {
if (workspace == destination || swayc_is_parent_of(workspace, destination)) {
return;
}
swayc_t *src_op = remove_child(workspace);
// reset container geometry
workspace->width = workspace->height = 0;
add_child(destination, workspace);
// Refocus destination (change to new workspace)
set_focused_container(get_focused_view(workspace));
arrange_windows(destination, -1, -1);
update_visibility(destination);
// make sure source output has a workspace
if (src_op->children->length == 0) {
char *ws_name = workspace_next_name(src_op->name);
swayc_t *ws = new_workspace(src_op, ws_name);
ws->is_focused = true;
free(ws_name);
}
set_focused_container(get_focused_view(src_op));
update_visibility(src_op);
}
// switches parent focus to c. will switch it accordingly
// TODO: Everything needs a handle, so we can set front/back position properly
static void update_focus(swayc_t *c) {
// Handle if focus switches
swayc_t *parent = c->parent;
if (parent->focused != c) {
// Get previous focus
swayc_t *prev = parent->focused;
// Set new focus
parent->focused = c;
switch (c->type) {
// Shouldnt happen
case C_ROOT: return;
// Case where output changes
case C_OUTPUT:
wlc_output_focus(c->handle);
break;
// Case where workspace changes
case C_WORKSPACE:
if (prev) {
// update visibility of old workspace
update_visibility(prev);
destroy_workspace(prev);
}
// Update visibility of newly focused workspace
update_visibility(c);
break;
default:
case C_VIEW:
case C_CONTAINER:
// TODO whatever to do when container changes
// for example, stacked and tabbing change stuff.
break;
}
}
}
void Vertex_visibility_graph_2<Traits>::handle(Tree_iterator p,
Tree_iterator q,
const Polygon& polygon,
Vertex_map& vertex_map)
{
#ifdef CGAL_VISIBILITY_GRAPH_DEBUG
std::cout << "Handling edge from " << (*p).x() << " " << (*p).y()
<< " to " << (*q).x() << " " << (*q).y() << std::endl;
#endif
Vertex_map_iterator p_it = vertex_map.find(*p);
Vertex_map_iterator q_it = vertex_map.find(*q);
CGAL_assertion (p_it != vertex_map.end());
CGAL_assertion (q_it != vertex_map.end());
#ifdef CGAL_VISIBILITY_GRAPH_DEBUG
std::cout << "p currently sees : ";
if ((*p_it).second.second != polygon.end())
std::cout << *((*p_it).second.second) << endl;
else
std::cout << " NADA" << endl;
#endif
// if p and q are adjacent
if (are_adjacent(polygon, (*p_it).second.first, (*q_it).second.first))
{
#ifdef CGAL_VISIBILITY_GRAPH_DEBUG
cout << "are adjacent" << endl;
#endif
insert_edge(Point_pair(*p,*q));
update_visibility(p_it, q_it, polygon, 1);
}
else
{
bool interior_at_p = diagonal_in_interior(polygon, (*p_it).second.first,
(*q_it).second.first);
bool interior_at_q = diagonal_in_interior(polygon, (*q_it).second.first,
(*p_it).second.first);
// line of site is through the interior of the polygon
if (interior_at_p && interior_at_q)
{
#ifdef CGAL_VISIBILITY_GRAPH_DEBUG
cout << "both interior" << endl;
#endif
// if p sees something and q is visible only through collinear
// points then update p's visibility if one of the points adjacent
// to q is above the line unless p's current visibility point
// obscures the view.
if ((*p_it).second.second != polygon.end() &&
are_strictly_ordered_along_line_2((*p_it).first,
*(*p_it).second.second,
(*q_it).first))
{
update_collinear_visibility(p_it, q_it, polygon);
}
// p current sees nothing or q is visible to p
else if ((*p_it).second.second == polygon.end() ||
point_is_visible(polygon, (*q_it).second.first, p_it))
{
insert_edge(Point_pair(*p,*q));
update_visibility(p_it, q_it, polygon, 0);
}
}
else if (!interior_at_p && !interior_at_q) // both points exterior
{
#ifdef CGAL_VISIBILITY_GRAPH_DEBUG
cout << "both exterior" << endl;
#endif
// p currently sees nothing or q is visible to p
if ((*p_it).second.second == polygon.end() ||
point_is_visible(polygon, (*q_it).second.first, p_it))
{
(*p_it).second.second = (*q_it).second.first;
}
}
}
#ifdef CGAL_VISIBILITY_GRAPH_DEBUG
std::cout << "p now sees : ";
if ((*p_it).second.second != polygon.end())
std::cout << *((*p_it).second.second) << endl;
else
std::cout << " NADA" << endl;
#endif
}
void
qt_tm_widget_rep::write (slot s, blackbox index, widget w) {
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_widget_rep::write " << slot_name (s) << LF;
switch (s) {
// Widget w is usually a qt_simple_widget_rep, with a QTMWidget as
// underlying widget. We must discard the current main_widget and
// display the new. But while switching buffers the widget w is a
// glue_widget, so we may not just use canvas() everywhere.
case SLOT_SCROLLABLE:
{
check_type_void (index, s);
QWidget* q = main_widget->qwid;
q->hide();
QLayout* l = centralwidget()->layout();
l->removeWidget(q);
q = concrete(w)->as_qwidget(); // force creation of the new QWidget
l->addWidget(q);
/* " When you use a layout, you do not need to pass a parent when
constructing the child widgets. The layout will automatically reparent
the widgets (using QWidget::setParent()) so that they are children of
the widget on which the layout is installed " */
main_widget = concrete (w);
// canvas() now returns the new QTMWidget (or 0)
if (scrollarea()) // Fix size to draw margins around.
scrollarea()->surface()->setSizePolicy (QSizePolicy::Fixed,
QSizePolicy::Fixed);
send_keyboard_focus (abstract (main_widget));
}
break;
case SLOT_MAIN_MENU:
check_type_void (index, s);
{
waiting_main_menu_widget = concrete (w);
if (menu_count <= 0)
install_main_menu();
else if (!contains (waiting_widgets, this))
// menu interaction ongoing, postpone new menu installation until done
waiting_widgets << this;
}
break;
case SLOT_MAIN_ICONS:
check_type_void (index, s);
{
main_icons_widget = concrete (w);
QMenu* m = main_icons_widget->get_qmenu();
if (m) {
replaceButtons (mainToolBar, m);
update_visibility();
}
}
break;
case SLOT_MODE_ICONS:
check_type_void (index, s);
{
mode_icons_widget = concrete (w);
QMenu* m = mode_icons_widget->get_qmenu();
if (m) {
replaceButtons (modeToolBar, m);
update_visibility();
}
}
break;
case SLOT_FOCUS_ICONS:
check_type_void (index, s);
{
focus_icons_widget = concrete (w);
QMenu* m = focus_icons_widget->get_qmenu();
if (m) {
replaceButtons (focusToolBar, m);
update_visibility();
}
}
break;
case SLOT_USER_ICONS:
check_type_void (index, s);
{
user_icons_widget = concrete (w);
QMenu* m = user_icons_widget->get_qmenu();
if (m) {
replaceButtons (userToolBar, m);
update_visibility();
}
}
break;
case SLOT_SIDE_TOOLS:
check_type_void (index, s);
{
side_tools_widget = concrete (w);
QWidget* new_qwidget = side_tools_widget->as_qwidget();
QWidget* old_qwidget = sideTools->widget();
if (old_qwidget) old_qwidget->deleteLater();
sideTools->setWidget (new_qwidget);
update_visibility();
new_qwidget->show();
}
break;
case SLOT_BOTTOM_TOOLS:
check_type_void (index, s);
{
bottom_tools_widget = concrete (w);
QWidget* new_qwidget = bottom_tools_widget->as_qwidget();
QWidget* old_qwidget = bottomTools->widget();
if (old_qwidget) old_qwidget->deleteLater();
bottomTools->setWidget (new_qwidget);
update_visibility();
new_qwidget->show();
}
break;
case SLOT_INTERACTIVE_PROMPT:
check_type_void (index, s);
int_prompt= concrete (w);
break;
case SLOT_INTERACTIVE_INPUT:
check_type_void (index, s);
int_input= concrete (w);
break;
default:
qt_window_widget_rep::write (s, index, w);
}
}
void
qt_tm_widget_rep::send (slot s, blackbox val) {
switch (s) {
case SLOT_INVALIDATE:
case SLOT_INVALIDATE_ALL:
case SLOT_EXTENTS:
case SLOT_SCROLL_POSITION:
case SLOT_ZOOM_FACTOR:
case SLOT_MOUSE_GRAB:
main_widget->send(s, val);
return;
case SLOT_KEYBOARD_FOCUS:
{
check_type<bool> (val, s);
bool focus = open_box<bool> (val);
if (focus && canvas() && !canvas()->hasFocus())
canvas()->setFocus (Qt::OtherFocusReason);
}
break;
case SLOT_HEADER_VISIBILITY:
{
check_type<bool>(val, s);
visibility[0] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_MAIN_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[1] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_MODE_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[2] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_FOCUS_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[3] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_USER_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[4] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_FOOTER_VISIBILITY:
{
check_type<bool>(val, s);
visibility[5] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_SIDE_TOOLS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[6] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_BOTTOM_TOOLS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[7] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_LEFT_FOOTER:
{
check_type<string>(val, s);
string msg = open_box<string> (val);
leftLabel->setText (to_qstring (msg));
leftLabel->update ();
}
break;
case SLOT_RIGHT_FOOTER:
{
check_type<string>(val, s);
string msg= open_box<string> (val);
rightLabel->setText (to_qstring (msg));
rightLabel->update ();
}
break;
case SLOT_SCROLLBARS_VISIBILITY:
// ignore this: qt handles scrollbars independently
// send_int (THIS, "scrollbars", val);
break;
case SLOT_INTERACTIVE_MODE:
{
check_type<bool>(val, s);
if (open_box<bool> (val) == true) {
prompt = new QTMInteractivePrompt (int_prompt, int_input);
mainwindow()->statusBar()->removeWidget (leftLabel);
mainwindow()->statusBar()->removeWidget (rightLabel);
mainwindow()->statusBar()->addWidget (prompt, 1);
prompt->start();
} else {
if (prompt) prompt->end();
mainwindow()->statusBar()->removeWidget (prompt);
mainwindow()->statusBar()->addWidget (leftLabel);
mainwindow()->statusBar()->addPermanentWidget (rightLabel);
leftLabel->show();
rightLabel->show();
prompt->deleteLater();
prompt = NULL;
}
}
break;
case SLOT_FILE:
{
check_type<string>(val, s);
string file = open_box<string> (val);
if (DEBUG_QT_WIDGETS) debug_widgets << "\tFile: " << file << LF;
#if (QT_VERSION >= 0x040400)
mainwindow()->setWindowFilePath (utf8_to_qstring (file));
#endif
}
break;
case SLOT_POSITION:
{
check_type<coord2>(val, s);
coord2 p= open_box<coord2> (val);
mainwindow()->move (to_qpoint (p));
}
break;
case SLOT_SIZE:
{
check_type<coord2>(val, s);
coord2 p= open_box<coord2> (val);
mainwindow()->resize (to_qsize (p));
}
break;
case SLOT_DESTROY:
{
ASSERT (is_nil (val), "type mismatch");
if (!is_nil (quit))
quit ();
the_gui->need_update ();
}
break;
case SLOT_FULL_SCREEN:
{
check_type<bool> (val, s);
set_full_screen(open_box<bool> (val));
}
break;
default:
qt_window_widget_rep::send (s, val);
return;
}
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_widget_rep: sent " << slot_name (s)
<< "\t\tto widget\t" << type_as_string() << LF;
}
void move_container(swayc_t *container, enum movement_direction dir) {
enum swayc_layouts layout;
if (container->is_floating) {
return;
}
if (dir == MOVE_UP || dir == MOVE_DOWN) {
layout = L_VERT;
} else if (dir == MOVE_LEFT || dir == MOVE_RIGHT) {
layout = L_HORIZ;
} else {
return;
}
swayc_t *parent = container->parent;
swayc_t *child = container;
bool ascended = false;
while (true) {
sway_log(L_DEBUG, "container:%p, parent:%p, child %p,",
container,parent,child);
if (parent->layout == layout) {
int diff;
// If it has ascended (parent has moved up), no container is removed
// so insert it at index, or index+1.
// if it has not, the moved container is removed, so it needs to be
// inserted at index-1, or index+1
if (ascended) {
diff = dir == MOVE_LEFT || dir == MOVE_UP ? 0 : 1;
} else {
diff = dir == MOVE_LEFT || dir == MOVE_UP ? -1 : 1;
}
int desired = index_child(child) + diff;
// when it has ascended, legal insertion position is 0:len
// when it has not, legal insertion position is 0:len-1
if (desired >= 0 && desired - ascended < parent->children->length) {
if (!ascended) {
child = parent->children->items[desired];
// Move container into sibling container
if (child->type == C_CONTAINER) {
parent = child;
// Insert it in first/last if matching layout,otherwise
// inesrt it next to focused container
if (parent->layout == layout) {
desired = (diff < 0) * parent->children->length;
} else {
desired = index_child(child->focused);
}
//reset geometry
container->width = container->height = 0;
}
}
swayc_t *old_parent = remove_child(container);
insert_child(parent, container, desired);
destroy_container(old_parent);
sway_log(L_DEBUG,"Moving to %p %d",parent, desired);
break;
}
}
// Change parent layout if we need to
if (parent->children->length == 1 && parent->layout != layout) {
parent->layout = layout;
continue;
}
if (parent->type == C_WORKSPACE) {
// We simply cannot move any further.
if (parent->layout == layout) {
break;
}
// Create container around workspace to insert child into
parent = new_container(parent, layout);
}
ascended = true;
child = parent;
parent = child->parent;
}
// Dirty hack to fix a certain case
arrange_windows(parent, -1, -1);
arrange_windows(parent->parent, -1, -1);
update_visibility(parent->parent);
set_focused_container_for(parent->parent, container);
}
static void
hippo_canvas_block_netflix_movie_append_content_items (HippoCanvasBlock *block,
HippoCanvasBox *parent_box)
{
HippoCanvasBlockNetflixMovie *block_netflix = HIPPO_CANVAS_BLOCK_NETFLIX_MOVIE(block);
HippoCanvasBox *box;
HippoCanvasBox *top_box;
HippoCanvasBox *beside_box;
HippoCanvasItem *item;
top_box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_HORIZONTAL,
"spacing", 4,
"border-bottom", 3,
NULL);
hippo_canvas_box_append(parent_box, HIPPO_CANVAS_ITEM(top_box), 0);
block_netflix->thumbnail = g_object_new(HIPPO_TYPE_CANVAS_URL_IMAGE,
"image-name", "netflix_no_image",
"tooltip", "More information about this movie",
"actions", hippo_canvas_block_get_actions(block),
"xalign", HIPPO_ALIGNMENT_START,
"yalign", HIPPO_ALIGNMENT_START,
"box-width", HIPPO_CANVAS_BLOCK_NETFLIX_COVER_ART_WIDTH,
"box-height", HIPPO_CANVAS_BLOCK_NETFLIX_COVER_ART_HEIGHT,
NULL);
hippo_canvas_box_append(top_box, block_netflix->thumbnail, 0);
beside_box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_VERTICAL,
NULL);
hippo_canvas_box_append(top_box, HIPPO_CANVAS_ITEM(beside_box), 0);
/* An extra box to keep the title link from expanding beyond its text */
box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_HORIZONTAL,
NULL);
hippo_canvas_box_append(beside_box, HIPPO_CANVAS_ITEM(box), 0);
block_netflix->favicon = g_object_new(HIPPO_TYPE_CANVAS_IMAGE,
"xalign", HIPPO_ALIGNMENT_CENTER,
"yalign", HIPPO_ALIGNMENT_CENTER,
"scale-width", 16, /* favicon size */
"scale-height", 16,
"border-right", 6,
NULL);
hippo_canvas_box_append(box, block_netflix->favicon, 0);
block_netflix->title_link = g_object_new(HIPPO_TYPE_CANVAS_URL_LINK,
"actions", hippo_canvas_block_get_actions(block),
"xalign", HIPPO_ALIGNMENT_START,
"size-mode", HIPPO_CANVAS_SIZE_ELLIPSIZE_END,
"font", "Bold 12px",
"tooltip", "More information about this movie",
NULL);
hippo_canvas_box_append(box, block_netflix->title_link, 0);
box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_HORIZONTAL,
NULL);
hippo_canvas_box_append(beside_box, HIPPO_CANVAS_ITEM(box), 0);
block_netflix->description_item = g_object_new(HIPPO_TYPE_CANVAS_TEXT,
"size-mode", HIPPO_CANVAS_SIZE_WRAP_WORD,
"xalign", HIPPO_ALIGNMENT_START,
"yalign", HIPPO_ALIGNMENT_START,
"text", NULL,
"border-top", 4,
"border-bottom", 4,
NULL);
hippo_canvas_box_append(beside_box, block_netflix->description_item, 0);
block_netflix->last_message_preview = g_object_new(HIPPO_TYPE_CANVAS_LAST_MESSAGE_PREVIEW,
"actions", hippo_canvas_block_get_actions(block),
NULL);
hippo_canvas_box_append(parent_box, block_netflix->last_message_preview, 0);
hippo_canvas_item_set_visible(block_netflix->last_message_preview,
FALSE); /* no messages yet */
block_netflix->quipper = g_object_new(HIPPO_TYPE_CANVAS_QUIPPER,
"actions", hippo_canvas_block_get_actions(block),
NULL);
hippo_canvas_box_append(parent_box, block_netflix->quipper, 0);
hippo_canvas_item_set_visible(block_netflix->quipper,
FALSE); /* not expanded */
block_netflix->chat_preview = g_object_new(HIPPO_TYPE_CANVAS_CHAT_PREVIEW,
"actions", hippo_canvas_block_get_actions(block),
"padding-bottom", 8,
NULL);
hippo_canvas_box_append(parent_box,
block_netflix->chat_preview, 0);
hippo_canvas_item_set_visible(block_netflix->chat_preview,
FALSE); /* not expanded at first */
block_netflix->queue_box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_VERTICAL,
NULL);
item = g_object_new(HIPPO_TYPE_CANVAS_TEXT,
"text", _("Movies in the Queue:"),
"xalign", HIPPO_ALIGNMENT_START,
NULL);
hippo_canvas_box_append(block_netflix->queue_box, item, 0);
block_netflix->queue_list_box = g_object_new(HIPPO_TYPE_CANVAS_BOX,
"orientation", HIPPO_ORIENTATION_VERTICAL,
NULL);
hippo_canvas_box_append(block_netflix->queue_box, HIPPO_CANVAS_ITEM(block_netflix->queue_list_box), 0);
hippo_canvas_box_append(parent_box, HIPPO_CANVAS_ITEM(block_netflix->queue_box), 0);
update_visibility(block_netflix);
}