2008-11-02 08:26:08 -07:00
|
|
|
/*
|
2006-11-26 11:13:41 -07:00
|
|
|
*
|
|
|
|
* Quartz-specific support for the Darwin X Server
|
|
|
|
*
|
2012-06-10 07:21:05 -06:00
|
|
|
* Copyright (c) 2002-2012 Apple Inc. All rights reserved.
|
2006-11-26 11:13:41 -07:00
|
|
|
* Copyright (c) 2001-2004 Greg Parker and Torrey T. Lyons.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
|
|
* DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Except as contained in this notice, the name(s) of the above copyright
|
|
|
|
* holders shall not be used in advertising or otherwise to promote the sale,
|
|
|
|
* use or other dealings in this Software without prior written authorization.
|
|
|
|
*/
|
2008-11-02 08:26:08 -07:00
|
|
|
|
2009-09-06 13:44:18 -06:00
|
|
|
#include "sanitizedCarbon.h"
|
|
|
|
|
2008-11-02 08:26:08 -07:00
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
|
|
#include <dix-config.h>
|
2007-11-24 10:55:21 -07:00
|
|
|
#endif
|
2008-11-02 08:26:08 -07:00
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
#include "quartzCommon.h"
|
2010-12-05 08:36:02 -07:00
|
|
|
#include "quartzRandR.h"
|
2009-09-06 13:44:18 -06:00
|
|
|
#include "inputstr.h"
|
2006-11-26 11:13:41 -07:00
|
|
|
#include "quartz.h"
|
|
|
|
#include "darwin.h"
|
2008-11-02 08:26:08 -07:00
|
|
|
#include "darwinEvents.h"
|
2006-11-26 11:13:41 -07:00
|
|
|
#include "pseudoramiX.h"
|
2013-06-07 11:28:45 -06:00
|
|
|
#include "extension.h"
|
2016-05-29 06:02:34 -06:00
|
|
|
#include "nonsdk_extinit.h"
|
2013-06-07 11:28:45 -06:00
|
|
|
#include "glx_extinit.h"
|
2006-11-26 11:13:41 -07:00
|
|
|
#define _APPLEWM_SERVER_
|
|
|
|
#include "applewmExt.h"
|
|
|
|
|
2008-11-02 08:26:08 -07:00
|
|
|
#include "X11Application.h"
|
|
|
|
|
2010-07-27 13:02:24 -06:00
|
|
|
#include <X11/extensions/applewmconst.h>
|
2008-11-02 08:26:08 -07:00
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
// X headers
|
|
|
|
#include "scrnintstr.h"
|
|
|
|
#include "windowstr.h"
|
|
|
|
#include "colormapst.h"
|
|
|
|
#include "globals.h"
|
2009-09-06 13:44:18 -06:00
|
|
|
#include "mi.h"
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
// System headers
|
2010-12-05 08:36:02 -07:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2006-11-26 11:13:41 -07:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <IOKit/pwr_mgt/IOPMLib.h>
|
2011-11-05 07:32:40 -06:00
|
|
|
#include <libkern/OSAtomic.h>
|
2011-04-02 10:08:38 -06:00
|
|
|
#include <signal.h>
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2009-09-06 13:44:18 -06:00
|
|
|
#include <rootlessCommon.h>
|
|
|
|
#include <Xplugin.h>
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
/* Work around a bug on Leopard's headers */
|
|
|
|
#if defined (__LP64__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 && MAC_OS_X_VERSION_MAX_ALLOWED < 1060
|
|
|
|
extern OSErr UpdateSystemActivity(UInt8 activity);
|
|
|
|
#define OverallAct 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
DevPrivateKeyRec quartzScreenKeyRec;
|
|
|
|
int aquaMenuBarHeight = 0;
|
|
|
|
QuartzModeProcsPtr quartzProcs = NULL;
|
2006-11-26 11:13:41 -07:00
|
|
|
const char *quartzOpenGLBundle = NULL;
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
Bool XQuartzFullscreenDisableHotkeys = TRUE;
|
|
|
|
Bool XQuartzOptionSendsAlt = FALSE;
|
|
|
|
Bool XQuartzEnableKeyEquivalents = TRUE;
|
|
|
|
Bool XQuartzFullscreenVisible = FALSE;
|
|
|
|
Bool XQuartzRootlessDefault = TRUE;
|
|
|
|
Bool XQuartzIsRootless = TRUE;
|
|
|
|
Bool XQuartzServerVisible = FALSE;
|
|
|
|
Bool XQuartzFullscreenMenu = FALSE;
|
2011-04-02 10:08:38 -06:00
|
|
|
|
|
|
|
int32_t XQuartzShieldingWindowLevel = 0;
|
2008-11-02 08:26:08 -07:00
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
/*
|
2012-06-10 07:21:05 -06:00
|
|
|
===========================================================================
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
Screen functions
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
===========================================================================
|
|
|
|
*/
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
/*
|
2008-11-02 08:26:08 -07:00
|
|
|
* QuartzAddScreen
|
2006-11-26 11:13:41 -07:00
|
|
|
* Do mode dependent initialization of each screen for Quartz.
|
|
|
|
*/
|
2012-06-10 07:21:05 -06:00
|
|
|
Bool
|
|
|
|
QuartzAddScreen(int index,
|
|
|
|
ScreenPtr pScreen)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2014-05-02 13:27:46 -06:00
|
|
|
// The clang static analyzer thinks we leak displayInfo here
|
|
|
|
#ifndef __clang_analyzer__
|
2006-11-26 11:13:41 -07:00
|
|
|
// allocate space for private per screen Quartz specific storage
|
2010-12-05 08:36:02 -07:00
|
|
|
QuartzScreenPtr displayInfo = calloc(sizeof(QuartzScreenRec), 1);
|
2008-11-02 08:26:08 -07:00
|
|
|
|
|
|
|
// QUARTZ_PRIV(pScreen) = displayInfo;
|
|
|
|
dixSetPrivate(&pScreen->devPrivates, quartzScreenKey, displayInfo);
|
2014-05-02 13:27:46 -06:00
|
|
|
#endif /* __clang_analyzer__ */
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
// do Quartz mode specific initialization
|
|
|
|
return quartzProcs->AddScreen(index, pScreen);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-11-02 08:26:08 -07:00
|
|
|
* QuartzSetupScreen
|
2006-11-26 11:13:41 -07:00
|
|
|
* Finalize mode specific setup of each screen.
|
|
|
|
*/
|
2012-06-10 07:21:05 -06:00
|
|
|
Bool
|
|
|
|
QuartzSetupScreen(int index,
|
|
|
|
ScreenPtr pScreen)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
|
|
|
// do Quartz mode specific setup
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!quartzProcs->SetupScreen(index, pScreen))
|
2006-11-26 11:13:41 -07:00
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
// setup cursor support
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!quartzProcs->InitCursor(pScreen))
|
2006-11-26 11:13:41 -07:00
|
|
|
return FALSE;
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
#if defined(RANDR)
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!QuartzRandRInit(pScreen)) {
|
2010-12-05 08:36:02 -07:00
|
|
|
DEBUG_LOG("Failed to init RandR extension.\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-11-02 08:26:08 -07:00
|
|
|
* QuartzInitOutput
|
2006-11-26 11:13:41 -07:00
|
|
|
* Quartz display initialization.
|
|
|
|
*/
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
QuartzInitOutput(int argc,
|
|
|
|
char **argv)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2011-04-02 10:08:38 -06:00
|
|
|
/* For XQuartz, we want to just use the default signal handler to work better with CrashTracer */
|
|
|
|
signal(SIGSEGV, SIG_DFL);
|
2017-12-08 08:01:59 -07:00
|
|
|
signal(SIGABRT, SIG_DFL);
|
2011-04-02 10:08:38 -06:00
|
|
|
signal(SIGILL, SIG_DFL);
|
|
|
|
#ifdef SIGEMT
|
|
|
|
signal(SIGEMT, SIG_DFL);
|
|
|
|
#endif
|
|
|
|
signal(SIGFPE, SIG_DFL);
|
|
|
|
#ifdef SIGBUS
|
|
|
|
signal(SIGBUS, SIG_DFL);
|
|
|
|
#endif
|
|
|
|
#ifdef SIGSYS
|
|
|
|
signal(SIGSYS, SIG_DFL);
|
|
|
|
#endif
|
|
|
|
#ifdef SIGXCPU
|
|
|
|
signal(SIGXCPU, SIG_DFL);
|
|
|
|
#endif
|
|
|
|
#ifdef SIGXFSZ
|
|
|
|
signal(SIGXFSZ, SIG_DFL);
|
|
|
|
#endif
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
if (!RegisterBlockAndWakeupHandlers(QuartzBlockHandler,
|
|
|
|
QuartzWakeupHandler,
|
2012-06-10 07:21:05 -06:00
|
|
|
NULL)) {
|
2006-11-26 11:13:41 -07:00
|
|
|
FatalError("Could not register block and wakeup handlers.");
|
|
|
|
}
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
if (!dixRegisterPrivateKey(&quartzScreenKeyRec, PRIVATE_SCREEN, 0))
|
2012-06-10 07:21:05 -06:00
|
|
|
FatalError("Failed to alloc quartz screen private.\n");
|
2010-07-27 13:02:24 -06:00
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
// Do display mode specific initialization
|
|
|
|
quartzProcs->DisplayInit();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-11-02 08:26:08 -07:00
|
|
|
* QuartzInitInput
|
2006-11-26 11:13:41 -07:00
|
|
|
* Inform the main thread the X server is ready to handle events.
|
|
|
|
*/
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
QuartzInitInput(int argc,
|
|
|
|
char **argv)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2010-07-27 13:02:24 -06:00
|
|
|
X11ApplicationSetCanQuit(0);
|
2008-11-02 08:26:08 -07:00
|
|
|
X11ApplicationServerReady();
|
2006-11-26 11:13:41 -07:00
|
|
|
// Do final display mode specific initialization before handling events
|
|
|
|
if (quartzProcs->InitInput)
|
|
|
|
quartzProcs->InitInput(argc, argv);
|
|
|
|
}
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
QuartzUpdateScreens(void)
|
|
|
|
{
|
2006-11-26 11:13:41 -07:00
|
|
|
ScreenPtr pScreen;
|
|
|
|
WindowPtr pRoot;
|
|
|
|
int x, y, width, height, sx, sy;
|
|
|
|
xEvent e;
|
2010-07-27 13:02:24 -06:00
|
|
|
BoxRec bounds;
|
2012-06-10 07:21:05 -06:00
|
|
|
|
|
|
|
if (noPseudoramiXExtension || screenInfo.numScreens != 1) {
|
2006-11-26 11:13:41 -07:00
|
|
|
/* FIXME: if not using Xinerama, we have multiple screens, and
|
2012-06-10 07:21:05 -06:00
|
|
|
to do this properly may need to add or remove screens. Which
|
|
|
|
isn't possible. So don't do anything. Another reason why
|
|
|
|
we default to running with Xinerama. */
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
return;
|
|
|
|
}
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
pScreen = screenInfo.screens[0];
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
PseudoramiXResetScreens();
|
2010-12-05 08:36:02 -07:00
|
|
|
quartzProcs->AddPseudoramiXScreens(&x, &y, &width, &height, pScreen);
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
pScreen->x = x;
|
|
|
|
pScreen->y = y;
|
2012-06-10 07:21:05 -06:00
|
|
|
pScreen->mmWidth = pScreen->mmWidth * ((double)width / pScreen->width);
|
|
|
|
pScreen->mmHeight = pScreen->mmHeight * ((double)height / pScreen->height);
|
2006-11-26 11:13:41 -07:00
|
|
|
pScreen->width = width;
|
|
|
|
pScreen->height = height;
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
DarwinAdjustScreenOrigins(&screenInfo);
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
/* DarwinAdjustScreenOrigins or UpdateScreen may change pScreen->x/y,
|
2010-07-27 13:02:24 -06:00
|
|
|
* so use it rather than x/y
|
|
|
|
*/
|
2010-12-05 08:36:02 -07:00
|
|
|
sx = pScreen->x + darwinMainScreenX;
|
|
|
|
sy = pScreen->y + darwinMainScreenY;
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
/* Adjust the root window. */
|
2010-12-05 08:36:02 -07:00
|
|
|
pRoot = pScreen->root;
|
2006-11-26 11:13:41 -07:00
|
|
|
AppleWMSetScreenOrigin(pRoot);
|
|
|
|
pScreen->ResizeWindow(pRoot, x - sx, y - sy, width, height, NULL);
|
2010-12-05 08:36:02 -07:00
|
|
|
|
2010-07-27 13:02:24 -06:00
|
|
|
/* <rdar://problem/7770779> pointer events are clipped to old display region after display reconfiguration
|
|
|
|
* http://xquartz.macosforge.org/trac/ticket/346
|
|
|
|
*/
|
|
|
|
bounds.x1 = 0;
|
|
|
|
bounds.x2 = width;
|
|
|
|
bounds.y1 = 0;
|
|
|
|
bounds.y2 = height;
|
|
|
|
pScreen->ConstrainCursor(inputInfo.pointer, pScreen, &bounds);
|
|
|
|
inputInfo.pointer->spriteInfo->sprite->physLimits = bounds;
|
|
|
|
inputInfo.pointer->spriteInfo->sprite->hotLimits = bounds;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
DEBUG_LOG(
|
|
|
|
"Root Window: %dx%d @ (%d, %d) darwinMainScreen (%d, %d) xy (%d, %d) dixScreenOrigins (%d, %d)\n",
|
|
|
|
width, height, x - sx, y - sy, darwinMainScreenX, darwinMainScreenY,
|
|
|
|
x, y,
|
|
|
|
pScreen->x, pScreen->y);
|
2009-09-06 13:44:18 -06:00
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
/* Send an event for the root reconfigure */
|
|
|
|
e.u.u.type = ConfigureNotify;
|
|
|
|
e.u.configureNotify.window = pRoot->drawable.id;
|
|
|
|
e.u.configureNotify.aboveSibling = None;
|
|
|
|
e.u.configureNotify.x = x - sx;
|
|
|
|
e.u.configureNotify.y = y - sy;
|
|
|
|
e.u.configureNotify.width = width;
|
|
|
|
e.u.configureNotify.height = height;
|
|
|
|
e.u.configureNotify.borderWidth = wBorderWidth(pRoot);
|
|
|
|
e.u.configureNotify.override = pRoot->overrideRedirect;
|
|
|
|
DeliverEvents(pRoot, &e, 1, NullWindow);
|
2010-12-05 08:36:02 -07:00
|
|
|
|
|
|
|
quartzProcs->UpdateScreen(pScreen);
|
2011-04-02 10:08:38 -06:00
|
|
|
|
2016-05-29 06:02:34 -06:00
|
|
|
/* PaintWindow needs to be called after RootlessUpdateScreenPixmap (from xprUpdateScreen) */
|
|
|
|
pScreen->PaintWindow(pRoot, &pRoot->borderClip, PW_BACKGROUND);
|
2011-11-05 07:32:40 -06:00
|
|
|
|
2011-04-02 10:08:38 -06:00
|
|
|
/* Tell RandR about the new size, so new connections get the correct info */
|
|
|
|
RRScreenSizeNotify(pScreen);
|
2009-09-06 13:44:18 -06:00
|
|
|
}
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
static void
|
|
|
|
pokeActivityCallback(CFRunLoopTimerRef timer, void *info)
|
|
|
|
{
|
2010-12-21 13:10:44 -07:00
|
|
|
UpdateSystemActivity(OverallAct);
|
|
|
|
}
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
static void
|
|
|
|
QuartzScreenSaver(int state)
|
|
|
|
{
|
2010-12-21 13:10:44 -07:00
|
|
|
static CFRunLoopTimerRef pokeActivityTimer = NULL;
|
2012-06-10 07:21:05 -06:00
|
|
|
static CFRunLoopTimerContext pokeActivityContext =
|
|
|
|
{ 0, NULL, NULL, NULL, NULL };
|
2011-11-05 07:32:40 -06:00
|
|
|
static OSSpinLock pokeActivitySpinLock = OS_SPINLOCK_INIT;
|
|
|
|
|
|
|
|
OSSpinLockLock(&pokeActivitySpinLock);
|
2010-12-21 13:10:44 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (state) {
|
|
|
|
if (pokeActivityTimer == NULL)
|
2010-12-21 13:10:44 -07:00
|
|
|
goto QuartzScreenSaverEnd;
|
|
|
|
|
|
|
|
CFRunLoopTimerInvalidate(pokeActivityTimer);
|
|
|
|
CFRelease(pokeActivityTimer);
|
|
|
|
pokeActivityTimer = NULL;
|
2012-06-10 07:21:05 -06:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (pokeActivityTimer != NULL)
|
2010-12-21 13:10:44 -07:00
|
|
|
goto QuartzScreenSaverEnd;
|
2012-06-10 07:21:05 -06:00
|
|
|
|
|
|
|
pokeActivityTimer = CFRunLoopTimerCreate(NULL,
|
|
|
|
CFAbsoluteTimeGetCurrent(),
|
|
|
|
30, 0, 0,
|
|
|
|
pokeActivityCallback,
|
|
|
|
&pokeActivityContext);
|
|
|
|
if (pokeActivityTimer == NULL) {
|
2010-12-21 13:10:44 -07:00
|
|
|
ErrorF("Unable to create pokeActivityTimer.\n");
|
|
|
|
goto QuartzScreenSaverEnd;
|
|
|
|
}
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
CFRunLoopAddTimer(
|
|
|
|
CFRunLoopGetMain(), pokeActivityTimer, kCFRunLoopCommonModes);
|
2010-12-21 13:10:44 -07:00
|
|
|
}
|
|
|
|
QuartzScreenSaverEnd:
|
2011-11-05 07:32:40 -06:00
|
|
|
OSSpinLockUnlock(&pokeActivitySpinLock);
|
2010-12-21 13:10:44 -07:00
|
|
|
}
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
QuartzShowFullscreen(int state)
|
|
|
|
{
|
2010-12-05 08:36:02 -07:00
|
|
|
int i;
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
DEBUG_LOG("QuartzShowFullscreen: state=%d\n", state);
|
2012-06-10 07:21:05 -06:00
|
|
|
|
|
|
|
if (XQuartzIsRootless) {
|
2010-12-05 08:36:02 -07:00
|
|
|
ErrorF("QuartzShowFullscreen called while in rootless mode.\n");
|
|
|
|
return;
|
|
|
|
}
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-21 13:10:44 -07:00
|
|
|
QuartzScreenSaver(!state);
|
2012-06-10 07:21:05 -06:00
|
|
|
|
|
|
|
if (XQuartzFullscreenVisible == state)
|
2009-09-06 13:44:18 -06:00
|
|
|
return;
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
XQuartzFullscreenVisible = state;
|
2012-06-10 07:21:05 -06:00
|
|
|
|
|
|
|
xp_disable_update();
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
if (!XQuartzFullscreenVisible)
|
2009-09-06 13:44:18 -06:00
|
|
|
RootlessHideAllWindows();
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
RootlessUpdateRooted(XQuartzFullscreenVisible);
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
if (XQuartzFullscreenVisible) {
|
2012-06-10 07:21:05 -06:00
|
|
|
RootlessShowAllWindows();
|
|
|
|
for (i = 0; i < screenInfo.numScreens; i++) {
|
|
|
|
ScreenPtr pScreen = screenInfo.screens[i];
|
2010-12-05 08:36:02 -07:00
|
|
|
RootlessRepositionWindows(pScreen);
|
|
|
|
// JH: I don't think this is necessary, but keeping it here as a reminder
|
|
|
|
//RootlessUpdateScreenPixmap(pScreen);
|
|
|
|
}
|
2009-09-06 13:44:18 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Somehow the menubar manages to interfere with our event stream
|
2012-06-10 07:21:05 -06:00
|
|
|
* in fullscreen mode, even though it's not visible.
|
2009-09-06 13:44:18 -06:00
|
|
|
*/
|
2010-12-05 08:36:02 -07:00
|
|
|
X11ApplicationShowHideMenubar(!XQuartzFullscreenVisible);
|
2012-06-10 07:21:05 -06:00
|
|
|
|
|
|
|
xp_reenable_update();
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
if (XQuartzFullscreenDisableHotkeys)
|
|
|
|
xp_disable_hot_keys(XQuartzFullscreenVisible);
|
2009-09-06 13:44:18 -06:00
|
|
|
}
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
QuartzSetRootless(Bool state)
|
|
|
|
{
|
2010-12-05 08:36:02 -07:00
|
|
|
DEBUG_LOG("QuartzSetRootless state=%d\n", state);
|
2012-06-10 07:21:05 -06:00
|
|
|
|
|
|
|
if (XQuartzIsRootless == state)
|
2009-09-06 13:44:18 -06:00
|
|
|
return;
|
2012-06-10 07:21:05 -06:00
|
|
|
|
|
|
|
if (state)
|
2010-12-05 08:36:02 -07:00
|
|
|
QuartzShowFullscreen(FALSE);
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
XQuartzIsRootless = state;
|
2009-09-06 13:44:18 -06:00
|
|
|
|
|
|
|
xp_disable_update();
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
/* When in rootless, the menubar is not part of the screen, so we need to update our screens on toggle */
|
2009-09-06 13:44:18 -06:00
|
|
|
QuartzUpdateScreens();
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (XQuartzIsRootless) {
|
2010-12-05 08:36:02 -07:00
|
|
|
RootlessShowAllWindows();
|
2012-06-10 07:21:05 -06:00
|
|
|
}
|
|
|
|
else {
|
2010-12-05 08:36:02 -07:00
|
|
|
RootlessHideAllWindows();
|
2009-09-06 13:44:18 -06:00
|
|
|
}
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
X11ApplicationShowHideMenubar(TRUE);
|
2010-07-27 13:02:24 -06:00
|
|
|
|
2009-09-06 13:44:18 -06:00
|
|
|
xp_reenable_update();
|
2010-07-27 13:02:24 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
xp_disable_hot_keys(FALSE);
|
2009-09-06 13:44:18 -06:00
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* QuartzShow
|
|
|
|
* Show the X server on screen. Does nothing if already shown.
|
|
|
|
* Calls mode specific screen resume to restore the X clip regions
|
|
|
|
* (if needed) and the X server cursor state.
|
|
|
|
*/
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
QuartzShow(void)
|
|
|
|
{
|
2006-11-26 11:13:41 -07:00
|
|
|
int i;
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
if (XQuartzServerVisible)
|
2009-09-06 13:44:18 -06:00
|
|
|
return;
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
XQuartzServerVisible = TRUE;
|
2009-09-06 13:44:18 -06:00
|
|
|
for (i = 0; i < screenInfo.numScreens; i++) {
|
|
|
|
if (screenInfo.screens[i]) {
|
2010-07-27 13:02:24 -06:00
|
|
|
quartzProcs->ResumeScreen(screenInfo.screens[i]);
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
}
|
2012-06-10 07:21:05 -06:00
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
if (!XQuartzIsRootless)
|
|
|
|
QuartzShowFullscreen(TRUE);
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* QuartzHide
|
|
|
|
* Remove the X server display from the screen. Does nothing if already
|
|
|
|
* hidden. Calls mode specific screen suspend to set X clip regions to
|
|
|
|
* prevent drawing (if needed) and restore the Aqua cursor.
|
|
|
|
*/
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
QuartzHide(void)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
if (XQuartzServerVisible) {
|
2006-11-26 11:13:41 -07:00
|
|
|
for (i = 0; i < screenInfo.numScreens; i++) {
|
|
|
|
if (screenInfo.screens[i]) {
|
|
|
|
quartzProcs->SuspendScreen(screenInfo.screens[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-12-05 08:36:02 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!XQuartzIsRootless)
|
2010-12-05 08:36:02 -07:00
|
|
|
QuartzShowFullscreen(FALSE);
|
|
|
|
XQuartzServerVisible = FALSE;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* QuartzSetRootClip
|
|
|
|
* Enable or disable rendering to the X screen.
|
|
|
|
*/
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
2016-05-29 06:02:34 -06:00
|
|
|
QuartzSetRootClip(int mode)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
if (!XQuartzServerVisible)
|
2006-11-26 11:13:41 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < screenInfo.numScreens; i++) {
|
|
|
|
if (screenInfo.screens[i]) {
|
2016-05-29 06:02:34 -06:00
|
|
|
SetRootClip(screenInfo.screens[i], mode);
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
/*
|
2009-09-06 13:44:18 -06:00
|
|
|
* QuartzSpaceChanged
|
|
|
|
* Unmap offscreen windows, map onscreen windows
|
2006-11-26 11:13:41 -07:00
|
|
|
*/
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
QuartzSpaceChanged(uint32_t space_id)
|
|
|
|
{
|
2009-09-06 13:44:18 -06:00
|
|
|
/* Do something special here, so we don't depend on quartz-wm for spaces to work... */
|
2012-06-10 07:21:05 -06:00
|
|
|
DEBUG_LOG("Space Changed (%u) ... do something interesting...\n",
|
|
|
|
space_id);
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
2010-12-05 08:36:02 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* QuartzCopyDisplayIDs
|
|
|
|
* Associate an X11 screen with one or more CoreGraphics display IDs by copying
|
|
|
|
* the list into a private array. Free the previously copied array, if present.
|
|
|
|
*/
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
QuartzCopyDisplayIDs(ScreenPtr pScreen,
|
|
|
|
int displayCount, CGDirectDisplayID *displayIDs)
|
|
|
|
{
|
2010-12-05 08:36:02 -07:00
|
|
|
QuartzScreenPtr pQuartzScreen = QUARTZ_PRIV(pScreen);
|
|
|
|
|
|
|
|
free(pQuartzScreen->displayIDs);
|
2012-06-10 07:21:05 -06:00
|
|
|
if (displayCount) {
|
2011-11-05 07:32:40 -06:00
|
|
|
size_t size = displayCount * sizeof(CGDirectDisplayID);
|
|
|
|
pQuartzScreen->displayIDs = malloc(size);
|
|
|
|
memcpy(pQuartzScreen->displayIDs, displayIDs, size);
|
2012-06-10 07:21:05 -06:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
pQuartzScreen->displayIDs = NULL;
|
2011-11-05 07:32:40 -06:00
|
|
|
}
|
2010-12-05 08:36:02 -07:00
|
|
|
pQuartzScreen->displayCount = displayCount;
|
|
|
|
}
|
2011-04-02 10:08:38 -06:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
void
|
|
|
|
NSBeep(void);
|
|
|
|
void
|
|
|
|
DDXRingBell(int volume, // volume is % of max
|
|
|
|
int pitch, // pitch is Hz
|
|
|
|
int duration) // duration is milliseconds
|
2011-04-02 10:08:38 -06:00
|
|
|
{
|
|
|
|
if (volume)
|
|
|
|
NSBeep();
|
|
|
|
}
|