static void _xfdashboard_stage_interface_get_preferred_width(ClutterActor *inActor,
gfloat inForHeight,
gfloat *outMinWidth,
gfloat *outNaturalWidth)
{
XfdashboardStageInterface *self=XFDASHBOARD_STAGE_INTERFACE(inActor);
XfdashboardStageInterfacePrivate *priv=self->priv;
gfloat minWidth, naturalWidth;
gint w;
ClutterActor *stage;
/* Set up default values */
minWidth=naturalWidth=0.0f;
/* Get monitor size if available otherwise get stage size */
if(priv->monitor)
{
xfdashboard_window_tracker_monitor_get_geometry(priv->monitor, NULL, NULL, &w, NULL);
minWidth=naturalWidth=w;
}
else
{
stage=clutter_actor_get_stage(inActor);
minWidth=naturalWidth=clutter_actor_get_width(stage);
}
/* Store sizes computed */
if(outMinWidth) *outMinWidth=minWidth;
if(outNaturalWidth) *outNaturalWidth=naturalWidth;
}
/* Monitor size changed */
static void _xfdashboard_stage_interface_on_geometry_changed(XfdashboardStageInterface *self, gpointer inUserData)
{
XfdashboardStageInterfacePrivate *priv;
gint x, y, w, h;
g_return_if_fail(XFDASHBOARD_IS_STAGE_INTERFACE(self));
priv=self->priv;
/* Resize actor to new monitor */
xfdashboard_window_tracker_monitor_get_geometry(priv->monitor, &x, &y, &w, &h);
clutter_actor_set_position(CLUTTER_ACTOR(self), x, y);
clutter_actor_set_size(CLUTTER_ACTOR(self), w, h);
XFDASHBOARD_DEBUG(self, ACTOR,
"Stage interface moved to %d,%d and resized to %dx%d because %s monitor %d changed geometry",
x, y,
w, h,
xfdashboard_window_tracker_monitor_is_primary(priv->monitor) ? "primary" : "non-primary",
xfdashboard_window_tracker_monitor_get_number(priv->monitor));
}
/* Timeout callback to check for activation or suspend via hot corner */
static gboolean _xfdashboard_hot_corner_check_hot_corner(gpointer inUserData)
{
XfdashboardHotCorner *self;
XfdashboardHotCornerPrivate *priv;
XfdashboardWindowTrackerWindow *activeWindow;
GdkDevice *pointerDevice;
gint pointerX, pointerY;
XfdashboardWindowTrackerMonitor *primaryMonitor;
XfdashboardHotCornerBox monitorRect;
XfdashboardHotCornerBox hotCornerRect;
GDateTime *currentTime;
GTimeSpan timeDiff;
XfdashboardHotCornerSettingsActivationCorner activationCorner;
gint activationRadius;
gint64 activationDuration;
g_return_val_if_fail(XFDASHBOARD_IS_HOT_CORNER(inUserData), G_SOURCE_CONTINUE);
self=XFDASHBOARD_HOT_CORNER(inUserData);
priv=self->priv;
/* Get all settings now which are used within this function */
activationCorner=xfdashboard_hot_corner_settings_get_activation_corner(priv->settings);
activationRadius=xfdashboard_hot_corner_settings_get_activation_radius(priv->settings);
activationDuration=xfdashboard_hot_corner_settings_get_activation_duration(priv->settings);
/* Do nothing if current window is fullscreen but not this application */
activeWindow=xfdashboard_window_tracker_get_active_window(priv->windowTracker);
if(activeWindow &&
xfdashboard_window_tracker_window_is_fullscreen(activeWindow) &&
!xfdashboard_window_tracker_window_is_stage(activeWindow))
{
return(G_SOURCE_CONTINUE);
}
/* Get current position of pointer */
#if GTK_CHECK_VERSION(3, 20, 0)
pointerDevice=gdk_seat_get_pointer(priv->seat);
#else
pointerDevice=gdk_device_manager_get_client_pointer(priv->deviceManager);
#endif
if(!pointerDevice)
{
g_critical(_("Could not get pointer to determine pointer position"));
return(G_SOURCE_CONTINUE);
}
gdk_window_get_device_position(priv->rootWindow, pointerDevice, &pointerX, &pointerY, NULL);
/* Get position and size of primary monitor */
primaryMonitor=xfdashboard_window_tracker_get_primary_monitor(priv->windowTracker);
if(primaryMonitor)
{
gint w, h;
xfdashboard_window_tracker_monitor_get_geometry(primaryMonitor,
&monitorRect.x1,
&monitorRect.y1,
&w,
&h);
monitorRect.x2=monitorRect.x1+w;
monitorRect.y2=monitorRect.y1+h;
}
else
{
/* Set position to 0,0 and size to screen size */
monitorRect.x1=monitorRect.y1=0;
monitorRect.x2=xfdashboard_window_tracker_get_screen_width(priv->windowTracker);
monitorRect.y2=xfdashboard_window_tracker_get_screen_height(priv->windowTracker);
}
/* Get rectangle where pointer must be inside to activate hot corner */
switch(activationCorner)
{
case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_TOP_RIGHT:
hotCornerRect.x2=monitorRect.x2;
hotCornerRect.x1=MAX(monitorRect.x2-activationRadius, monitorRect.x1);
hotCornerRect.y1=monitorRect.y1;
hotCornerRect.y2=MIN(monitorRect.y1+activationRadius, monitorRect.y2);
break;
case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_BOTTOM_LEFT:
hotCornerRect.x1=monitorRect.x1;
hotCornerRect.x2=MIN(monitorRect.x1+activationRadius, monitorRect.x2);
hotCornerRect.y2=monitorRect.y2;
hotCornerRect.y1=MAX(monitorRect.y2-activationRadius, monitorRect.y1);
break;
case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_BOTTOM_RIGHT:
hotCornerRect.x2=monitorRect.x2;
hotCornerRect.x1=MAX(monitorRect.x2-activationRadius, monitorRect.x1);
hotCornerRect.y2=monitorRect.y2;
hotCornerRect.y1=MAX(monitorRect.y2-activationRadius, monitorRect.y1);
break;
case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_TOP_LEFT:
default:
hotCornerRect.x1=monitorRect.x1;
hotCornerRect.x2=MIN(monitorRect.x1+activationRadius, monitorRect.x2);
hotCornerRect.y1=monitorRect.y1;
hotCornerRect.y2=MIN(monitorRect.y1+activationRadius, monitorRect.y2);
break;
}
/* Check if pointer is in configured hot corner for a configured interval.
* If it is not reset entered time and return immediately without doing anything.
*/
if(pointerX<hotCornerRect.x1 || pointerX>=hotCornerRect.x2 ||
pointerY<hotCornerRect.y1 || pointerY>=hotCornerRect.y2)
{
/* Reset entered time */
if(priv->enteredTime)
{
g_date_time_unref(priv->enteredTime);
priv->enteredTime=NULL;
}
/* Return without doing anything */
return(G_SOURCE_CONTINUE);
}
/* If no entered time was registered yet we assume the pointer is in hot corner
* for the first time. So remember entered time for next polling interval.
*/
if(!priv->enteredTime)
{
/* Remember entered time */
priv->enteredTime=g_date_time_new_now_local();
/* Reset handled flag to get duration checked next time */
priv->wasHandledRecently=FALSE;
/* Return without doing anything */
return(G_SOURCE_CONTINUE);
}
/* If handled flag is set then do nothing to avoid flapping between activation
* and suspending application once the activation duration was reached.
*/
if(priv->wasHandledRecently) return(G_SOURCE_CONTINUE);
/* We know the time the pointer entered hot corner. Check if pointer have stayed
* in hot corner for the duration to activate/suspend application. If duration
* was not reached yet, just return immediately.
*/
currentTime=g_date_time_new_now_local();
timeDiff=g_date_time_difference(currentTime, priv->enteredTime);
g_date_time_unref(currentTime);
if(timeDiff<(activationDuration*G_TIME_SPAN_MILLISECOND)) return(G_SOURCE_CONTINUE);
/* Activation duration reached so activate application if suspended or suspend it
* if active currently.
*/
if(!xfdashboard_application_is_suspended(priv->application))
{
xfdashboard_application_suspend_or_quit(priv->application);
}
else
{
g_application_activate(G_APPLICATION(priv->application));
}
/* Set flag that activation was handled recently */
priv->wasHandledRecently=TRUE;
return(G_SOURCE_CONTINUE);
}
