/* Determine if actor can get the focus */ static gboolean _xfdashboard_viewpad_focusable_can_focus(XfdashboardFocusable *inFocusable) { XfdashboardViewpad *self; XfdashboardViewpadPrivate *priv; gboolean canFocus; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_VIEWPAD(inFocusable), FALSE); self=XFDASHBOARD_VIEWPAD(inFocusable); priv=self->priv; /* Set current focusable result to FALSE (not focusable). It will be set * to TRUE automatically if current active view is focusable and its * virtual function will also return TRUE. */ canFocus=FALSE; /* Viewpad is just a proxy for the current active view. * So check if current active view is focusable and call its * virtual function. */ if(priv->activeView && XFDASHBOARD_IS_FOCUSABLE(priv->activeView)) { canFocus=xfdashboard_focusable_can_focus(XFDASHBOARD_FOCUSABLE(priv->activeView)); } /* Return focusable state */ return(canFocus); }
/* Virtual function "handle_key_event" was called */ static gboolean _xfdashboard_viewpad_focusable_handle_key_event(XfdashboardFocusable *inFocusable, const ClutterEvent *inEvent) { XfdashboardViewpad *self; XfdashboardViewpadPrivate *priv; gboolean handledEvent; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), CLUTTER_EVENT_PROPAGATE); g_return_val_if_fail(XFDASHBOARD_IS_VIEWPAD(inFocusable), CLUTTER_EVENT_PROPAGATE); self=XFDASHBOARD_VIEWPAD(inFocusable); priv=self->priv; /* Set handled key eventto CLUTTER_EVENT_PROPAGATE. It might be set to * CLUTTER_EVENT_STOP if current active view is focusable and it handled * the key event by its virtual function. */ handledEvent=CLUTTER_EVENT_PROPAGATE; /* Viewpad is just a proxy for the current active view. * So check if current active view is focusable and call its * virtual function. */ if(priv->activeView && XFDASHBOARD_IS_FOCUSABLE(priv->activeView)) { handledEvent=xfdashboard_focusable_handle_key_event(XFDASHBOARD_FOCUSABLE(priv->activeView), inEvent); } /* Return focusable state */ return(handledEvent); }
/* Unset focus from actor */ static void _xfdashboard_viewpad_focusable_unset_focus(XfdashboardFocusable *inFocusable) { XfdashboardViewpad *self; XfdashboardViewpadPrivate *priv; XfdashboardFocusableInterface *selfIface; XfdashboardFocusableInterface *parentIface; g_return_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable)); g_return_if_fail(XFDASHBOARD_IS_VIEWPAD(inFocusable)); self=XFDASHBOARD_VIEWPAD(inFocusable); priv=self->priv; /* Viewpad is just a proxy for the current active view. * So check if current active view is focusable and call its * virtual function. */ if(priv->activeView && XFDASHBOARD_IS_FOCUSABLE(priv->activeView)) { /* Call virtual function of view to unset focus */ xfdashboard_focusable_unset_focus(XFDASHBOARD_FOCUSABLE(priv->activeView)); /* Call parent class interface function of this actor */ selfIface=XFDASHBOARD_FOCUSABLE_GET_IFACE(inFocusable); parentIface=g_type_interface_peek_parent(selfIface); if(parentIface && parentIface->unset_focus) { parentIface->unset_focus(inFocusable); } } }
/* Unset focus from actor */ static void _xfdashboard_text_box_focusable_unset_focus(XfdashboardFocusable *inFocusable) { ClutterActor *self; XfdashboardFocusableInterface *selfIface; XfdashboardFocusableInterface *parentIface; ClutterStage *stage; g_return_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable)); g_return_if_fail(XFDASHBOARD_IS_ACTOR(inFocusable)); self=CLUTTER_ACTOR(inFocusable); /* Call parent class interface function */ selfIface=XFDASHBOARD_FOCUSABLE_GET_IFACE(inFocusable); parentIface=g_type_interface_peek_parent(selfIface); if(parentIface && parentIface->unset_focus) { parentIface->unset_focus(inFocusable); } /* Get stage of actor to tell it where the keyboard focus to set to */ stage=CLUTTER_STAGE(clutter_actor_get_stage(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, NULL); }
/* Action signal to move selection was emitted */ static gboolean _xfdashboard_focusable_selection_move_to_direction(XfdashboardFocusable *self, XfdashboardFocusable *inSource, const gchar *inAction, ClutterEvent *inEvent, XfdashboardSelectionTarget inDirection) { ClutterActor *currentSelection; ClutterActor *newSelection; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(self), CLUTTER_EVENT_PROPAGATE); g_return_val_if_fail(inEvent, CLUTTER_EVENT_PROPAGATE); g_return_val_if_fail(inDirection<=XFDASHBOARD_SELECTION_TARGET_NEXT, CLUTTER_EVENT_PROPAGATE); /* Check for key press or release event */ if(clutter_event_type(inEvent)!=CLUTTER_KEY_PRESS && clutter_event_type(inEvent)!=CLUTTER_KEY_RELEASE) { return(CLUTTER_EVENT_PROPAGATE); } /* If focusable actor does not support selections return here with event unhandled */ if(!xfdashboard_focusable_supports_selection(self)) return(CLUTTER_EVENT_PROPAGATE); /* Find new selection */ currentSelection=xfdashboard_focusable_get_selection(self); newSelection=xfdashboard_focusable_find_selection(self, currentSelection, inDirection); /* Set new selection */ xfdashboard_focusable_set_selection(self, newSelection); /* All done so return and stop further processing of this action */ return(CLUTTER_EVENT_STOP); }
/* Call virtual function "activate_selection" */ gboolean xfdashboard_focusable_activate_selection(XfdashboardFocusable *self, ClutterActor *inSelection) { XfdashboardFocusableInterface *iface; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(self), FALSE); g_return_val_if_fail(CLUTTER_IS_ACTOR(inSelection), FALSE); iface=XFDASHBOARD_FOCUSABLE_GET_IFACE(self); /* If this focusable actor does not support selection we should ask for * the current selection and avoid the warning being printed if this * virtual function was not overridden. */ if(!xfdashboard_focusable_supports_selection(self)) return(FALSE); /* Call virtual function */ if(iface->activate_selection) { return(iface->activate_selection(self, inSelection)); } /* If we get here the virtual function was not overridden */ XFDASHBOARD_FOCUSABLE_WARN_NOT_IMPLEMENTED(self, "activate_selection"); return(FALSE); }
/* Default implementation of virtual function "activate_selection" */ static gboolean _xfdashboard_focusable_real_activate_selection(XfdashboardFocusable *self, ClutterActor *inSelection) { g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(self), FALSE); /* By default (if not overidden) this actor cannot activate any selection */ return(FALSE); }
/* Default implementation of virtual function "supports_selection" */ static gboolean _xfdashboard_focusable_real_supports_selection(XfdashboardFocusable *self) { g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(self), FALSE); /* By default (if not overidden) this actor does not support selection */ return(FALSE); }
/* Call virtual function "find_selection" */ ClutterActor* xfdashboard_focusable_find_selection(XfdashboardFocusable *self, ClutterActor *inSelection, XfdashboardSelectionTarget inDirection) { XfdashboardFocusableInterface *iface; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(self), NULL); g_return_val_if_fail(!inSelection || CLUTTER_IS_ACTOR(inSelection), NULL); g_return_val_if_fail(inDirection>XFDASHBOARD_SELECTION_TARGET_NONE, NULL); g_return_val_if_fail(inDirection<=XFDASHBOARD_SELECTION_TARGET_NEXT, NULL); iface=XFDASHBOARD_FOCUSABLE_GET_IFACE(self); /* If this focusable actor does not support selection we should ask for * the current selection and avoid the warning being printed if this * virtual function was not overridden. */ if(!xfdashboard_focusable_supports_selection(self)) return(NULL); /* Call virtual function */ if(iface->find_selection) { return(iface->find_selection(self, inSelection, inDirection)); } /* If we get here the virtual function was not overridden */ XFDASHBOARD_FOCUSABLE_WARN_NOT_IMPLEMENTED(self, "find_selection"); return(NULL); }
/* Default implementation of virtual function "can_focus" */ static gboolean _xfdashboard_focusable_real_can_focus(XfdashboardFocusable *self) { g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(self), FALSE); /* By default (if not overidden) an focusable actor cannot be focused */ return(FALSE); }
/* Check if this focusable actor has the focus */ static gboolean _xfdashboard_focusable_has_focus(XfdashboardFocusable *self) { XfdashboardFocusManager *focusManager; gboolean hasFocus; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(self), FALSE); hasFocus=FALSE; /* Ask focus manager which actor has the current focus and * check if it is this focusable actor. */ focusManager=xfdashboard_focus_manager_get_default(); hasFocus=xfdashboard_focus_manager_has_focus(focusManager, self); g_object_unref(focusManager); /* If focus manager says this focusable has not the focus then * it might a proxy who has the focus (as seen by focus manager) * but in real this focusable actor is the destination of the * proxy so check for style class "focus" being set. */ if(!hasFocus && XFDASHBOARD_IS_STYLABLE(self) && xfdashboard_stylable_has_class(XFDASHBOARD_STYLABLE(self), "focus")) { hasFocus=TRUE; } return(hasFocus); }
/* Determine if this actor supports selection */ static gboolean _xfdashboard_action_button_focusable_supports_selection(XfdashboardFocusable *inFocusable) { g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_ACTION_BUTTON(inFocusable), FALSE); /* This actor supports selection */ return(TRUE); }
/* Determine if this actor supports selection */ static gboolean _xfdashboard_workspace_selector_focusable_supports_selection(XfdashboardFocusable *inFocusable) { g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_WORKSPACE_SELECTOR(inFocusable), FALSE); /* This actor supports selection */ return(TRUE); }
/* Get current selection */ static ClutterActor* _xfdashboard_action_button_focusable_get_selection(XfdashboardFocusable *inFocusable) { XfdashboardActionButton *self; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), NULL); g_return_val_if_fail(XFDASHBOARD_IS_ACTION_BUTTON(inFocusable), NULL); self=XFDASHBOARD_ACTION_BUTTON(inFocusable); /* Return the actor itself as current selection */ return(CLUTTER_ACTOR(self)); }
/* Unset focus from actor */ static void _xfdashboard_actor_focusable_unset_focus(XfdashboardFocusable *self) { XfdashboardActor *actor; g_return_if_fail(XFDASHBOARD_IS_FOCUSABLE(self)); g_return_if_fail(XFDASHBOARD_IS_ACTOR(self)); actor=XFDASHBOARD_ACTOR(self); /* Set focus and style for focus */ xfdashboard_stylable_remove_class(XFDASHBOARD_STYLABLE(actor), "focus"); }
/* Determine if a specific actor has the focus */ gboolean xfdashboard_focus_manager_has_focus(XfdashboardFocusManager *self, XfdashboardFocusable *inFocusable) { XfdashboardFocusManagerPrivate *priv; g_return_val_if_fail(XFDASHBOARD_IS_FOCUS_MANAGER(self), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), FALSE); priv=self->priv; /* Return TRUE if given actor has the focus otherwise return FALSE */ return(priv->currentFocus==inFocusable ? TRUE : FALSE); }
/* A registered focusable actor is going to be destroyed so unregister it */ static void _xfdashboard_focus_manager_on_focusable_destroy(XfdashboardFocusManager *self, gpointer inUserData) { XfdashboardFocusable *focusable; g_return_if_fail(XFDASHBOARD_IS_FOCUS_MANAGER(self)); g_return_if_fail(XFDASHBOARD_IS_FOCUSABLE(inUserData)); focusable=XFDASHBOARD_FOCUSABLE(inUserData); /* Unregister going-to-be-destroyed focusable actor */ xfdashboard_focus_manager_unregister(self, focusable); }
/* Find previous focusable actor from given focusable actor */ XfdashboardFocusable* xfdashboard_focus_manager_get_previous_focusable(XfdashboardFocusManager *self, XfdashboardFocusable *inBeginFocusable) { XfdashboardFocusManagerPrivate *priv; GList *startIteration; GList *iter; XfdashboardFocusable *focusable; g_return_val_if_fail(XFDASHBOARD_IS_FOCUS_MANAGER(self), NULL); g_return_val_if_fail(!inBeginFocusable || XFDASHBOARD_IS_FOCUSABLE(inBeginFocusable), NULL); priv=self->priv; startIteration=NULL; /* Find starting point of iteration. * If starting focusable actor for search for next focusable actor is NULL * or if it is not registered start search at begin of list of focusable actors. */ if(inBeginFocusable) startIteration=g_list_find(priv->registeredFocusables, inBeginFocusable); if(startIteration) startIteration=g_list_previous(startIteration); else startIteration=priv->registeredFocusables; /* Iterate reverse through list of registered focusable actors beginning * at given focusable actor (might be begin of this list) and return * the first focusable actor which can be focused. */ for(iter=startIteration; iter; iter=g_list_previous(iter)) { focusable=(XfdashboardFocusable*)iter->data; /* If focusable can be focused then return it */ if(xfdashboard_focusable_can_focus(focusable)) return(focusable); } /* If we get here we have to continue search at the end of list * of registered focusable actors. Iterate reverse through list of * registered focusable actors from the beginning of that list up * to the given focusable actor and return the first focusable actor * which is focusable. */ for(iter=g_list_last(priv->registeredFocusables); iter!=startIteration; iter=g_list_previous(iter)) { focusable=(XfdashboardFocusable*)iter->data; /* If focusable can be focused then return it */ if(xfdashboard_focusable_can_focus(focusable)) return(focusable); } /* If we get here we could not find next focusable actor */ return(NULL); }
/* Check if given focusable actor is registered */ gboolean xfdashboard_focus_manager_is_registered(XfdashboardFocusManager *self, XfdashboardFocusable *inFocusable) { XfdashboardFocusManagerPrivate *priv; g_return_val_if_fail(XFDASHBOARD_IS_FOCUS_MANAGER(self), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), FALSE); priv=self->priv; /* If given focusable actor is in list of registered ones return TRUE */ if(g_list_find(priv->registeredFocusables, inFocusable)!=NULL) return(TRUE); /* If here get here the given focusable actor is not registered */ return(FALSE); }
/* Call virtual function "set_focus" */ void xfdashboard_focusable_set_focus(XfdashboardFocusable *self) { XfdashboardFocusableInterface *iface; ClutterActor *selection; g_return_if_fail(XFDASHBOARD_IS_FOCUSABLE(self)); iface=XFDASHBOARD_FOCUSABLE_GET_IFACE(self); /* Call virtual function */ if(iface->set_focus) { iface->set_focus(self); } /* Style newly focused actor */ if(XFDASHBOARD_IS_STYLABLE(self)) { xfdashboard_stylable_add_class(XFDASHBOARD_STYLABLE(self), "focus"); } /* If actor supports selection get current selection and style it */ if(xfdashboard_focusable_supports_selection(self)) { /* Get current selection. If no selection is available then select first item. */ selection=xfdashboard_focusable_get_selection(self); if(!selection) { selection=xfdashboard_focusable_find_selection(self, NULL, XFDASHBOARD_SELECTION_TARGET_FIRST); if(selection) xfdashboard_focusable_set_selection(self, selection); } /* Style selection if available */ if(selection && XFDASHBOARD_IS_STYLABLE(selection)) { xfdashboard_stylable_add_pseudo_class(XFDASHBOARD_STYLABLE(selection), "selected"); } g_debug("Set selection to %s for focused actor %s", G_OBJECT_TYPE_NAME(self), selection ? G_OBJECT_TYPE_NAME(selection) : "<nil>"); } /* Emit signal */ g_signal_emit(self, XfdashboardFocusableSignals[SIGNAL_FOCUS_GAINED], 0, self); g_debug("Emitted signal 'focus-gained' for focused actor %s", G_OBJECT_TYPE_NAME(self)); }
/* Activate selection */ static gboolean _xfdashboard_action_button_focusable_activate_selection(XfdashboardFocusable *inFocusable, ClutterActor *inSelection) { XfdashboardActionButton *self; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_ACTION_BUTTON(inFocusable), FALSE); g_return_val_if_fail(CLUTTER_IS_ACTOR(inSelection), FALSE); self=XFDASHBOARD_ACTION_BUTTON(inFocusable); /* Activate selection */ _xfdashboard_action_button_clicked(XFDASHBOARD_BUTTON(self)); return(TRUE); }
/* Activate selection */ static gboolean _xfdashboard_workspace_selector_focusable_activate_selection(XfdashboardFocusable *inFocusable, ClutterActor *inSelection) { XfdashboardWorkspaceSelector *self; XfdashboardLiveWorkspace *actor; XfdashboardWindowTrackerWorkspace *workspace; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_WORKSPACE_SELECTOR(inFocusable), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_LIVE_WORKSPACE(inSelection), FALSE); self=XFDASHBOARD_WORKSPACE_SELECTOR(inFocusable); actor=XFDASHBOARD_LIVE_WORKSPACE(inSelection); workspace=NULL; /* Check that selection is a child of this actor */ if(!xfdashboard_actor_contains_child_deep(CLUTTER_ACTOR(self), inSelection)) { ClutterActor *parent; parent=clutter_actor_get_parent(inSelection); g_warning(_("%s is a child of %s and cannot be selected at %s"), G_OBJECT_TYPE_NAME(inSelection), parent ? G_OBJECT_TYPE_NAME(parent) : "<nil>", G_OBJECT_TYPE_NAME(self)); } /* Get workspace of new selection and set new selection*/ workspace=xfdashboard_live_workspace_get_workspace(actor); if(workspace) { /* Activate workspace */ xfdashboard_window_tracker_workspace_activate(workspace); /* Quit application */ xfdashboard_application_quit(); /* Activation was successful */ return(TRUE); } /* Activation was unsuccessful if we get here */ g_warning(_("Could not determine workspace of %s to set selection at %s"), G_OBJECT_TYPE_NAME(actor), G_OBJECT_TYPE_NAME(self)); return(FALSE); }
/* Set new selection */ static gboolean _xfdashboard_action_button_focusable_set_selection(XfdashboardFocusable *inFocusable, ClutterActor *inSelection) { XfdashboardActionButton *self; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_ACTION_BUTTON(inFocusable), FALSE); g_return_val_if_fail(!inSelection || CLUTTER_IS_ACTOR(inSelection), FALSE); self=XFDASHBOARD_ACTION_BUTTON(inFocusable); /* Setting new selection always fails if it is not this actor itself */ if(inSelection!=CLUTTER_ACTOR(self)) return(FALSE); /* Otherwise setting selection was successful because nothing has changed */ return(TRUE); }
/* Call virtual function "supports_selection" */ gboolean xfdashboard_focusable_supports_selection(XfdashboardFocusable *self) { XfdashboardFocusableInterface *iface; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(self), FALSE); iface=XFDASHBOARD_FOCUSABLE_GET_IFACE(self); /* Call virtual function */ if(iface->supports_selection) { return(iface->supports_selection(self)); } /* If we get here the virtual function was not overridden */ XFDASHBOARD_FOCUSABLE_WARN_NOT_IMPLEMENTED(self, "supports_selection"); return(FALSE); }
/* Call virtual function "unset_focus" */ void xfdashboard_focusable_unset_focus(XfdashboardFocusable *self) { XfdashboardFocusableInterface *iface; ClutterActor *selection; g_return_if_fail(XFDASHBOARD_IS_FOCUSABLE(self)); iface=XFDASHBOARD_FOCUSABLE_GET_IFACE(self); /* Call virtual function */ if(iface->unset_focus) { iface->unset_focus(self); } /* Remove style from unfocused actor */ if(XFDASHBOARD_IS_STYLABLE(self)) { xfdashboard_stylable_remove_class(XFDASHBOARD_STYLABLE(self), "focus"); } /* If actor supports selection get current selection and unstyle it */ if(xfdashboard_focusable_supports_selection(self)) { /* Get current selection */ selection=xfdashboard_focusable_get_selection(self); /* unstyle selection if available */ if(selection && XFDASHBOARD_IS_STYLABLE(selection)) { xfdashboard_stylable_remove_pseudo_class(XFDASHBOARD_STYLABLE(selection), "selected"); } g_debug("Unstyled selection %s for focus loosing actor %s", G_OBJECT_TYPE_NAME(self), selection ? G_OBJECT_TYPE_NAME(selection) : "<nil>"); } /* Emit signal */ g_signal_emit(self, XfdashboardFocusableSignals[SIGNAL_FOCUS_LOST], 0, self); g_debug("Emitted signal 'focus-lost' for focused actor %s", G_OBJECT_TYPE_NAME(self)); }
/* Find requested selection target depending of current selection */ static ClutterActor* _xfdashboard_action_button_focusable_find_selection(XfdashboardFocusable *inFocusable, ClutterActor *inSelection, XfdashboardSelectionTarget inDirection) { XfdashboardActionButton *self; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), NULL); g_return_val_if_fail(XFDASHBOARD_IS_ACTION_BUTTON(inFocusable), NULL); g_return_val_if_fail(!inSelection || CLUTTER_IS_ACTOR(inSelection), NULL); g_return_val_if_fail(inDirection>=0 && inDirection<=XFDASHBOARD_SELECTION_TARGET_NEXT, NULL); self=XFDASHBOARD_ACTION_BUTTON(inFocusable); /* Regardless of "current" selection and direction requested for new selection * we return this actor as new current selection resulting in no change of * selection. It is and will be the actor itself. */ return(CLUTTER_ACTOR(self)); }
/* Determine if view has the focus */ gboolean xfdashboard_view_has_focus(XfdashboardView *self) { XfdashboardViewPrivate *priv; XfdashboardFocusManager *focusManager; XfdashboardViewpad *viewpad; g_return_val_if_fail(XFDASHBOARD_IS_VIEW(self), FALSE); priv=self->priv; /* The view can only have the focus if this view is enabled, active and * has the current focus. */ if(!priv->isEnabled) { return(FALSE); } viewpad=_xfdashboard_view_find_viewpad(self); if(!viewpad) { return(FALSE); } if(xfdashboard_viewpad_get_active_view(XFDASHBOARD_VIEWPAD(viewpad))!=self) { return(FALSE); } focusManager=xfdashboard_focus_manager_get_default(); if(!XFDASHBOARD_IS_FOCUSABLE(self) || !xfdashboard_focus_manager_has_focus(focusManager, XFDASHBOARD_FOCUSABLE(self))) { g_object_unref(focusManager); return(FALSE); } /* Release allocated resources */ g_object_unref(focusManager); /* All tests passed so this view has the focus */ return(TRUE); }
/* Determine if actor can get the focus */ static gboolean _xfdashboard_action_button_focusable_can_focus(XfdashboardFocusable *inFocusable) { XfdashboardFocusableInterface *selfIface; XfdashboardFocusableInterface *parentIface; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable), FALSE); g_return_val_if_fail(XFDASHBOARD_IS_ACTION_BUTTON(inFocusable), FALSE); /* Call parent class interface function */ 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); } /* If we get here this actor can be focused */ return(TRUE); }
/* Action signal to activate current selection was emitted */ static gboolean _xfdashboard_focusable_selection_activate(XfdashboardFocusable *self, XfdashboardFocusable *inSource, const gchar *inAction, ClutterEvent *inEvent) { ClutterActor *currentSelection; g_return_val_if_fail(XFDASHBOARD_IS_FOCUSABLE(self), CLUTTER_EVENT_PROPAGATE); g_return_val_if_fail(inEvent, CLUTTER_EVENT_PROPAGATE); /* Get selection to activate from focusable actio. If no selection is available * return here with event unhandled. */ currentSelection=xfdashboard_focusable_get_selection(self); if(!currentSelection) return(CLUTTER_EVENT_PROPAGATE); /* Activate selection */ xfdashboard_focusable_activate_selection(self, currentSelection); /* All done so return and stop further processing of this event */ return(CLUTTER_EVENT_STOP); }
/* Action signal to close currently selected window was emitted */ static gboolean _xfdashboard_view_activate(XfdashboardView *self, XfdashboardFocusable *inSource, const gchar *inAction, ClutterEvent *inEvent) { XfdashboardViewPrivate *priv; XfdashboardViewpad *viewpad; XfdashboardFocusManager *focusManager; g_return_val_if_fail(XFDASHBOARD_IS_VIEW(self), CLUTTER_EVENT_PROPAGATE); priv=self->priv; /* Only enabled views can be activated */ if(!priv->isEnabled) return(CLUTTER_EVENT_STOP); /* Find viewpad which contains this view */ viewpad=_xfdashboard_view_find_viewpad(self); if(!viewpad) return(CLUTTER_EVENT_STOP); /* Activate view at viewpad if this view is not the active one */ if(xfdashboard_viewpad_get_active_view(viewpad)!=self) { xfdashboard_viewpad_set_active_view(viewpad, self); } /* Set focus to view if it has not the focus */ focusManager=xfdashboard_focus_manager_get_default(); if(XFDASHBOARD_IS_FOCUSABLE(self) && !xfdashboard_focus_manager_has_focus(focusManager, XFDASHBOARD_FOCUSABLE(self))) { xfdashboard_focus_manager_set_focus(focusManager, XFDASHBOARD_FOCUSABLE(self)); } g_object_unref(focusManager); /* Action handled */ return(CLUTTER_EVENT_STOP); }