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_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;
}
}
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;
}
}
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_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_text_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
HippoCanvasText *text;
text = HIPPO_CANVAS_TEXT(object);
switch (prop_id) {
case PROP_TEXT:
{
const char *new_text;
new_text = g_value_get_string(value);
if (!(new_text == text->text ||
(new_text && text->text && strcmp(new_text, text->text) == 0))) {
g_free(text->text);
text->text = g_strdup(new_text);
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(text));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(text), 0, 0, -1, -1);
}
}
break;
case PROP_ATTRIBUTES:
{
PangoAttrList *attrs = g_value_get_boxed(value);
if (attrs)
pango_attr_list_ref(attrs);
if (text->attributes)
pango_attr_list_unref(text->attributes);
text->attributes = attrs;
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(text));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(text), 0, 0, -1, -1);
}
break;
case PROP_MARKUP:
{
char *text;
PangoAttrList *attrs;
GError *error = NULL;
if (!pango_parse_markup(g_value_get_string(value),
-1,
0,
&attrs,
&text,
NULL,
&error)) {
g_error("Failed to set markup: %s", error->message);
return;
}
g_object_set(object, "text", text, "attributes", attrs, NULL);
pango_attr_list_unref(attrs);
g_free(text);
}
break;
case PROP_FONT_SCALE:
text->font_scale = g_value_get_double(value);
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(text));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(text), 0, 0, -1, -1);
break;
case PROP_SIZE_MODE:
text->size_mode = g_value_get_enum(value);
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(text));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(text), 0, 0, -1, -1);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
hippo_canvas_block_set_block_impl(HippoCanvasBlock *canvas_block,
HippoBlock *new_block)
{
#if 0
g_debug("setting block on canvas block to %s",
new_block ? hippo_block_get_guid(new_block) : "null");
#endif
if (new_block != canvas_block->block) {
if (new_block) {
if (canvas_block->required_type != HIPPO_BLOCK_TYPE_UNKNOWN &&
hippo_block_get_block_type(new_block) != canvas_block->required_type) {
g_warning("Trying to set block type %d on canvas block type %s",
hippo_block_get_block_type(new_block),
g_type_name_from_instance((GTypeInstance*)canvas_block));
return;
}
g_object_ref(new_block);
g_signal_connect(G_OBJECT(new_block), "notify::timestamp",
G_CALLBACK(on_block_timestamp_changed),
canvas_block);
g_signal_connect(G_OBJECT(new_block), "notify::significant-clicked-count",
G_CALLBACK(on_block_significant_clicked_count_changed),
canvas_block);
g_signal_connect(G_OBJECT(new_block), "notify::ignored",
G_CALLBACK(on_block_ignored_changed),
canvas_block);
g_signal_connect(G_OBJECT(new_block), "notify::stack-reason",
G_CALLBACK(on_block_stack_reason_changed),
canvas_block);
g_signal_connect(G_OBJECT(new_block), "notify::icon-url",
G_CALLBACK(on_block_icon_url_changed),
canvas_block);
}
if (canvas_block->block) {
g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block),
G_CALLBACK(on_block_timestamp_changed),
canvas_block);
g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block),
G_CALLBACK(on_block_significant_clicked_count_changed),
canvas_block);
g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block),
G_CALLBACK(on_block_ignored_changed),
canvas_block);
g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block),
G_CALLBACK(on_block_stack_reason_changed),
canvas_block);
g_signal_handlers_disconnect_by_func(G_OBJECT(canvas_block->block),
G_CALLBACK(on_block_icon_url_changed),
canvas_block);
g_object_unref(canvas_block->block);
}
canvas_block->block = new_block;
if (new_block) {
on_block_timestamp_changed(new_block, NULL, canvas_block);
on_block_significant_clicked_count_changed(new_block, NULL, canvas_block);
on_block_ignored_changed(new_block, NULL, canvas_block);
on_block_stack_reason_changed(new_block, NULL, canvas_block);
on_block_icon_url_changed(new_block, NULL, canvas_block);
if (canvas_block->heading_lock_item)
hippo_canvas_item_set_visible(canvas_block->heading_lock_item,
!hippo_block_is_public(canvas_block->block));
}
g_object_notify(G_OBJECT(canvas_block), "block");
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(canvas_block));
}
}
static void
hippo_canvas_image_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
HippoCanvasImage *image;
image = HIPPO_CANVAS_IMAGE(object);
switch (prop_id) {
case PROP_IMAGE:
{
cairo_surface_t *surface = g_value_get_boxed(value);
if (image->image_name) {
g_free(image->image_name);
image->image_name = NULL;
g_object_notify(G_OBJECT(image), "image-name");
}
set_surface(image, surface);
}
break;
case PROP_IMAGE_NAME:
{
const char *name = g_value_get_string(value);
if (!(image->image_name == name ||
(image->image_name && name && strcmp(image->image_name,
name) == 0))) {
g_free(image->image_name);
image->image_name = g_strdup(name);
set_surface_from_name(image);
/* will recursively call set_property("image") which
* will result in a request_changed if required
*/
}
}
break;
case PROP_SCALE_WIDTH:
{
int w = g_value_get_int(value);
if (w != image->scale_width) {
image->scale_width = w;
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(image));
}
}
break;
case PROP_SCALE_HEIGHT:
{
int h = g_value_get_int(value);
if (h != image->scale_height) {
image->scale_height = h;
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(image));
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
