/* Dispose this object */
static void _xfdashboard_text_box_dispose(GObject *inObject)
{
XfdashboardTextBox *self=XFDASHBOARD_TEXT_BOX(inObject);
XfdashboardTextBoxPrivate *priv=self->priv;
/* Release our allocated variables */
if(priv->primaryIconName)
{
g_free(priv->primaryIconName);
priv->primaryIconName=NULL;
}
if(priv->secondaryIconName)
{
g_free(priv->secondaryIconName);
priv->secondaryIconName=NULL;
}
if(priv->textFont)
{
g_free(priv->textFont);
priv->textFont=NULL;
}
if(priv->textColor)
{
clutter_color_free(priv->textColor);
priv->textColor=NULL;
}
if(priv->selectionTextColor)
{
clutter_color_free(priv->selectionTextColor);
priv->selectionTextColor=NULL;
}
if(priv->selectionBackgroundColor)
{
clutter_color_free(priv->selectionBackgroundColor);
priv->selectionBackgroundColor=NULL;
}
if(priv->hintTextFont)
{
g_free(priv->hintTextFont);
priv->hintTextFont=NULL;
}
if(priv->hintTextColor)
{
clutter_color_free(priv->hintTextColor);
priv->hintTextColor=NULL;
}
/* Call parent's class dispose method */
G_OBJECT_CLASS(xfdashboard_text_box_parent_class)->dispose(inObject);
}
static void
champlain_path_layer_finalize (GObject *object)
{
ChamplainPathLayer *self = CHAMPLAIN_PATH_LAYER (object);
ChamplainPathLayerPrivate *priv = self->priv;
clutter_color_free (priv->stroke_color);
clutter_color_free (priv->fill_color);
g_free (priv->dash);
G_OBJECT_CLASS (champlain_path_layer_parent_class)->finalize (object);
}
void
gourmap_ui_update_map (GourmapUi *ui,
const double my_lat,
const double my_lng,
const double center_lat,
const double center_lng,
GList *poi_list)
{
GourmapUiPrivate *priv = GET_PRIVATE (ui);
ClutterActor *marker;
ClutterColor *color;
Restaurant *rest;
GList *list_i;
/* remove previous markers */
champlain_marker_layer_remove_all (priv->marker_layer);
champlain_view_set_zoom_level (priv->champ_view, priv->zoom);
champlain_view_go_to (priv->champ_view, my_lat, my_lng);
color = clutter_color_new (0xff, 0x20, 0x15, 0xbb);
marker = champlain_label_new_with_text (_("I'm here"),
"Serif 14", NULL, color);
clutter_color_free (color);
champlain_location_set_location (CHAMPLAIN_LOCATION (marker),
my_lat, my_lng);
champlain_marker_layer_add_marker (priv->marker_layer,
CHAMPLAIN_MARKER (marker));
/* Put restaurant markers */
list_i = poi_list;
color = clutter_color_new (0xff, 0x20, 0xff, 0xbb);
while (list_i != NULL) {
rest = (Restaurant *)list_i->data;
marker = champlain_label_new_with_text (rest->name,
"Serif 10",
NULL, color);
champlain_location_set_location (CHAMPLAIN_LOCATION (marker),
rest->latitude,
rest->longitude);
champlain_marker_layer_add_marker (priv->marker_layer,
CHAMPLAIN_MARKER (marker));
list_i = g_list_next (list_i);
}
clutter_color_free (color);
champlain_marker_layer_show_all_markers (priv->marker_layer);
}
static void
connect_joints (cairo_t *cairo,
SkeltrackJoint *joint_a,
SkeltrackJoint *joint_b,
const gchar *color_str)
{
ClutterColor *color;
if (joint_a == NULL || joint_b == NULL)
return;
color = clutter_color_new (0, 0, 0, 200);
clutter_color_from_string (color, color_str);
cairo_set_line_width (cairo, 10);
clutter_cairo_set_source_color (cairo, color);
cairo_move_to (cairo,
joint_a->screen_x,
joint_a->screen_y);
cairo_line_to (cairo,
joint_b->screen_x,
joint_b->screen_y);
cairo_stroke (cairo);
clutter_color_free (color);
}
static void
paint_joint (cairo_t *cairo,
SkeltrackJoint *joint,
gint radius,
const gchar *color_str)
{
ClutterColor *color;
if (joint == NULL)
return;
color = clutter_color_new (0, 0, 0, 200);
clutter_color_from_string (color, color_str);
cairo_set_line_width (cairo, 10);
clutter_cairo_set_source_color (cairo, color);
cairo_arc (cairo,
joint->screen_x,
joint->screen_y,
radius * (THRESHOLD_END - THRESHOLD_BEGIN) / joint->z,
0,
G_PI * 2);
cairo_fill (cairo);
clutter_color_free (color);
}
//
// redraw stack
//
void redraw_stack()
{
if (stage == NULL) {
fprintf(stderr, "stage cannot be drawn upon\n");
return;
}
// clear stage
ClutterColor stage_bg_color;
clutter_color_parse("#fff", &stage_bg_color);
clutter_stage_set_color(CLUTTER_STAGE(stage), &stage_bg_color);
int width=256, /*height=256, */padding=5;
// loop through all windows and draw an item on the grid
WindowStack *sitem = stack;
int i=0;
while (sitem != NULL) {
printf( "drawing stack item %d\n", (i+1) );
int x = (i*width) + ( (i+1)*padding );
int y = padding;
ClutterActor *actor = clutter_texture_new_from_file("/home/Downloads/window.png", NULL);
clutter_container_add(CLUTTER_CONTAINER(stage), actor, NULL);
clutter_actor_set_position(actor, x, y);
sitem = sitem->next;
i++;
}
clutter_actor_show(CLUTTER_ACTOR(stage));
clutter_color_free(&stage_bg_color);
}
void xfdashboard_stage_interface_set_background_color(XfdashboardStageInterface *self, const ClutterColor *inColor)
{
XfdashboardStageInterfacePrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_STAGE_INTERFACE(self));
priv=self->priv;
/* Set value if changed */
if((priv->backgroundColor && !inColor) ||
(!priv->backgroundColor && inColor) ||
(inColor && clutter_color_equal(inColor, priv->backgroundColor)==FALSE))
{
/* Set value */
if(priv->backgroundColor)
{
clutter_color_free(priv->backgroundColor);
priv->backgroundColor=NULL;
}
if(inColor) priv->backgroundColor=clutter_color_copy(inColor);
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardStageInterfaceProperties[PROP_BACKGROUND_COLOR]);
}
}
static void
draw_point (guchar *buffer,
guint width,
guint height,
gchar *color_str,
guint x,
guint y)
{
ClutterColor *color = clutter_color_new (0, 0, 0, 255);
clutter_color_from_string (color, color_str);
gint i, j;
for (i = -POINT_SIZE; i < POINT_SIZE; i++)
{
for (j = -POINT_SIZE; j < POINT_SIZE; j++)
{
if (x + i < 0 || x + i >= width ||
y + j < 0 || y + j >= height)
continue;
buffer[(width * (y + j) + x + i) * 3] = color->red;
buffer[(width * (y + j) + x + i) * 3 + 1] = color->green;
buffer[(width * (y + j) + x + i) * 3 + 2] = color->blue;
}
}
clutter_color_free (color);
}
static gboolean
on_skeleton_draw (ClutterCanvas *canvas,
cairo_t *cairo,
gint width,
gint height,
gpointer user_data)
{
ClutterColor *color;
SkeltrackJoint *head, *left_hand, *right_hand,
*left_shoulder, *right_shoulder, *left_elbow, *right_elbow;
if (list == NULL)
return FALSE;
head = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_HEAD);
left_hand = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_LEFT_HAND);
right_hand = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_RIGHT_HAND);
left_shoulder = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_LEFT_SHOULDER);
right_shoulder = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_RIGHT_SHOULDER);
left_elbow = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_LEFT_ELBOW);
right_elbow = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_RIGHT_ELBOW);
/* Paint it white */
color = clutter_color_new (255, 255, 255, 255);
clutter_cairo_set_source_color (cairo, color);
cairo_rectangle (cairo, 0, 0, width, height);
cairo_fill (cairo);
clutter_color_free (color);
paint_joint (cairo, head, 50, "#FFF800");
connect_joints (cairo, left_shoulder, right_shoulder, "#afafaf");
connect_joints (cairo, left_shoulder, left_elbow, "#afafaf");
connect_joints (cairo, right_shoulder, right_elbow, "#afafaf");
connect_joints (cairo, right_hand, right_elbow, "#afafaf");
connect_joints (cairo, left_hand, left_elbow, "#afafaf");
paint_joint (cairo, left_hand, 30, "#C2FF00");
paint_joint (cairo, right_hand, 30, "#00FAFF");
skeltrack_joint_list_free (list);
list = NULL;
return FALSE;
}
static void
on_texture_draw (ClutterCairoTexture *texture,
cairo_t *cairo,
gpointer user_data)
{
guint width, height;
ClutterColor *color;
SkeltrackJoint *head, *left_hand, *right_hand,
*left_shoulder, *right_shoulder, *left_elbow, *right_elbow;
if (list == NULL)
return;
head = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_HEAD);
left_hand = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_LEFT_HAND);
right_hand = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_RIGHT_HAND);
left_shoulder = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_LEFT_SHOULDER);
right_shoulder = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_RIGHT_SHOULDER);
left_elbow = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_LEFT_ELBOW);
right_elbow = skeltrack_joint_list_get_joint (list,
SKELTRACK_JOINT_ID_RIGHT_ELBOW);
/* Paint it white */
clutter_cairo_texture_clear (texture);
clutter_cairo_texture_get_surface_size (texture, &width, &height);
color = clutter_color_new (255, 255, 255, 255);
clutter_cairo_set_source_color (cairo, color);
cairo_rectangle (cairo, 0, 0, width, height);
cairo_fill (cairo);
clutter_color_free (color);
paint_joint (cairo, head, 50, "#FFF800");
connect_joints (cairo, left_shoulder, right_shoulder, "#afafaf");
connect_joints (cairo, left_shoulder, left_elbow, "#afafaf");
connect_joints (cairo, right_shoulder, right_elbow, "#afafaf");
connect_joints (cairo, right_hand, right_elbow, "#afafaf");
connect_joints (cairo, left_hand, left_elbow, "#afafaf");
paint_joint (cairo, left_hand, 30, "#C2FF00");
paint_joint (cairo, right_hand, 30, "#00FAFF");
skeltrack_joint_list_free (list);
list = NULL;
}
//doc ClutterColor subtractInPlace(otherColor)
IO_METHOD(IoClutterColor, subtractInPlace) {
ClutterColor color_a = IOCCOLOR(self);
ClutterColor color_b = IOCCOLOR(IoMessage_locals_clutterColorArgAt_(m, locals, 0));
ClutterColor result;
clutter_color_subtract(&color_a, &color_b, &result);
clutter_color_free(&color_a);
DATA(self)->color = result;
return self;
}
/* Dispose this object */
static void _xfdashboard_stage_interface_dispose(GObject *inObject)
{
XfdashboardStageInterface *self=XFDASHBOARD_STAGE_INTERFACE(inObject);
XfdashboardStageInterfacePrivate *priv=self->priv;
/* Release allocated resources */
if(priv->bindingBackgroundImageType)
{
g_object_unref(priv->bindingBackgroundImageType);
priv->bindingBackgroundImageType=NULL;
}
if(priv->bindingBackgroundColor)
{
g_object_unref(priv->bindingBackgroundColor);
priv->bindingBackgroundColor=NULL;
}
if(priv->monitor)
{
if(priv->geometryChangedID)
{
g_signal_handler_disconnect(priv->monitor, priv->geometryChangedID);
priv->geometryChangedID=0;
}
if(priv->primaryChangedID)
{
g_signal_handler_disconnect(priv->monitor, priv->primaryChangedID);
priv->primaryChangedID=0;
}
g_object_unref(priv->monitor);
priv->monitor=NULL;
}
if(priv->backgroundColor)
{
clutter_color_free(priv->backgroundColor);
priv->backgroundColor=NULL;
}
/* Call parent's class dispose method */
G_OBJECT_CLASS(xfdashboard_stage_interface_parent_class)->dispose(inObject);
}
/**
* champlain_point_set_color:
* @point: a #ChamplainPoint
* @color: (allow-none): The color of the point or NULL to reset the background to the
* default color. The color parameter is copied.
*
* Set the color of the point.
*
* Since: 0.10
*/
void
champlain_point_set_color (ChamplainPoint *point,
const ClutterColor *color)
{
g_return_if_fail (CHAMPLAIN_IS_POINT (point));
ChamplainPointPrivate *priv = point->priv;
if (priv->color != NULL)
clutter_color_free (priv->color);
if (color == NULL)
color = &DEFAULT_COLOR;
priv->color = clutter_color_copy (color);
g_object_notify (G_OBJECT (point), "color");
clutter_content_invalidate (priv->canvas);
}
static void
color_prop_value_cb (MxSlider *slider,
GParamSpec *pspec,
ColorPropComp *prop_comp)
{
float value = mx_slider_get_value (slider) * 255.0f + 0.5f;
ColorProp *prop = prop_comp->prop;
if (prop->object)
{
ClutterColor *color;
g_object_get (prop->object, prop->prop_name, &color, NULL);
((guint8 *) color)[prop_comp->comp_num] = value;
clutter_rectangle_set_color (CLUTTER_RECTANGLE (prop->rect), color);
g_object_set (prop->object, prop->prop_name, color, NULL);
clutter_color_free (color);
}
else
{
ClutterColor color;
CoglColor cogl_color;
prop->get_func (prop->material, &cogl_color);
color.red = cogl_color_get_red_byte (&cogl_color);
color.green = cogl_color_get_green_byte (&cogl_color);
color.blue = cogl_color_get_blue_byte (&cogl_color);
color.alpha = 255;
((guint8 *) &color)[prop_comp->comp_num] = value;
cogl_color_set_from_4ub (&cogl_color,
color.red,
color.green,
color.blue,
255);
clutter_rectangle_set_color (CLUTTER_RECTANGLE (prop->rect), &color);
prop->set_func (prop->material, &cogl_color);
}
update_prop_comp_label (prop_comp, value);
}
static ClutterActor *new_rect (gint r,
gint g,
gint b,
gint a)
{
GError *error = NULL;
ClutterColor *color = clutter_color_new (r, g, b, a);
ClutterActor *rectangle = clutter_rectangle_new_with_color (color);
gchar *file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);
rectangle = clutter_texture_new_from_file (file, &error);
if (rectangle == NULL)
g_error ("image load failed: %s", error->message);
g_free (file);
clutter_actor_set_size (rectangle, 128, 128);
clutter_color_free (color);
return rectangle;
}
static void
champlain_point_finalize (GObject *object)
{
ChamplainPointPrivate *priv = CHAMPLAIN_POINT (object)->priv;
if (priv->color)
{
clutter_color_free (priv->color);
priv->color = NULL;
}
if (priv->canvas)
{
g_object_unref (priv->canvas);
priv->canvas = NULL;
}
G_OBJECT_CLASS (champlain_point_parent_class)->finalize (object);
}
/**
* champlain_path_layer_set_stroke_color:
* @layer: a #ChamplainPathLayer
* @color: (allow-none): The path's stroke color or NULL to reset to the
* default color. The color parameter is copied.
*
* Set the path's stroke color.
*
* Since: 0.10
*/
void
champlain_path_layer_set_stroke_color (ChamplainPathLayer *layer,
const ClutterColor *color)
{
g_return_if_fail (CHAMPLAIN_IS_PATH_LAYER (layer));
ChamplainPathLayerPrivate *priv = layer->priv;
if (priv->stroke_color != NULL)
clutter_color_free (priv->stroke_color);
if (color == NULL)
color = &DEFAULT_STROKE_COLOR;
priv->stroke_color = clutter_color_copy (color);
g_object_notify (G_OBJECT (layer), "stroke-color");
schedule_redraw (layer);
}
static void
add_color_prop (ClutterActor *table,
const char *name,
GObject *object,
const char *prop_name)
{
ColorProp *prop = g_slice_new (ColorProp);
ClutterColor *value;
prop->prop_name = g_strdup (prop_name);
prop->object = g_object_ref (object);
prop->material = COGL_INVALID_HANDLE;
g_object_get (object, prop_name, &value, NULL);
add_color_prop_base (table, name, prop, value);
clutter_color_free (value);
}
void
gmc_button_set_label (GmcButton *self, const gchar *label)
{
GmcButtonPrivate *priv;
ClutterColor *color;
priv = GMC_BUTTON_GET_PRIVATE (self);
if (priv->label) {
if (g_strcmp0 (label, clutter_text_get_text (CLUTTER_TEXT (priv->label))) == 0)
return;
clutter_text_set_text (CLUTTER_TEXT (priv->label), label);
return;
}
color = clutter_color_new (0x80, 0x80, 0x80, 0xff);
priv->label = clutter_text_new_full ("Comic Sans MS 12", label, color);
clutter_actor_set_parent (priv->label, CLUTTER_ACTOR (self));
clutter_color_free (color);
}
static gboolean
gmc_button_leave_event (ClutterActor *actor,
ClutterCrossingEvent *event)
{
GmcButton *self;
GmcButtonPrivate *priv;
ClutterColor *color;
self = GMC_BUTTON (actor);
priv = GMC_BUTTON_GET_PRIVATE (self);
if (priv->label) {
color = clutter_color_new (0x80, 0x80, 0x80, 0xff);
clutter_text_set_color (CLUTTER_TEXT (priv->label), color);
clutter_color_free (color);
}
priv->is_hover = FALSE;
return TRUE;
}
void xfdashboard_text_box_set_hint_text_color(XfdashboardTextBox *self, const ClutterColor *inColor)
{
XfdashboardTextBoxPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_TEXT_BOX(self));
g_return_if_fail(inColor);
priv=self->priv;
/* Set value if changed */
if(!priv->hintTextColor || !clutter_color_equal(inColor, priv->hintTextColor))
{
if(priv->hintTextColor) clutter_color_free(priv->hintTextColor);
priv->hintTextColor=clutter_color_copy(inColor);
clutter_text_set_color(CLUTTER_TEXT(priv->actorHintLabel), priv->hintTextColor);
clutter_actor_queue_redraw(CLUTTER_ACTOR(self));
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardTextBoxProperties[PROP_HINT_TEXT_COLOR]);
}
}
void xfdashboard_text_box_set_text_color(XfdashboardTextBox *self, const ClutterColor *inColor)
{
XfdashboardTextBoxPrivate *priv;
ClutterColor selectionColor;
g_return_if_fail(XFDASHBOARD_IS_TEXT_BOX(self));
g_return_if_fail(inColor);
priv=self->priv;
/* Set value if changed */
if(!priv->textColor || !clutter_color_equal(inColor, priv->textColor))
{
if(priv->textColor) clutter_color_free(priv->textColor);
priv->textColor=clutter_color_copy(inColor);
clutter_text_set_color(CLUTTER_TEXT(priv->actorTextBox), priv->textColor);
/* Selection text and background color is inverted text color if not set */
if(!priv->selectionColorSet)
{
selectionColor.red=0xff-priv->textColor->red;
selectionColor.green=0xff-priv->textColor->green;
selectionColor.blue=0xff-priv->textColor->blue;
selectionColor.alpha=priv->textColor->alpha;
clutter_text_set_selected_text_color(CLUTTER_TEXT(priv->actorTextBox), &selectionColor);
/* Selection color is the same as text color */
clutter_text_set_selection_color(CLUTTER_TEXT(priv->actorTextBox), priv->textColor);
}
/* Redraw actor in new color */
clutter_actor_queue_redraw(CLUTTER_ACTOR(self));
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardTextBoxProperties[PROP_TEXT_COLOR]);
}
}
static ClutterActor *new_rect (gint r,
gint g,
gint b,
gint a)
{
GError *error = NULL;
ClutterColor *color = clutter_color_new (r, g, b, a);
ClutterActor *group = clutter_group_new ();
ClutterActor *rectangle = clutter_rectangle_new_with_color (color);
ClutterActor *hand = NULL;
gchar *file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);
hand = clutter_texture_new_from_file (file, &error);
if (rectangle == NULL)
g_error ("image load failed: %s", error->message);
g_free (file);
clutter_actor_set_size (hand, ACTOR_WIDTH,ACTOR_HEIGHT);
clutter_actor_set_size (rectangle, ACTOR_WIDTH,ACTOR_HEIGHT);
clutter_color_free (color);
clutter_container_add (CLUTTER_CONTAINER (group), rectangle, hand, NULL);
return group;
}
/* Set up color button, e.g. set initial color from settings, connect signals
* to store newly chosen color or to reflect changed color from settings
* in widget etc.
*/
static void _plugin_configure_setup_color_button(GtkColorButton *inButton,
XfdashboardClockViewSettings *inSettings,
const gchar *inProperty)
{
ClutterColor *settingsColor;
GdkRGBA widgetColor;
gchar *signalName;
guint signalID;
PluginWidgetSettingsMap *mapping;
g_return_if_fail(GTK_IS_COLOR_BUTTON(inButton));
g_return_if_fail(XFDASHBOARD_IS_CLOCK_VIEW_SETTINGS(inSettings));
g_return_if_fail(inProperty && *inProperty);
/* Create data for later use at color button */
mapping=g_new0(PluginWidgetSettingsMap,1);
if(!mapping)
{
g_critical(_("Cannot allocate memory for mapping"));
return;
}
/* Get current color from settings */
g_object_get(G_OBJECT(inSettings), inProperty, &settingsColor, NULL);
/* Convert color for color button */
widgetColor.red=settingsColor->red/255.0f;
widgetColor.green=settingsColor->green/255.0f;
widgetColor.blue=settingsColor->blue/255.0f;
widgetColor.alpha=settingsColor->alpha/255.0f;
/* Set converted color at color button */
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(inButton), &widgetColor);
#else
gtk_color_button_set_rgba(inButton, &widgetColor);
#endif
/* Connect signal to store color of new one was chosen at color button */
g_signal_connect(inButton,
"color-set",
G_CALLBACK(_plugin_on_color_button_color_chosen),
NULL);
signalName=g_strdup_printf("notify::%s", inProperty);
signalID=g_signal_connect(inSettings,
signalName,
G_CALLBACK(_plugin_on_settings_color_change),
inButton);
/* Set mapping data at color button */
mapping->settings=g_object_ref(inSettings);
mapping->property=g_strdup(inProperty);
mapping->settingsPropertyChangedSignalID=signalID;
g_object_set_data_full(G_OBJECT(inButton),
CONFIGURATION_MAPPING,
mapping,
(GDestroyNotify)_plugin_widget_settings_map_free);
/* Release allocated resources */
if(settingsColor) clutter_color_free(settingsColor);
if(signalName) g_free(signalName);
}
static void
mx_tooltip_style_changed (MxWidget *self)
{
ClutterColor *color = NULL;
MxTooltipPrivate *priv;
gchar *font_name;
gchar *font_string;
gint font_size;
MxBorderImage *border_image;
priv = MX_TOOLTIP (self)->priv;
mx_stylable_get (MX_STYLABLE (self),
"color", &color,
"font-family", &font_name,
"font-size", &font_size,
"border-image", &border_image,
NULL);
if (color)
{
clutter_text_set_color (CLUTTER_TEXT (priv->label), color);
clutter_color_free (color);
}
if (font_name || font_size)
{
if (font_name && font_size)
{
font_string = g_strdup_printf ("%s %dpx", font_name, font_size);
g_free (font_name);
}
else
if (font_size)
font_string = g_strdup_printf ("%dpx", font_size);
else
font_string = font_name;
clutter_text_set_font_name (CLUTTER_TEXT (priv->label), font_string);
g_free (font_string);
}
/* remove existing border image */
if (priv->border_image)
{
g_boxed_free (MX_TYPE_BORDER_IMAGE, priv->border_image);
priv->border_image = NULL;
}
if (priv->border_image_texture)
{
cogl_handle_unref (priv->border_image_texture);
priv->border_image_texture = NULL;
}
if (border_image)
{
priv->border_image_texture =
mx_texture_cache_get_cogl_texture (mx_texture_cache_get_default (),
border_image->uri);
priv->border_image = border_image;
}
clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
}
int
main (int argc, char *argv[])
{
ClutterActor *stage, *box, *bg, *icon, *emblem, *label;
ClutterLayoutManager *layout;
ClutterContent *canvas, *image;
ClutterColor *color;
ClutterAction *action;
GdkPixbuf *pixbuf;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
/* prepare the stage */
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "BinLayout");
clutter_actor_set_background_color (stage, CLUTTER_COLOR_Aluminium2);
clutter_actor_set_size (stage, 640, 480);
clutter_actor_show (stage);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* this is our BinLayout, with its default alignments */
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
/* the main container; this actor will use the BinLayout to lay
* out its children; we use the anchor point to keep it centered
* on the same position even when we change its size
*/
box = clutter_actor_new ();
clutter_actor_set_layout_manager (box, layout);
clutter_actor_add_constraint (box, clutter_align_constraint_new (stage, CLUTTER_ALIGN_BOTH, 0.5));
clutter_actor_set_position (box, 320, 240);
clutter_actor_set_reactive (box, TRUE);
clutter_actor_set_name (box, "box");
clutter_actor_add_child (stage, box);
/* the background is drawn using a canvas content */
canvas = clutter_canvas_new ();
g_signal_connect (canvas, "draw", G_CALLBACK (on_canvas_draw), NULL);
clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 200, 200);
/* this is the background actor; we want it to fill the whole
* of the allocation given to it by its parent
*/
bg = clutter_actor_new ();
clutter_actor_set_name (bg, "background");
clutter_actor_set_size (bg, 200, 200);
clutter_actor_set_content (bg, canvas);
clutter_actor_set_x_expand (bg, TRUE);
clutter_actor_set_y_expand (bg, TRUE);
clutter_actor_set_x_align (bg, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_set_y_align (bg, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_add_child (box, bg);
/* we use the ::transitions-completed signal to get notification
* of the end of the sizing animation; this allows us to redraw
* the canvas only once the animation has stopped
*/
g_signal_connect (box, "transitions-completed",
G_CALLBACK (redraw_canvas),
canvas);
/* we use GdkPixbuf to load an image from our data directory */
pixbuf = gdk_pixbuf_new_from_file (TESTS_DATADIR G_DIR_SEPARATOR_S "redhand.png", NULL);
image = clutter_image_new ();
clutter_image_set_data (CLUTTER_IMAGE (image),
gdk_pixbuf_get_pixels (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf)
? COGL_PIXEL_FORMAT_RGBA_8888
: COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf),
NULL);
g_object_unref (pixbuf);
/* this is the icon; it's going to be centered inside the box actor.
* we use the content gravity to keep the aspect ratio of the image,
* and the scaling filters to get a better result when scaling the
* image down.
*/
icon = clutter_actor_new ();
clutter_actor_set_name (icon, "icon");
clutter_actor_set_size (icon, 196, 196);
clutter_actor_set_x_expand (icon, TRUE);
clutter_actor_set_y_expand (icon, TRUE);
clutter_actor_set_x_align (icon, CLUTTER_ACTOR_ALIGN_CENTER);
clutter_actor_set_y_align (icon, CLUTTER_ACTOR_ALIGN_CENTER);
clutter_actor_set_content_gravity (icon, CLUTTER_CONTENT_GRAVITY_RESIZE_ASPECT);
clutter_actor_set_content_scaling_filters (icon,
CLUTTER_SCALING_FILTER_TRILINEAR,
CLUTTER_SCALING_FILTER_LINEAR);
clutter_actor_set_content (icon, image);
clutter_actor_add_child (box, icon);
color = clutter_color_new (g_random_int_range (0, 255),
g_random_int_range (0, 255),
g_random_int_range (0, 255),
224);
/* this is the emblem: a small rectangle with a random color, that we
* want to put in the bottom right corner
*/
emblem = clutter_actor_new ();
clutter_actor_set_name (emblem, "emblem");
clutter_actor_set_size (emblem, 48, 48);
clutter_actor_set_background_color (emblem, color);
clutter_actor_set_x_expand (emblem, TRUE);
clutter_actor_set_y_expand (emblem, TRUE);
clutter_actor_set_x_align (emblem, CLUTTER_ACTOR_ALIGN_END);
clutter_actor_set_y_align (emblem, CLUTTER_ACTOR_ALIGN_END);
clutter_actor_set_reactive (emblem, TRUE);
clutter_actor_set_opacity (emblem, 0);
clutter_actor_add_child (box, emblem);
clutter_color_free (color);
/* when clicking on the emblem, we want to perform an action */
action = clutter_click_action_new ();
clutter_actor_add_action (emblem, action);
g_signal_connect (action, "clicked", G_CALLBACK (on_emblem_clicked), box);
g_signal_connect (action, "long-press", G_CALLBACK (on_emblem_long_press), box);
/* whenever the pointer enters the box, we show the emblem; we hide
* the emblem when the pointer leaves the box
*/
g_signal_connect (box,
"enter-event", G_CALLBACK (on_box_enter),
emblem);
g_signal_connect (box,
"leave-event", G_CALLBACK (on_box_leave),
emblem);
/* a label, that we want to position at the top and center of the box */
label = clutter_text_new ();
clutter_actor_set_name (label, "text");
clutter_text_set_text (CLUTTER_TEXT (label), "A simple test");
clutter_actor_set_x_expand (label, TRUE);
clutter_actor_set_x_align (label, CLUTTER_ACTOR_ALIGN_CENTER);
clutter_actor_set_y_expand (label, TRUE);
clutter_actor_set_y_align (label, CLUTTER_ACTOR_ALIGN_START);
clutter_actor_add_child (box, label);
clutter_main ();
return EXIT_SUCCESS;
}
void xfdashboard_text_box_set_selection_background_color(XfdashboardTextBox *self, const ClutterColor *inColor)
{
XfdashboardTextBoxPrivate *priv;
ClutterColor selectionColor;
g_return_if_fail(XFDASHBOARD_IS_TEXT_BOX(self));
priv=self->priv;
/* Set value if changed */
if(priv->selectionBackgroundColor!=inColor ||
(priv->selectionBackgroundColor &&
inColor &&
!clutter_color_equal(inColor, priv->selectionBackgroundColor)))
{
/* Freeze notifications and collect them */
g_object_freeze_notify(G_OBJECT(self));
/* Release old color */
if(priv->selectionBackgroundColor)
{
clutter_color_free(priv->selectionBackgroundColor);
priv->selectionBackgroundColor=NULL;
/* Check if any selection color is set */
priv->selectionColorSet=((priv->selectionTextColor && priv->selectionBackgroundColor) ? TRUE : FALSE);
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardTextBoxProperties[PROP_SELECTION_BACKGROUND_COLOR]);
}
/* Set new color if available */
if(inColor)
{
priv->selectionBackgroundColor=clutter_color_copy(inColor);
clutter_text_set_selection_color(CLUTTER_TEXT(priv->actorTextBox), priv->selectionBackgroundColor);
/* Any selection color was set */
priv->selectionColorSet=TRUE;
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardTextBoxProperties[PROP_SELECTION_BACKGROUND_COLOR]);
}
/* Selection text and background color is inverted text color if not set */
if(!priv->selectionColorSet)
{
selectionColor.red=0xff-priv->textColor->red;
selectionColor.green=0xff-priv->textColor->green;
selectionColor.blue=0xff-priv->textColor->blue;
selectionColor.alpha=priv->textColor->alpha;
clutter_text_set_selected_text_color(CLUTTER_TEXT(priv->actorTextBox), &selectionColor);
/* Selection color is the same as text color */
clutter_text_set_selection_color(CLUTTER_TEXT(priv->actorTextBox), priv->textColor);
}
/* Redraw actor in new color */
clutter_actor_queue_redraw(CLUTTER_ACTOR(self));
/* Thaw notifications and send them now */
g_object_thaw_notify(G_OBJECT(self));
}
}
static void
mx_scroll_view_paint (ClutterActor *actor)
{
ClutterActorBox box;
gfloat w, h;
MxAdjustment *vadjustment = NULL, *hadjustment = NULL;
MxScrollViewPrivate *priv = MX_SCROLL_VIEW (actor)->priv;
ClutterColor *color;
guint8 r, g, b;
const gint shadow = 15;
mx_stylable_get (MX_STYLABLE (actor), "background-color", &color, NULL);
r = color->red;
g = color->green;
b = color->blue;
clutter_color_free (color);
/* MxBin will paint the child */
CLUTTER_ACTOR_CLASS (mx_scroll_view_parent_class)->paint (actor);
clutter_actor_get_allocation_box (actor, &box);
w = box.x2 - box.x1;
h = box.y2 - box.y1;
/* paint our custom children */
if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
{
clutter_actor_paint (priv->hscroll);
clutter_actor_get_allocation_box (priv->hscroll, &box);
h -= (box.y2 - box.y1);
hadjustment = mx_scroll_bar_get_adjustment (MX_SCROLL_BAR(priv->hscroll));
}
if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
{
clutter_actor_paint (priv->vscroll);
clutter_actor_get_allocation_box (priv->vscroll, &box);
w -= (box.x2 - box.x1);
vadjustment = mx_scroll_bar_get_adjustment (MX_SCROLL_BAR(priv->vscroll));
}
/* set up the matrial using dummy set source call */
cogl_set_source_color4ub (0, 0, 0, 0);
if (vadjustment)
{
gdouble len;
if ((len = mx_adjustment_get_value (vadjustment)) > 0)
{
CoglTextureVertex top[4] = { { 0,}, };
if (len > shadow)
len = shadow;
top[1].x = w;
top[2].x = w;
top[2].y = len;
top[3].y = len;
cogl_color_set_from_4ub (&top[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&top[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&top[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&top[3].color, 0, 0, 0, 0);
cogl_polygon (top, 4, TRUE);
}
if ((len = (mx_adjustment_get_upper (vadjustment)
- mx_adjustment_get_page_size (vadjustment))
- mx_adjustment_get_value (vadjustment)) > 0)
{
CoglTextureVertex bottom[4] = { {0, }, };
if (len > shadow)
len = shadow;
bottom[0].x = w;
bottom[0].y = h;
bottom[1].y = h;
bottom[2].y = h - len;
bottom[3].x = w;
bottom[3].y = h - len;
cogl_color_set_from_4ub (&bottom[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&bottom[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&bottom[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&bottom[3].color, 0, 0, 0, 0);
cogl_polygon (bottom, 4, TRUE);
}
}
if (hadjustment)
{
gdouble len;
if ((len = mx_adjustment_get_value (hadjustment)) > 0)
{
CoglTextureVertex left[4] = { { 0, }, };
if (len > shadow)
len = shadow;
left[0].y = h;
left[2].x = len;
left[3].x = len;
left[3].y = h;
cogl_color_set_from_4ub (&left[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&left[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&left[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&left[3].color, 0, 0, 0, 0);
cogl_polygon (left, 4, TRUE);
}
if ((len = (mx_adjustment_get_upper (hadjustment)
- mx_adjustment_get_page_size (hadjustment))
- mx_adjustment_get_value (hadjustment)) > 0)
{
CoglTextureVertex right[4] = { { 0, }, };
if (len > shadow)
len = shadow;
right[0].x = w;
right[1].x = w;
right[1].y = h;
right[2].x = w - len;
right[2].y = h;
right[3].x = w - len;
cogl_color_set_from_4ub (&right[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&right[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&right[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&right[3].color, 0, 0, 0, 0);
cogl_polygon (right, 4, TRUE);
}
}
}
G_MODULE_EXPORT int
test_bin_layout_main (int argc, char *argv[])
{
ClutterActor *stage, *box, *rect;
ClutterLayoutManager *layout;
ClutterColor stage_color = { 0xe0, 0xf2, 0xfc, 0xff };
ClutterColor bg_color = { 0xcc, 0xcc, 0xcc, 0x99 };
ClutterColor *color;
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Box test");
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
clutter_actor_set_size (stage, 640, 480);
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
box = clutter_box_new (layout);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);
clutter_actor_set_anchor_point_from_gravity (box, CLUTTER_GRAVITY_CENTER);
clutter_actor_set_position (box, 320, 240);
clutter_actor_set_reactive (box, TRUE);
clutter_actor_set_name (box, "box");
rect = make_background (&bg_color, 200, 200);
/* first method: use clutter_box_pack() */
clutter_box_pack (CLUTTER_BOX (box), rect,
"x-align", CLUTTER_BIN_ALIGNMENT_FILL,
"y-align", CLUTTER_BIN_ALIGNMENT_FILL,
NULL);
clutter_actor_lower_bottom (rect);
clutter_actor_set_name (rect, "background");
{
ClutterActor *tex;
GError *error;
gchar *file;
error = NULL;
file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);
tex = clutter_texture_new_from_file (file, &error);
if (error)
g_error ("Unable to create texture: %s", error->message);
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (tex), TRUE);
/* second method: use clutter_bin_layout_add() */
clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (layout), tex,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
clutter_actor_raise (tex, rect);
clutter_actor_set_width (tex, 175);
clutter_actor_set_name (tex, "texture");
g_free (file);
}
color = clutter_color_new (g_random_int_range (0, 255),
g_random_int_range (0, 255),
g_random_int_range (0, 255),
224);
rect = clutter_rectangle_new_with_color (color);
/* third method: container_add() and set_alignment() */
clutter_container_add_actor (CLUTTER_CONTAINER (box), rect);
clutter_bin_layout_set_alignment (CLUTTER_BIN_LAYOUT (layout), rect,
CLUTTER_BIN_ALIGNMENT_END,
CLUTTER_BIN_ALIGNMENT_END);
clutter_actor_set_size (rect, 50, 50);
clutter_actor_set_opacity (rect, 0);
clutter_actor_raise_top (rect);
clutter_actor_set_name (rect, "emblem");
g_signal_connect (box,
"enter-event", G_CALLBACK (on_box_enter),
rect);
g_signal_connect (box,
"leave-event", G_CALLBACK (on_box_leave),
rect);
clutter_actor_show_all (stage);
clutter_main ();
clutter_color_free (color);
return EXIT_SUCCESS;
}
void IoClutterColor_free(IoClutterColor *self) {
clutter_color_free(&(IOCCOLOR(self)));
io_free(IoObject_dataPointer(self));
}
