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