/* Set focus to actor */
static void _xfdashboard_text_box_focusable_set_focus(XfdashboardFocusable *inFocusable)
{
XfdashboardTextBox *self;
XfdashboardTextBoxPrivate *priv;
XfdashboardFocusableInterface *selfIface;
XfdashboardFocusableInterface *parentIface;
ClutterStage *stage;
g_return_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable));
g_return_if_fail(XFDASHBOARD_IS_TEXT_BOX(inFocusable));
self=XFDASHBOARD_TEXT_BOX(inFocusable);
priv=self->priv;
/* Call parent class interface function */
selfIface=XFDASHBOARD_FOCUSABLE_GET_IFACE(inFocusable);
parentIface=g_type_interface_peek_parent(selfIface);
if(parentIface && parentIface->set_focus)
{
parentIface->set_focus(inFocusable);
}
/* Get stage of actor to tell it where the keyboard focus to set to */
stage=CLUTTER_STAGE(clutter_actor_get_stage(CLUTTER_ACTOR(self)));
if(!stage)
{
g_warning(_("Focusable actor %s is not on a stage"),
G_OBJECT_TYPE_NAME(self));
return;
}
clutter_stage_set_key_focus(stage, CLUTTER_ACTOR(priv->actorTextBox));
}
/* Virtual function "can_focus" was called */
static gboolean _xfdashboard_text_box_focusable_can_focus(XfdashboardFocusable *inFocusable)
{
XfdashboardTextBox *self;
XfdashboardTextBoxPrivate *priv;
XfdashboardFocusableInterface *selfIface;
XfdashboardFocusableInterface *parentIface;
g_return_val_if_fail(XFDASHBOARD_IS_TEXT_BOX(inFocusable), CLUTTER_EVENT_PROPAGATE);
self=XFDASHBOARD_TEXT_BOX(inFocusable);
priv=self->priv;
/* Check if actor could be focused at all ... */
selfIface=XFDASHBOARD_FOCUSABLE_GET_IFACE(inFocusable);
parentIface=g_type_interface_peek_parent(selfIface);
if(parentIface && parentIface->can_focus)
{
if(!parentIface->can_focus(inFocusable)) return(FALSE);
}
/* ... then only an editable text box can be focused */
if(priv->isEditable) return(TRUE);
/* If we get here this actor cannot be focused */
return(FALSE);
}
/* Get preferred width/height */
static void _xfdashboard_text_box_get_preferred_height(ClutterActor *self,
gfloat inForWidth,
gfloat *outMinHeight,
gfloat *outNaturalHeight)
{
XfdashboardTextBoxPrivate *priv=XFDASHBOARD_TEXT_BOX(self)->priv;
gfloat minHeight, naturalHeight;
gfloat childMinHeight, childNaturalHeight;
minHeight=naturalHeight=0.0f;
/* Regardless if text or hint label is visible or not. Both actors' height
* will be requested and the larger one used */
clutter_actor_get_preferred_height(CLUTTER_ACTOR(priv->actorTextBox),
inForWidth,
&minHeight, &naturalHeight);
clutter_actor_get_preferred_height(CLUTTER_ACTOR(priv->actorHintLabel),
inForWidth,
&childMinHeight, &childNaturalHeight);
if(childMinHeight>minHeight) minHeight=childMinHeight;
if(childNaturalHeight>naturalHeight) naturalHeight=childNaturalHeight;
// Add padding
minHeight+=2*priv->padding;
naturalHeight+=2*priv->padding;
/* Store sizes computed */
if(outMinHeight) *outMinHeight=minHeight;
if(outNaturalHeight) *outNaturalHeight=naturalHeight;
}
/* Destroy this actor */
static void _xfdashboard_text_box_destroy(ClutterActor *self)
{
/* Destroy each child actor when this actor is destroyed */
XfdashboardTextBoxPrivate *priv=XFDASHBOARD_TEXT_BOX(self)->priv;
if(priv->actorTextBox)
{
clutter_actor_destroy(CLUTTER_ACTOR(priv->actorTextBox));
priv->actorTextBox=NULL;
}
if(priv->actorHintLabel)
{
clutter_actor_destroy(CLUTTER_ACTOR(priv->actorHintLabel));
priv->actorHintLabel=NULL;
}
if(priv->actorPrimaryIcon)
{
clutter_actor_destroy(CLUTTER_ACTOR(priv->actorPrimaryIcon));
priv->actorPrimaryIcon=NULL;
}
if(priv->actorSecondaryIcon)
{
clutter_actor_destroy(CLUTTER_ACTOR(priv->actorSecondaryIcon));
priv->actorSecondaryIcon=NULL;
}
/* Call parent's class destroy method */
CLUTTER_ACTOR_CLASS(xfdashboard_text_box_parent_class)->destroy(self);
}
/* Show all children of this one */
static void _xfdashboard_text_box_show(ClutterActor *inActor)
{
XfdashboardTextBox *self=XFDASHBOARD_TEXT_BOX(inActor);
XfdashboardTextBoxPrivate *priv=self->priv;
/* Show icons */
if(priv->showPrimaryIcon!=FALSE)
{
clutter_actor_show(CLUTTER_ACTOR(priv->actorPrimaryIcon));
}
if(priv->showSecondaryIcon!=FALSE)
{
clutter_actor_show(CLUTTER_ACTOR(priv->actorSecondaryIcon));
}
/* Show hint label depending if text box is empty or not */
if(xfdashboard_text_box_is_empty(self) && priv->isEditable)
{
clutter_actor_show(priv->actorHintLabel);
}
else
{
clutter_actor_hide(priv->actorHintLabel);
}
clutter_actor_show(CLUTTER_ACTOR(self));
}
/* 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);
}
/* Actor got key focus */
static void _xfdashboard_text_box_key_focus_in(ClutterActor *inActor)
{
XfdashboardTextBox *self=XFDASHBOARD_TEXT_BOX(inActor);
XfdashboardTextBoxPrivate *priv=self->priv;
ClutterStage *stage;
XfdashboardFocusManager *focusManager;
/* Push key focus forward to text box */
stage=CLUTTER_STAGE(clutter_actor_get_stage(inActor));
clutter_stage_set_key_focus(stage, priv->actorTextBox);
/* Update focus in focus manager */
focusManager=xfdashboard_focus_manager_get_default();
xfdashboard_focus_manager_set_focus(focusManager, XFDASHBOARD_FOCUSABLE(self));
g_object_unref(focusManager);
}
/* Virtual function "handle_key_event" was called */
static gboolean _xfdashboard_text_box_focusable_handle_key_event(XfdashboardFocusable *inFocusable,
const ClutterEvent *inEvent)
{
XfdashboardTextBox *self;
XfdashboardTextBoxPrivate *priv;
gboolean result;
g_return_val_if_fail(XFDASHBOARD_IS_TEXT_BOX(inFocusable), CLUTTER_EVENT_PROPAGATE);
self=XFDASHBOARD_TEXT_BOX(inFocusable);
priv=self->priv;
result=CLUTTER_EVENT_PROPAGATE;
/* Push event to real text box if available */
if(priv->actorTextBox)
{
result=clutter_actor_event(priv->actorTextBox, inEvent, FALSE);
}
/* Return event handling result */
return(result);
}
/* A key was released */
static gboolean _xfdashboard_text_box_on_key_release_event(ClutterActor *inActor,
ClutterEvent *inEvent,
gpointer inUserData)
{
XfdashboardTextBox *self;
XfdashboardTextBoxPrivate *priv;
gboolean result;
g_return_val_if_fail(XFDASHBOARD_IS_TEXT_BOX(inActor), CLUTTER_EVENT_PROPAGATE);
self=XFDASHBOARD_TEXT_BOX(inActor);
priv=self->priv;
result=CLUTTER_EVENT_PROPAGATE;
/* Push event to real text box if available */
if(priv->actorTextBox)
{
result=clutter_actor_event(priv->actorTextBox, inEvent, FALSE);
}
/* Return event handling result */
return(result);
}
static void _xfdashboard_text_box_get_property(GObject *inObject,
guint inPropID,
GValue *outValue,
GParamSpec *inSpec)
{
XfdashboardTextBox *self=XFDASHBOARD_TEXT_BOX(inObject);
XfdashboardTextBoxPrivate *priv=self->priv;
switch(inPropID)
{
case PROP_PADDING:
g_value_set_float(outValue, priv->padding);
break;
case PROP_SPACING:
g_value_set_float(outValue, priv->spacing);
break;
case PROP_EDITABLE:
g_value_set_boolean(outValue, priv->isEditable);
break;
case PROP_PRIMARY_ICON_NAME:
g_value_set_string(outValue, priv->primaryIconName);
break;
case PROP_SECONDARY_ICON_NAME:
g_value_set_string(outValue, priv->secondaryIconName);
break;
case PROP_TEXT:
g_value_set_string(outValue, clutter_text_get_text(CLUTTER_TEXT(priv->actorTextBox)));
break;
case PROP_TEXT_FONT:
g_value_set_string(outValue, priv->textFont);
break;
case PROP_TEXT_COLOR:
clutter_value_set_color(outValue, priv->textColor);
break;
case PROP_SELECTION_TEXT_COLOR:
clutter_value_set_color(outValue, priv->selectionTextColor);
break;
case PROP_SELECTION_BACKGROUND_COLOR:
clutter_value_set_color(outValue, priv->selectionBackgroundColor);
break;
case PROP_HINT_TEXT:
g_value_set_string(outValue, clutter_text_get_text(CLUTTER_TEXT(priv->actorHintLabel)));
break;
case PROP_HINT_TEXT_FONT:
g_value_set_string(outValue, priv->hintTextFont);
break;
case PROP_HINT_TEXT_COLOR:
clutter_value_set_color(outValue, priv->hintTextColor);
break;
case PROP_HINT_TEXT_SET:
g_value_set_boolean(outValue, priv->hintTextSet);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
break;
}
}
/* Set/get properties */
static void _xfdashboard_text_box_set_property(GObject *inObject,
guint inPropID,
const GValue *inValue,
GParamSpec *inSpec)
{
XfdashboardTextBox *self=XFDASHBOARD_TEXT_BOX(inObject);
switch(inPropID)
{
case PROP_PADDING:
xfdashboard_text_box_set_padding(self, g_value_get_float(inValue));
break;
case PROP_SPACING:
xfdashboard_text_box_set_spacing(self, g_value_get_float(inValue));
break;
case PROP_EDITABLE:
xfdashboard_text_box_set_editable(self, g_value_get_boolean(inValue));
break;
case PROP_PRIMARY_ICON_NAME:
xfdashboard_text_box_set_primary_icon(self, g_value_get_string(inValue));
break;
case PROP_SECONDARY_ICON_NAME:
xfdashboard_text_box_set_secondary_icon(self, g_value_get_string(inValue));
break;
case PROP_TEXT:
xfdashboard_text_box_set_text(self, g_value_get_string(inValue));
break;
case PROP_TEXT_FONT:
xfdashboard_text_box_set_text_font(self, g_value_get_string(inValue));
break;
case PROP_TEXT_COLOR:
xfdashboard_text_box_set_text_color(self, clutter_value_get_color(inValue));
break;
case PROP_SELECTION_TEXT_COLOR:
xfdashboard_text_box_set_selection_text_color(self, clutter_value_get_color(inValue));
break;
case PROP_SELECTION_BACKGROUND_COLOR:
xfdashboard_text_box_set_selection_background_color(self, clutter_value_get_color(inValue));
break;
case PROP_HINT_TEXT:
xfdashboard_text_box_set_hint_text(self, g_value_get_string(inValue));
break;
case PROP_HINT_TEXT_FONT:
xfdashboard_text_box_set_hint_text_font(self, g_value_get_string(inValue));
break;
case PROP_HINT_TEXT_COLOR:
xfdashboard_text_box_set_hint_text_color(self, clutter_value_get_color(inValue));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
break;
}
}
/* Allocate position and size of actor and its children */
static void _xfdashboard_text_box_allocate(ClutterActor *self,
const ClutterActorBox *inBox,
ClutterAllocationFlags inFlags)
{
XfdashboardTextBoxPrivate *priv=XFDASHBOARD_TEXT_BOX(self)->priv;
ClutterActorBox *box=NULL;
gfloat left, right, top, bottom;
gfloat iconWidth, iconHeight;
/* Chain up to store the allocation of the actor */
CLUTTER_ACTOR_CLASS(xfdashboard_text_box_parent_class)->allocate(self, inBox, inFlags);
/* Initialize bounding box of allocation used in actors */
left=top=priv->padding;
right=clutter_actor_box_get_width(inBox)-priv->padding;
bottom=clutter_actor_box_get_height(inBox)-priv->padding;
/* Set allocation of primary icon if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorPrimaryIcon))
{
gfloat childRight;
/* Get scale size of primary icon */
iconWidth=iconHeight=0.0f;
clutter_actor_get_size(priv->actorPrimaryIcon, &iconWidth, &iconHeight);
if(iconHeight>0.0f) iconWidth=(bottom-top)*(iconWidth/iconHeight);
/* Set allocation */
childRight=left+iconWidth;
box=clutter_actor_box_new(floor(left), floor(top), floor(childRight), floor(bottom));
clutter_actor_allocate(CLUTTER_ACTOR(priv->actorPrimaryIcon), box, inFlags);
clutter_actor_box_free(box);
/* Adjust bounding box for next actor */
left=childRight+priv->spacing;
}
/* Set allocation of secondary icon if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorSecondaryIcon))
{
gfloat childLeft;
/* Get scale size of secondary icon */
iconWidth=0.0f;
clutter_actor_get_size(priv->actorSecondaryIcon, &iconWidth, &iconHeight);
if(iconHeight>0.0f) iconWidth=(bottom-top)*(iconWidth/iconHeight);
/* Set allocation */
childLeft=right-iconWidth;
box=clutter_actor_box_new(floor(childLeft), floor(top), floor(right), floor(bottom));
clutter_actor_allocate(CLUTTER_ACTOR(priv->actorSecondaryIcon), box, inFlags);
clutter_actor_box_free(box);
/* Adjust bounding box for next actor */
right=childLeft-priv->spacing;
}
/* Set allocation of editable text box if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorTextBox))
{
gfloat textHeight;
/* Get height of text */
clutter_actor_get_preferred_size(CLUTTER_ACTOR(priv->actorTextBox),
NULL, NULL,
NULL, &textHeight);
/* Set allocation */
box=clutter_actor_box_new(floor(left), floor(bottom-textHeight), floor(right), floor(bottom));
clutter_actor_allocate(CLUTTER_ACTOR(priv->actorTextBox), box, inFlags);
clutter_actor_box_free(box);
}
/* Set allocation of hint label if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorHintLabel))
{
gfloat textHeight;
/* Get height of label */
clutter_actor_get_preferred_size(CLUTTER_ACTOR(priv->actorHintLabel),
NULL, NULL,
NULL, &textHeight);
/* Set allocation */
box=clutter_actor_box_new(floor(left), floor(bottom-textHeight), floor(right), floor(bottom));
clutter_actor_allocate(CLUTTER_ACTOR(priv->actorHintLabel), box, inFlags);
clutter_actor_box_free(box);
}
}
static void _xfdashboard_text_box_get_preferred_width(ClutterActor *self,
gfloat inForHeight,
gfloat *outMinWidth,
gfloat *outNaturalWidth)
{
XfdashboardTextBoxPrivate *priv=XFDASHBOARD_TEXT_BOX(self)->priv;
gfloat minWidth, naturalWidth;
gfloat childMinWidth, childNaturalWidth;
gint numberChildren=0;
minWidth=naturalWidth=0.0f;
/* Determine size of primary icon if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorPrimaryIcon))
{
clutter_actor_get_preferred_width(CLUTTER_ACTOR(priv->actorPrimaryIcon),
inForHeight,
&childMinWidth, &childNaturalWidth);
minWidth+=childMinWidth;
naturalWidth+=childNaturalWidth;
numberChildren++;
}
/* Determine size of editable text box if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorTextBox))
{
clutter_actor_get_preferred_width(CLUTTER_ACTOR(priv->actorTextBox),
inForHeight,
&childMinWidth, &childNaturalWidth);
minWidth+=childMinWidth;
naturalWidth+=childNaturalWidth;
numberChildren++;
}
/* Determine size of hint label if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorHintLabel))
{
clutter_actor_get_preferred_width(CLUTTER_ACTOR(priv->actorHintLabel),
inForHeight,
&childMinWidth, &childNaturalWidth);
minWidth+=childMinWidth;
naturalWidth+=childNaturalWidth;
numberChildren++;
}
/* Determine size of secondary icon if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorSecondaryIcon))
{
clutter_actor_get_preferred_width(CLUTTER_ACTOR(priv->actorSecondaryIcon),
inForHeight,
&childMinWidth, &childNaturalWidth);
minWidth+=childMinWidth;
naturalWidth+=childNaturalWidth;
}
/* Add spacing for each child except the last one */
if(numberChildren>1)
{
numberChildren--;
minWidth+=(numberChildren*priv->spacing);
naturalWidth+=(numberChildren*priv->spacing);
}
// Add padding
minWidth+=2*priv->padding;
naturalWidth+=2*priv->padding;
/* Store sizes computed */
if(outMinWidth) *outMinWidth=minWidth;
if(outNaturalWidth) *outNaturalWidth=naturalWidth;
}
