/**
* mpl_panel_clutter_load_base_style:
*
* Loads the base css style for the Panel. This function is called automatically
* when the panel is constructed, so it is rarely necessary to call this from
* the panel application. Calling this function mutliple times is safe (nop).
*/
void
mpl_panel_clutter_load_base_style (void)
{
static gboolean already_loaded = FALSE;
if (!already_loaded)
{
GError *error = NULL;
/* Load in a base cache and a base style */
mx_texture_cache_load_cache (mx_texture_cache_get_default (),
MX_CACHE);
#if 0
mx_style_load_from_file (mx_style_get_default (),
THEMEDIR "/theme.css", NULL);
#endif
mx_style_load_from_file (mx_style_get_default (),
DAWATI_RUNTIME_THEME_DIR "/shared/shared.css",
&error);
if (error)
{
g_warning ("Error loading Dawati style: %s", error->message);
g_clear_error (&error);
}
already_loaded = TRUE;
}
}
static void
mex_tile_style_changed_cb (MexTile *self, MxStyleChangedFlags flags)
{
MexTilePrivate *priv = self->priv;
MxBorderImage *image;
if (priv->header_padding)
{
g_boxed_free (MX_TYPE_PADDING, priv->header_padding);
priv->header_padding = NULL;
}
if (priv->header_background_color)
{
g_boxed_free (CLUTTER_TYPE_COLOR, priv->header_background_color);
priv->header_background_color = NULL;
}
mx_stylable_get (MX_STYLABLE (self),
"x-mex-header-background", &image,
"x-mex-header-background-color", &priv->header_background_color,
"x-mex-header-padding", &priv->header_padding,
NULL);
mx_stylable_apply_clutter_text_attributes (MX_STYLABLE (self),
CLUTTER_TEXT (priv->label));
mx_stylable_apply_clutter_text_attributes (MX_STYLABLE (self),
CLUTTER_TEXT (priv->secondary_label));
if (image && image->uri)
{
CoglObject *background;
background =
mx_texture_cache_get_cogl_texture (mx_texture_cache_get_default (),
image->uri);
cogl_material_set_layer (priv->material, 0, background);
}
else
{
if (cogl_material_get_n_layers (priv->material))
cogl_material_remove_layer (priv->material, 0);
}
if (image)
g_boxed_free (MX_TYPE_BORDER_IMAGE, image);
if (priv->icon1)
mx_stylable_style_changed (MX_STYLABLE (priv->icon1), flags);
if (priv->icon2)
mx_stylable_style_changed (MX_STYLABLE (priv->icon2), flags);
clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
}
void
mnb_launcher_button_set_icon (MnbLauncherButton *self,
const gchar *icon_file,
gint icon_size)
{
MxTextureCache *texture_cache;
GError *error = NULL;
if (self->priv->icon_file)
{
g_free (self->priv->icon_file);
self->priv->icon_file = NULL;
}
if (self->priv->icon)
{
clutter_actor_destroy (self->priv->icon);
self->priv->icon = NULL;
}
self->priv->icon_file = g_strdup (icon_file);
self->priv->icon_size = icon_size;
error = NULL;
texture_cache = mx_texture_cache_get_default ();
self->priv->icon = mx_texture_cache_get_actor (texture_cache,
self->priv->icon_file);
if (error) {
g_warning (G_STRLOC "%s", error->message);
g_clear_error (&error);
}
if (self->priv->icon) {
if (self->priv->icon_size > -1) {
clutter_actor_set_size (self->priv->icon,
self->priv->icon_size,
self->priv->icon_size);
}
mx_table_insert_actor_with_properties (MX_TABLE (self),
CLUTTER_ACTOR (self->priv->icon),
0, 0,
"x-align", MX_ALIGN_MIDDLE,
"x-expand", FALSE,
"x-fill", FALSE,
"y-align", MX_ALIGN_MIDDLE,
"y-expand", FALSE,
"y-fill", FALSE,
NULL);
}
}
/**
* mx_icon_theme_lookup:
* @theme: an #MxIconTheme
* @icon_name: The name of the icon
* @size: The desired size of the icon
*
* If the icon is available, returns a #CoglHandle of the icon.
*
* Return value: (transfer none): a #CoglHandle of the icon, or %NULL.
*/
CoglHandle
mx_icon_theme_lookup (MxIconTheme *theme,
const gchar *icon_name,
gint size)
{
MxTextureCache *texture_cache;
MxIconData *icon_data;
g_return_val_if_fail (MX_IS_ICON_THEME (theme), NULL);
g_return_val_if_fail (icon_name, NULL);
g_return_val_if_fail (size > 0, NULL);
if (!(icon_data = mx_icon_theme_lookup_internal (theme, icon_name, size)))
return NULL;
texture_cache = mx_texture_cache_get_default ();
return mx_texture_cache_get_cogl_texture (texture_cache, icon_data->path);
}
static void
mx_combo_box_style_changed (MxComboBox *combo, MxStyleChangedFlags flags)
{
MxBorderImage *marker_filename;
gint spacing;
MxComboBoxPrivate *priv = combo->priv;
mx_stylable_get (MX_STYLABLE (combo),
"x-mx-spacing", &spacing,
"x-mx-marker-image", &marker_filename,
NULL);
if (spacing != priv->spacing)
priv->spacing = spacing;
if (priv->marker)
{
clutter_actor_destroy (priv->marker);
priv->marker = NULL;
}
if (marker_filename)
{
MxTextureCache *cache = mx_texture_cache_get_default ();
priv->marker = (ClutterActor *)
mx_texture_cache_get_texture (cache, marker_filename->uri);
if (priv->marker)
clutter_actor_add_child (CLUTTER_ACTOR (combo), priv->marker);
g_boxed_free (MX_TYPE_BORDER_IMAGE, marker_filename);
}
mx_stylable_apply_clutter_text_attributes (MX_STYLABLE (combo),
CLUTTER_TEXT (combo->priv->label));
/* make sure the popup is also up-to-date */
mx_stylable_style_changed (MX_STYLABLE (mx_widget_get_menu (MX_WIDGET (combo))),
flags | MX_STYLE_CHANGED_FORCE);
clutter_actor_queue_relayout (CLUTTER_ACTOR (combo));
}
/**
* mpl_panel_clutter_load_base_style:
*
* Loads the base css style for the Panel. This function is called automatically
* when the panel is constructed, so it is rarely necessary to call this from
* the panel application. Calling this function mutliple times is safe (nop).
*/
void
mpl_panel_clutter_load_base_style (void)
{
static gboolean already_loaded = FALSE;
if (!already_loaded)
{
GError *error = NULL;
gboolean envset;
/* Load in a base cache and a base style */
mx_texture_cache_load_cache (mx_texture_cache_get_default (),
MX_CACHE);
#if 0
mx_style_load_from_file (mx_style_get_default (),
THEMEDIR "/theme.css", NULL);
#endif
/* Won't override MX_RC_FILE env if it's alread set */
envset = g_setenv ("MX_RC_FILE", DAWATI_MX_THEME "/default.css", FALSE);
if (!envset)
g_message ("MX_RC_FILE not set");
mx_style_load_from_file (mx_style_get_default (),
DAWATI_RUNTIME_THEME_DIR "/shared/shared.css",
&error);
if (error)
{
g_warning ("Error loading Dawati style: %s", error->message);
g_clear_error (&error);
}
already_loaded = TRUE;
}
}
static void
mx_button_style_changed (MxWidget *widget)
{
MxButton *button = MX_BUTTON (widget);
MxButtonPrivate *priv = button->priv;
MxBorderImage *content_image = NULL;
/* update the label styling */
mx_button_update_label_style (button);
g_free (priv->style_icon_name);
mx_stylable_get (MX_STYLABLE (widget),
"x-mx-content-image", &content_image,
"x-mx-icon-name", &priv->style_icon_name,
"x-mx-icon-size", &priv->style_icon_size,
NULL);
if (content_image && content_image->uri)
{
if (priv->content_image)
{
clutter_actor_remove_child (CLUTTER_ACTOR (widget),
priv->content_image);
}
priv->content_image =
(ClutterActor*) mx_texture_cache_get_texture (mx_texture_cache_get_default (),
content_image->uri);
if (priv->content_image)
clutter_actor_add_child (CLUTTER_ACTOR (widget), priv->content_image);
else
g_warning ("Could not load content image \"%s\"", content_image->uri);
g_boxed_free (MX_TYPE_BORDER_IMAGE, content_image);
return;
}
else
{
/* remove any previous content image */
if (priv->content_image)
{
clutter_actor_remove_child (CLUTTER_ACTOR (widget),
priv->content_image);
priv->content_image = NULL;
}
if (content_image)
g_boxed_free (MX_TYPE_BORDER_IMAGE, content_image);
}
if (priv->icon_size == 0)
mx_icon_set_icon_size (MX_ICON (priv->icon), priv->style_icon_size);
if (priv->style_icon_name && !priv->icon_name)
{
mx_icon_set_icon_name (MX_ICON (priv->icon), priv->style_icon_name);
mx_button_update_contents (button);
}
}
int
main (int argc,
char **argv)
{
bool standalone = false;
char const *geometry = NULL;
int dpi = 0;
GOptionEntry _options[] = {
{ "standalone", 's', 0, G_OPTION_ARG_NONE, &standalone,
"Run as standalone app (for testing purpose)", NULL },
{ "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry,
"Window geometry in standalone mode", NULL },
#if CLUTTER_CHECK_VERSION(1, 3, 0)
{ "clutter-font-dpi", 'd', 0, G_OPTION_ARG_INT, &dpi,
"Set clutter font resolution to <dpi>", "<dpi>" },
#endif
{ NULL }
};
ClutterActor *shell;
GOptionContext *context;
ClutterInitError clutter_error;
GError *error = NULL;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
context = g_option_context_new ("- Dawati devices panel");
g_option_context_add_main_entries (context, _options, GETTEXT_PACKAGE);
g_option_context_add_group (context, clutter_get_option_group_without_init ());
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_critical ("%s %s", G_STRLOC, error->message);
g_critical ("Starting in standalone mode.");
g_clear_error (&error);
standalone = true;
}
g_option_context_free (context);
clutter_error = clutter_init (&argc, &argv);
if (clutter_error != CLUTTER_INIT_SUCCESS)
{
g_critical ("Unable to initialise clutter");
return EXIT_FAILURE;
}
notify_init (_("Dawati Devices Panel"));
/* Just for icon theme, no widgets. */
gtk_init (&argc, &argv);
if (dpi)
{
#if CLUTTER_CHECK_VERSION(1, 3, 0)
ClutterSettings *settings = clutter_settings_get_default ();
g_object_set (settings, "font-dpi", dpi * 1000, NULL);
#endif
}
/* Load base styling for default font size */
mpl_panel_clutter_load_base_style ();
mx_texture_cache_load_cache (mx_texture_cache_get_default (),
PKGDATADIR "/mx.cache");
mx_style_load_from_file (mx_style_get_default (),
THEMEDIR "/panel.css", NULL);
if (standalone)
{
ClutterActor *stage = clutter_stage_get_default ();
if (geometry)
{
int x, y;
unsigned int width, height;
XParseGeometry (geometry, &x, &y, &width, &height);
clutter_actor_set_size (stage, width, height);
} else
{
clutter_actor_set_size (stage, MPD_SHELL_WIDTH, MPD_SHELL_HEIGHT);
}
shell = mpd_shell_new ();
g_signal_connect (shell, "request-hide",
G_CALLBACK (_shell_request_hide_cb), NULL);
g_signal_connect (stage, "notify::width",
G_CALLBACK (_stage_width_notify_cb), shell);
g_signal_connect (stage, "notify::height",
G_CALLBACK (_stage_height_notify_cb), shell);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), shell);
clutter_actor_show_all (stage);
} else {
MplPanelClient *panel = mpd_panel_new ("devices",
_("devices"),
"devices-button");
shell = mpd_shell_new ();
mpd_shell_set_client (MPD_SHELL (shell), panel);
g_signal_connect (shell, "request-hide",
G_CALLBACK (_shell_request_hide_cb), panel);
g_signal_connect (shell, "request-show",
G_CALLBACK (_shell_request_show_cb), panel);
g_signal_connect (panel, "size-changed",
G_CALLBACK (_panel_set_size_cb), shell);
clutter_container_add_actor (CLUTTER_CONTAINER (panel), shell);
}
clutter_main ();
return EXIT_SUCCESS;
}
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));
}
static void
mex_content_box_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
MexContentBox *self = MEX_CONTENT_BOX (object);
MexContentBoxPrivate *priv = self->priv;
switch (property_id)
{
case PROP_MEDIA_URL:
g_free (priv->media_url);
priv->media_url = g_value_dup_string (value);
break;
case PROP_LOGO_URL:
/* FIXME: We want the logo URL to be file:// to share the same
* underlying texture. This should be handled by a generic "download
* queue + texture cache" thingy that caches the same URL to a local
* file and hands over a ClutterTexure (or a MagicTexture) with the
* same underlying Cogl texture */
{
MxTextureCache *cache;
ClutterActor *logo, *logo_frame;
GFile *file;
gchar *path;
gint bw, bh;
gfloat ratio;
g_free (priv->logo_url);
priv->logo_url = g_value_dup_string (value);
if (priv->logo_url == NULL)
break;
file = g_file_new_for_uri (priv->logo_url);
path = g_file_get_path (file);
g_object_unref (file);
if (G_UNLIKELY (path == NULL))
{
g_warning ("The logo URL provided is not local, refusing to load it");
break;
}
cache = mx_texture_cache_get_default ();
logo = mx_texture_cache_get_actor (cache, path);
if (G_UNLIKELY (logo == NULL))
{
g_warning ("Could not retrieve texture for %s", path);
break;
}
logo_frame = mex_aspect_frame_new ();
/* FIXME, had to set the size (for now?) provides some GObject properties
* to tune that? expose it in the CSS */
clutter_actor_set_size (logo_frame, 60, 40);
clutter_texture_get_base_size (CLUTTER_TEXTURE (logo), &bw, &bh);
ratio = bh / 40.;
mex_aspect_frame_set_ratio (MEX_ASPECT_FRAME (logo_frame), ratio);
clutter_container_add_actor (CLUTTER_CONTAINER (logo_frame), logo);
mex_tile_set_primary_icon (MEX_TILE (priv->tile), logo_frame);
}
break;
case PROP_THUMB_WIDTH:
priv->thumb_width = g_value_get_int (value);
g_object_set (G_OBJECT (priv->tile),
"thumb-width",
priv->thumb_width,
NULL);
break;
case PROP_THUMB_HEIGHT:
priv->thumb_height = g_value_get_int (value);
g_object_set (G_OBJECT (priv->tile),
"thumb-height",
priv->thumb_height,
NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
