/* 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)); }