void UScreen::Refresh()
{
LOG_DEBUG(logger) << "Screen geometry changed";
nux::Geometry last_geo;
monitors_.clear();
primary_ = gdk_screen_get_primary_monitor(screen_);
int monitors = gdk_screen_get_n_monitors(screen_);
for (int i = 0; i < monitors; ++i)
{
GdkRectangle rect = { 0 };
gdk_screen_get_monitor_geometry(screen_, i, &rect);
float scale = gdk_screen_get_monitor_scale_factor(screen_, i);
nux::Geometry geo(rect.x*scale, rect.y*scale, rect.width*scale, rect.height*scale);
// Check for mirrored displays
if (geo == last_geo)
continue;
last_geo = geo;
monitors_.push_back(geo);
LOG_DEBUG(logger) << "Monitor " << i << " has geometry " << geo.x << "x"
<< geo.y << "x" << geo.width << "x" << geo.height;
}
changed.emit(primary_, monitors_);
}
static gint
nautilus_list_model_get_icon_scale (NautilusListModel *model)
{
gint retval = -1;
g_signal_emit (model, list_model_signals[GET_ICON_SCALE], 0,
&retval);
if (retval == -1) {
retval = gdk_screen_get_monitor_scale_factor (gdk_screen_get_default (), 0);
}
return retval;
}
/**
* cs_screen_get_mouse_monitor:
* @screen: a #CsScreen
*
* Gets the index of the monitor that the mouse pointer currently
* occupies.
*
* Return value: the monitor index for the pointer
*/
gint
cs_screen_get_mouse_monitor (CsScreen *screen)
{
GdkDisplay *gdk_display;
Window xroot, root_return, child_return;
int root_x_return, root_y_return;
int win_x_return, win_y_return;
unsigned int mask_return;
gint scale_factor;
gint i;
gint ret = 0;
g_return_val_if_fail (CS_IS_SCREEN (screen), 0);
gdk_display = gdk_screen_get_display (screen->gdk_screen);
xroot = gdk_x11_window_get_xid (gdk_screen_get_root_window (screen->gdk_screen));
gdk_error_trap_push ();
XQueryPointer (gdk_x11_display_get_xdisplay (gdk_display),
xroot,
&root_return,
&child_return,
&root_x_return,
&root_y_return,
&win_x_return,
&win_y_return,
&mask_return);
gdk_error_trap_pop_ignored ();
scale_factor = gdk_screen_get_monitor_scale_factor (screen->gdk_screen, 0);
root_x_return /= scale_factor;
root_y_return /= scale_factor;
for (i = 0; i < screen->n_monitor_infos; i++)
{
GdkRectangle iter = screen->monitor_infos[i].rect;
if (root_x_return >= iter.x && root_x_return <= iter.x + iter.width &&
root_y_return >= iter.y && root_y_return <= iter.y + iter.height)
{
ret = i;
break;
}
}
return ret;
}
static gint
get_scale_factor (GtkIconHelper *self,
GtkStyleContext *context)
{
GdkScreen *screen;
if (self->priv->window)
return gdk_window_get_scale_factor (self->priv->window);
screen = gtk_style_context_get_screen (context);
/* else fall back to something that is more likely to be right than
* just returning 1:
*/
return gdk_screen_get_monitor_scale_factor (screen, 0);
}
int
main(int argc, char *argv[]) {
GOOGLE_PROTOBUF_VERIFY_VERSION;
hu_log_library_versions();
hu_install_crash_handler();
#if defined GDK_VERSION_3_10
printf("GTK VERSION 3.10.0 or higher\n");
//Assuming we are on Gnome, what's the DPI scale factor?
gdk_init(&argc, &argv);
GdkScreen * primaryDisplay = gdk_screen_get_default();
if (primaryDisplay) {
g_dpi_scalefactor = (float) gdk_screen_get_monitor_scale_factor(primaryDisplay, 0);
printf("Got gdk_screen_get_monitor_scale_factor() == %f\n", g_dpi_scalefactor);
}
#else
printf("Using hard coded scalefactor\n");
g_dpi_scalefactor = 1;
#endif
gst_app_t *app = &gst_app;
int ret = 0;
errno = 0;
gst_init(NULL, NULL);
struct sigaction action;
sigaction(SIGINT, NULL, &action);
if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
SDL_Log("Unable to initialize SDL: %s", SDL_GetError());
return 1;
}
sigaction(SIGINT, &action, NULL);
DesktopCommandServerCallbacks commandCallbacks;
CommandServer commandServer(commandCallbacks);
if (!commandServer.Start())
{
loge("Command server failed to start");
}
//loop to emulate the caar
while(true)
{
DesktopEventCallbacks callbacks;
HUServer headunit(callbacks);
/* Start AA processing */
ret = headunit.hu_aap_start(HU_TRANSPORT_TYPE::USB, true);
if (ret < 0) {
printf("Phone is not connected. Connect a supported phone and restart.\n");
return 0;
}
callbacks.connected = true;
g_hu = &headunit.GetAnyThreadInterface();
commandCallbacks.eventCallbacks = &callbacks;
/* Start gstreamer pipeline and main loop */
ret = gst_loop(app);
if (ret < 0) {
printf("STATUS:gst_loop() ret: %d\n", ret);
}
callbacks.connected = false;
commandCallbacks.eventCallbacks = nullptr;
/* Stop AA processing */
ret = headunit.hu_aap_shutdown();
if (ret < 0) {
printf("STATUS:hu_aap_stop() ret: %d\n", ret);
SDL_Quit();
return (ret);
}
g_hu = nullptr;
}
SDL_Quit();
return (ret);
}
static void
reload_monitor_infos (CsScreen *screen)
{
GdkDisplay *gdk_display;
Display *xdisplay;
Window xroot;
gdk_display = gdk_screen_get_display (screen->gdk_screen);
xdisplay = gdk_x11_display_get_xdisplay (gdk_display);
xroot = gdk_x11_window_get_xid (gdk_screen_get_root_window (screen->gdk_screen));
/* Any previous screen->monitor_infos is freed by the caller */
screen->monitor_infos = NULL;
screen->n_monitor_infos = 0;
/* Xinerama doesn't have a concept of primary monitor, however XRandR
* does. However, the XRandR xinerama compat code always sorts the
* primary output first, so we rely on that here. We could use the
* native XRandR calls instead of xinerama, but that would be
* slightly problematic for _NET_WM_FULLSCREEN_MONITORS support, as
* that is defined in terms of xinerama monitor indexes.
* So, since we don't need anything in xrandr except the primary
* we can keep using xinerama and use the first monitor as the
* primary.
*/
screen->primary_monitor_index = PRIMARY_MONITOR;
#ifdef HAVE_XFREE_XINERAMA
if (screen->n_monitor_infos == 0 &&
XineramaIsActive (xdisplay))
{
XineramaScreenInfo *infos;
int n_infos;
int i;
n_infos = 0;
infos = XineramaQueryScreens (xdisplay, &n_infos);
DEBUG ("Found %d Xinerama screens on display %s\n",
n_infos, gdk_display_get_name (gdk_display));
if (n_infos > 0)
{
screen->monitor_infos = g_new0 (CsMonitorInfo, n_infos);
screen->n_monitor_infos = n_infos;
i = 0;
while (i < n_infos)
{
screen->monitor_infos[i].number = infos[i].screen_number;
screen->monitor_infos[i].rect.x = infos[i].x_org;
screen->monitor_infos[i].rect.y = infos[i].y_org;
screen->monitor_infos[i].rect.width = infos[i].width;
screen->monitor_infos[i].rect.height = infos[i].height;
DEBUG ("Monitor %d is %d,%d %d x %d\n",
screen->monitor_infos[i].number,
screen->monitor_infos[i].rect.x,
screen->monitor_infos[i].rect.y,
screen->monitor_infos[i].rect.width,
screen->monitor_infos[i].rect.height);
++i;
}
}
cs_XFree (infos);
#ifdef HAVE_RANDR
{
XRRScreenResources *resources;
resources = XRRGetScreenResourcesCurrent (xdisplay, xroot);
if (resources)
{
for (i = 0; i < resources->ncrtc; i++)
{
XRRCrtcInfo *crtc;
CsMonitorInfo *info;
crtc = XRRGetCrtcInfo (xdisplay, resources, resources->crtcs[i]);
info = find_monitor_with_rect (screen, crtc->x, crtc->y, (int)crtc->width, (int)crtc->height);
if (info)
{
info->output = find_main_output_for_crtc (resources, crtc, xdisplay, xroot);
}
XRRFreeCrtcInfo (crtc);
}
XRRFreeScreenResources (resources);
}
}
#endif
}
else if (screen->n_monitor_infos > 0)
{
DEBUG ("No XFree86 Xinerama extension or XFree86 Xinerama inactive on display %s\n",
gdk_display_get_name (gdk_display));
}
#else
DEBUG ("Muffin compiled without XFree86 Xinerama support\n");
#endif /* HAVE_XFREE_XINERAMA */
#ifdef HAVE_SOLARIS_XINERAMA
/* This code from GDK, Copyright (C) 2002 Sun Microsystems */
if (screen->n_monitor_infos == 0 &&
XineramaGetState (xdisplay,
gdk_screen_get_number (screen->gdk_screen)))
{
XRectangle monitors[MAXFRAMEBUFFERS];
unsigned char hints[16];
int result;
int n_monitors;
int i;
n_monitors = 0;
result = XineramaGetInfo (xdisplay,
gdk_screen_get_number (screen->gdk_screen),
monitors, hints,
&n_monitors);
/* Yes I know it should be Success but the current implementation
* returns the num of monitor
*/
if (result > 0)
{
g_assert (n_monitors > 0);
screen->monitor_infos = g_new0 (CsMonitorInfo, n_monitors);
screen->n_monitor_infos = n_monitors;
i = 0;
while (i < n_monitors)
{
screen->monitor_infos[i].number = i;
screen->monitor_infos[i].rect.x = monitors[i].x;
screen->monitor_infos[i].rect.y = monitors[i].y;
screen->monitor_infos[i].rect.width = monitors[i].width;
screen->monitor_infos[i].rect.height = monitors[i].height;
DEBUG ("Monitor %d is %d,%d %d x %d\n",
screen->monitor_infos[i].number,
screen->monitor_infos[i].rect.x,
screen->monitor_infos[i].rect.y,
screen->monitor_infos[i].rect.width,
screen->monitor_infos[i].rect.height);
++i;
}
}
}
else if (screen->n_monitor_infos == 0)
{
DEBUG ("No Solaris Xinerama extension or Solaris Xinerama inactive on display %s\n",
gdk_display_get_name (gdk_display));
}
#else
DEBUG ("Cinnamon Screensaver compiled without Solaris Xinerama support\n");
#endif /* HAVE_SOLARIS_XINERAMA */
/* If no Xinerama, fill in the single screen info so
* we can use the field unconditionally
*/
if (screen->n_monitor_infos == 0)
{
DEBUG ("No Xinerama screens, using default screen info\n");
screen->monitor_infos = g_new0 (CsMonitorInfo, 1);
screen->n_monitor_infos = 1;
screen->monitor_infos[0].number = 0;
screen->monitor_infos[0].rect = screen->rect;
}
filter_mirrored_monitors (screen);
screen->monitor_infos[screen->primary_monitor_index].is_primary = TRUE;
apply_scale_factor (screen->monitor_infos,
screen->n_monitor_infos,
gdk_screen_get_monitor_scale_factor (screen->gdk_screen, PRIMARY_MONITOR));
g_assert (screen->n_monitor_infos > 0);
g_assert (screen->monitor_infos != NULL);
}
