[deb_xorg-server.git] / xf86RandR.c

/*
 *
 * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif

#include <X11/X.h>
#include "os.h"
#include "globals.h"
#include "xf86.h"
#include "xf86str.h"
#include "xf86Priv.h"
#include "xf86DDC.h"
#include "mipointer.h"
#include <randrstr.h>
#include "inputstr.h"

typedef struct _xf86RandRInfo {
    CreateScreenResourcesProcPtr CreateScreenResources;
    CloseScreenProcPtr CloseScreen;
    int virtualX;
    int virtualY;
    int mmWidth;
    int mmHeight;
    Rotation rotation;
} XF86RandRInfoRec, *XF86RandRInfoPtr;

static DevPrivateKeyRec xf86RandRKeyRec;
static DevPrivateKey xf86RandRKey;

#define XF86RANDRINFO(p) ((XF86RandRInfoPtr)dixLookupPrivate(&(p)->devPrivates, xf86RandRKey))

static int
xf86RandRModeRefresh(DisplayModePtr mode)
{
    if (mode->VRefresh)
        return (int) (mode->VRefresh + 0.5);
    else if (mode->Clock == 0)
        return 0;
    else
        return (int) (mode->Clock * 1000.0 / mode->HTotal / mode->VTotal + 0.5);
}

static Bool
xf86RandRGetInfo(ScreenPtr pScreen, Rotation * rotations)
{
    RRScreenSizePtr pSize;
    ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    DisplayModePtr mode;
    int refresh0 = 60;
    xorgRRModeMM RRModeMM;

    *rotations = RR_Rotate_0;

    for (mode = scrp->modes; mode != NULL; mode = mode->next) {
        int refresh = xf86RandRModeRefresh(mode);

        if (mode == scrp->modes)
            refresh0 = refresh;

        RRModeMM.mode = mode;
        RRModeMM.virtX = randrp->virtualX;
        RRModeMM.virtY = randrp->virtualY;
        RRModeMM.mmWidth = randrp->mmWidth;
        RRModeMM.mmHeight = randrp->mmHeight;

        if (scrp->DriverFunc) {
            (*scrp->DriverFunc) (scrp, RR_GET_MODE_MM, &RRModeMM);
        }

        pSize = RRRegisterSize(pScreen,
                               mode->HDisplay, mode->VDisplay,
                               RRModeMM.mmWidth, RRModeMM.mmHeight);
        if (!pSize)
            return FALSE;
        RRRegisterRate(pScreen, pSize, refresh);
        if (mode == scrp->currentMode &&
            mode->HDisplay == scrp->virtualX &&
            mode->VDisplay == scrp->virtualY)
            RRSetCurrentConfig(pScreen, randrp->rotation, refresh, pSize);
        if (mode->next == scrp->modes)
            break;
    }
    if (scrp->currentMode->HDisplay != randrp->virtualX ||
        scrp->currentMode->VDisplay != randrp->virtualY) {
        mode = scrp->modes;

        RRModeMM.mode = NULL;
        RRModeMM.virtX = randrp->virtualX;
        RRModeMM.virtY = randrp->virtualY;
        RRModeMM.mmWidth = randrp->mmWidth;
        RRModeMM.mmHeight = randrp->mmHeight;

        if (scrp->DriverFunc) {
            (*scrp->DriverFunc) (scrp, RR_GET_MODE_MM, &RRModeMM);
        }

        pSize = RRRegisterSize(pScreen,
                               randrp->virtualX, randrp->virtualY,
                               RRModeMM.mmWidth, RRModeMM.mmHeight);
        if (!pSize)
            return FALSE;
        RRRegisterRate(pScreen, pSize, refresh0);
        if (scrp->virtualX == randrp->virtualX &&
            scrp->virtualY == randrp->virtualY) {
            RRSetCurrentConfig(pScreen, randrp->rotation, refresh0, pSize);
        }
    }

    /* If there is driver support for randr, let it set our supported rotations */
    if (scrp->DriverFunc) {
        xorgRRRotation RRRotation;

        RRRotation.RRRotations = *rotations;
        if (!(*scrp->DriverFunc) (scrp, RR_GET_INFO, &RRRotation))
            return TRUE;
        *rotations = RRRotation.RRRotations;
    }

    return TRUE;
}

static Bool
xf86RandRSetMode(ScreenPtr pScreen,
                 DisplayModePtr mode,
                 Bool useVirtual, int mmWidth, int mmHeight)
{
    ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    int oldWidth = pScreen->width;
    int oldHeight = pScreen->height;
    int oldmmWidth = pScreen->mmWidth;
    int oldmmHeight = pScreen->mmHeight;
    int oldVirtualX = scrp->virtualX;
    int oldVirtualY = scrp->virtualY;
    WindowPtr pRoot = pScreen->root;
    Bool ret = TRUE;

    if (pRoot && scrp->vtSema)
        (*scrp->EnableDisableFBAccess) (scrp, FALSE);
    if (useVirtual) {
        scrp->virtualX = randrp->virtualX;
        scrp->virtualY = randrp->virtualY;
    }
    else {
        scrp->virtualX = mode->HDisplay;
        scrp->virtualY = mode->VDisplay;
    }

    /*
     * The DIX forgets the physical dimensions we passed into RRRegisterSize, so
     * reconstruct them if possible.
     */
    if (scrp->DriverFunc) {
        xorgRRModeMM RRModeMM;

        RRModeMM.mode = mode;
        RRModeMM.virtX = scrp->virtualX;
        RRModeMM.virtY = scrp->virtualY;
        RRModeMM.mmWidth = mmWidth;
        RRModeMM.mmHeight = mmHeight;

        (*scrp->DriverFunc) (scrp, RR_GET_MODE_MM, &RRModeMM);

        mmWidth = RRModeMM.mmWidth;
        mmHeight = RRModeMM.mmHeight;
    }
    if (randrp->rotation & (RR_Rotate_90 | RR_Rotate_270)) {
        /* If the screen is rotated 90 or 270 degrees, swap the sizes. */
        pScreen->width = scrp->virtualY;
        pScreen->height = scrp->virtualX;
        pScreen->mmWidth = mmHeight;
        pScreen->mmHeight = mmWidth;
    }
    else {
        pScreen->width = scrp->virtualX;
        pScreen->height = scrp->virtualY;
        pScreen->mmWidth = mmWidth;
        pScreen->mmHeight = mmHeight;
    }
    if (!xf86SwitchMode(pScreen, mode)) {
        pScreen->width = oldWidth;
        pScreen->height = oldHeight;
        pScreen->mmWidth = oldmmWidth;
        pScreen->mmHeight = oldmmHeight;
        scrp->virtualX = oldVirtualX;
        scrp->virtualY = oldVirtualY;
        ret = FALSE;
    }
    /*
     * Make sure the layout is correct
     */
    xf86ReconfigureLayout();

    if (scrp->vtSema) {
        /*
         * Make sure the whole screen is visible
         */
        xf86SetViewport (pScreen, pScreen->width, pScreen->height);
        xf86SetViewport (pScreen, 0, 0);
        if (pRoot)
            (*scrp->EnableDisableFBAccess) (scrp, TRUE);
    }
    return ret;
}

static Bool
xf86RandRSetConfig(ScreenPtr pScreen,
                   Rotation rotation, int rate, RRScreenSizePtr pSize)
{
    ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
    DisplayModePtr mode;
    int pos[MAXDEVICES][2];
    Bool useVirtual = FALSE;
    Rotation oldRotation = randrp->rotation;
    DeviceIntPtr dev;
    Bool view_adjusted = FALSE;

    for (dev = inputInfo.devices; dev; dev = dev->next) {
        if (!IsMaster(dev) && !IsFloating(dev))
            continue;

        miPointerGetPosition(dev, &pos[dev->id][0], &pos[dev->id][1]);
    }

    for (mode = scrp->modes;; mode = mode->next) {
        if (mode->HDisplay == pSize->width &&
            mode->VDisplay == pSize->height &&
            (rate == 0 || xf86RandRModeRefresh(mode) == rate))
            break;
        if (mode->next == scrp->modes) {
            if (pSize->width == randrp->virtualX &&
                pSize->height == randrp->virtualY) {
                mode = scrp->modes;
                useVirtual = TRUE;
                break;
            }
            return FALSE;
        }
    }

    if (randrp->rotation != rotation) {

        /* Have the driver do its thing. */
        if (scrp->DriverFunc) {
            xorgRRRotation RRRotation;

            RRRotation.RRConfig.rotation = rotation;
            RRRotation.RRConfig.rate = rate;
            RRRotation.RRConfig.width = pSize->width;
            RRRotation.RRConfig.height = pSize->height;

            /*
             * Currently we need to rely on HW support for rotation.
             */
            if (!(*scrp->DriverFunc) (scrp, RR_SET_CONFIG, &RRRotation))
                return FALSE;
        }
        else
            return FALSE;

        randrp->rotation = rotation;
    }

    if (!xf86RandRSetMode
        (pScreen, mode, useVirtual, pSize->mmWidth, pSize->mmHeight)) {
        if (randrp->rotation != oldRotation) {
            /* Have the driver undo its thing. */
            if (scrp->DriverFunc) {
                xorgRRRotation RRRotation;

                RRRotation.RRConfig.rotation = oldRotation;
                RRRotation.RRConfig.rate =
                    xf86RandRModeRefresh(scrp->currentMode);
                RRRotation.RRConfig.width = scrp->virtualX;
                RRRotation.RRConfig.height = scrp->virtualY;
                (*scrp->DriverFunc) (scrp, RR_SET_CONFIG, &RRRotation);
            }

            randrp->rotation = oldRotation;
        }
        return FALSE;
    }

    update_desktop_dimensions();

    /*
     * Move the cursor back where it belongs; SwitchMode repositions it
     * FIXME: duplicated code, see modes/xf86RandR12.c
     */
    for (dev = inputInfo.devices; dev; dev = dev->next) {
        if (!IsMaster(dev) && !IsFloating(dev))
            continue;

        if (pScreen == miPointerGetScreen(dev)) {
            int px = pos[dev->id][0];
            int py = pos[dev->id][1];

            px = (px >= pScreen->width ? (pScreen->width - 1) : px);
            py = (py >= pScreen->height ? (pScreen->height - 1) : py);

            /* Setting the viewpoint makes only sense on one device */
            if (!view_adjusted && IsMaster(dev)) {
                xf86SetViewport(pScreen, px, py);
                view_adjusted = TRUE;
            }

            (*pScreen->SetCursorPosition) (dev, pScreen, px, py, FALSE);
        }
    }

    return TRUE;
}

/*
 * Wait until the screen is initialized before whacking the
 * sizes around; otherwise the screen pixmap will be allocated
 * at the current mode size rather than the maximum size
 */
static Bool
xf86RandRCreateScreenResources(ScreenPtr pScreen)
{
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);

#if 0
    ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
    DisplayModePtr mode;
#endif

    pScreen->CreateScreenResources = randrp->CreateScreenResources;
    if (!(*pScreen->CreateScreenResources) (pScreen))
        return FALSE;

#if 0
    mode = scrp->currentMode;
    if (mode)
        xf86RandRSetMode(pScreen, mode, TRUE);
#endif

    return TRUE;
}

/*
 * Reset size back to original
 */
static Bool
xf86RandRCloseScreen(ScreenPtr pScreen)
{
    ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);

    scrp->virtualX = pScreen->width = randrp->virtualX;
    scrp->virtualY = pScreen->height = randrp->virtualY;
    scrp->currentMode = scrp->modes;
    pScreen->CloseScreen = randrp->CloseScreen;
    free(randrp);
    dixSetPrivate(&pScreen->devPrivates, xf86RandRKey, NULL);
    return (*pScreen->CloseScreen) (pScreen);
}

Rotation
xf86GetRotation(ScreenPtr pScreen)
{
    if (xf86RandRKey == NULL)
        return RR_Rotate_0;

    return XF86RANDRINFO(pScreen)->rotation;
}

/* Function to change RandR's idea of the virtual screen size */
Bool
xf86RandRSetNewVirtualAndDimensions(ScreenPtr pScreen,
                                    int newvirtX, int newvirtY, int newmmWidth,
                                    int newmmHeight, Bool resetMode)
{
    XF86RandRInfoPtr randrp;

    if (xf86RandRKey == NULL)
        return FALSE;

    randrp = XF86RANDRINFO(pScreen);
    if (randrp == NULL)
        return FALSE;

    if (newvirtX > 0)
        randrp->virtualX = newvirtX;

    if (newvirtY > 0)
        randrp->virtualY = newvirtY;

    if (newmmWidth > 0)
        randrp->mmWidth = newmmWidth;

    if (newmmHeight > 0)
        randrp->mmHeight = newmmHeight;

    /* This is only for during server start */
    if (resetMode) {
	ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
        return (xf86RandRSetMode(pScreen,
                                 pScrn->currentMode,
                                 TRUE, pScreen->mmWidth, pScreen->mmHeight));
    }

    return TRUE;
}

Bool
xf86RandRInit(ScreenPtr pScreen)
{
    rrScrPrivPtr rp;
    XF86RandRInfoPtr randrp;
    ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);

#ifdef PANORAMIX
    /* XXX disable RandR when using Xinerama */
    if (!noPanoramiXExtension)
        return TRUE;
#endif

    xf86RandRKey = &xf86RandRKeyRec;

    if (!dixRegisterPrivateKey(&xf86RandRKeyRec, PRIVATE_SCREEN, 0))
        return FALSE;

    randrp = malloc(sizeof(XF86RandRInfoRec));
    if (!randrp)
        return FALSE;

    if (!RRScreenInit(pScreen)) {
        free(randrp);
        return FALSE;
    }
    rp = rrGetScrPriv(pScreen);
    rp->rrGetInfo = xf86RandRGetInfo;
    rp->rrSetConfig = xf86RandRSetConfig;

    randrp->virtualX = scrp->virtualX;
    randrp->virtualY = scrp->virtualY;
    randrp->mmWidth = pScreen->mmWidth;
    randrp->mmHeight = pScreen->mmHeight;

    randrp->CreateScreenResources = pScreen->CreateScreenResources;
    pScreen->CreateScreenResources = xf86RandRCreateScreenResources;

    randrp->CloseScreen = pScreen->CloseScreen;
    pScreen->CloseScreen = xf86RandRCloseScreen;

    randrp->rotation = RR_Rotate_0;

    dixSetPrivate(&pScreen->devPrivates, xf86RandRKey, randrp);
    return TRUE;
}
Commit	Line	Data
	1	/*
	2	*
	3	* Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
	4	*
	5	* Permission to use, copy, modify, distribute, and sell this software and its
	6	* documentation for any purpose is hereby granted without fee, provided that
	7	* the above copyright notice appear in all copies and that both that
	8	* copyright notice and this permission notice appear in supporting
	9	* documentation, and that the name of Keith Packard not be used in
	10	* advertising or publicity pertaining to distribution of the software without
	11	* specific, written prior permission. Keith Packard makes no
	12	* representations about the suitability of this software for any purpose. It
	13	* is provided "as is" without express or implied warranty.
	14	*
	15	* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	16	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	17	* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	18	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	19	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	20	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	21	* PERFORMANCE OF THIS SOFTWARE.
	22	*/
	23
	24	#ifdef HAVE_XORG_CONFIG_H
	25	#include <xorg-config.h>
	26	#endif
	27
	28	#include <X11/X.h>
	29	#include "os.h"
	30	#include "globals.h"
	31	#include "xf86.h"
	32	#include "xf86str.h"
	33	#include "xf86Priv.h"
	34	#include "xf86DDC.h"
	35	#include "mipointer.h"
	36	#include <randrstr.h>
	37	#include "inputstr.h"
	38
	39	typedef struct _xf86RandRInfo {
	40	CreateScreenResourcesProcPtr CreateScreenResources;
	41	CloseScreenProcPtr CloseScreen;
	42	int virtualX;
	43	int virtualY;
	44	int mmWidth;
	45	int mmHeight;
	46	Rotation rotation;
	47	} XF86RandRInfoRec, *XF86RandRInfoPtr;
	48
	49	static DevPrivateKeyRec xf86RandRKeyRec;
	50	static DevPrivateKey xf86RandRKey;
	51
	52	#define XF86RANDRINFO(p) ((XF86RandRInfoPtr)dixLookupPrivate(&(p)->devPrivates, xf86RandRKey))
	53
	54	static int
	55	xf86RandRModeRefresh(DisplayModePtr mode)
	56	{
	57	if (mode->VRefresh)
	58	return (int) (mode->VRefresh + 0.5);
	59	else if (mode->Clock == 0)
	60	return 0;
	61	else
	62	return (int) (mode->Clock * 1000.0 / mode->HTotal / mode->VTotal + 0.5);
	63	}
	64
	65	static Bool
	66	xf86RandRGetInfo(ScreenPtr pScreen, Rotation * rotations)
	67	{
	68	RRScreenSizePtr pSize;
	69	ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
	70	XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
	71	DisplayModePtr mode;
	72	int refresh0 = 60;
	73	xorgRRModeMM RRModeMM;
	74
	75	*rotations = RR_Rotate_0;
	76
	77	for (mode = scrp->modes; mode != NULL; mode = mode->next) {
	78	int refresh = xf86RandRModeRefresh(mode);
	79
	80	if (mode == scrp->modes)
	81	refresh0 = refresh;
	82
	83	RRModeMM.mode = mode;
	84	RRModeMM.virtX = randrp->virtualX;
	85	RRModeMM.virtY = randrp->virtualY;
	86	RRModeMM.mmWidth = randrp->mmWidth;
	87	RRModeMM.mmHeight = randrp->mmHeight;
	88
	89	if (scrp->DriverFunc) {
	90	(*scrp->DriverFunc) (scrp, RR_GET_MODE_MM, &RRModeMM);
	91	}
	92
	93	pSize = RRRegisterSize(pScreen,
	94	mode->HDisplay, mode->VDisplay,
	95	RRModeMM.mmWidth, RRModeMM.mmHeight);
	96	if (!pSize)
	97	return FALSE;
	98	RRRegisterRate(pScreen, pSize, refresh);
	99	if (mode == scrp->currentMode &&
	100	mode->HDisplay == scrp->virtualX &&
	101	mode->VDisplay == scrp->virtualY)
	102	RRSetCurrentConfig(pScreen, randrp->rotation, refresh, pSize);
	103	if (mode->next == scrp->modes)
	104	break;
	105	}
	106	if (scrp->currentMode->HDisplay != randrp->virtualX \|\|
	107	scrp->currentMode->VDisplay != randrp->virtualY) {
	108	mode = scrp->modes;
	109
	110	RRModeMM.mode = NULL;
	111	RRModeMM.virtX = randrp->virtualX;
	112	RRModeMM.virtY = randrp->virtualY;
	113	RRModeMM.mmWidth = randrp->mmWidth;
	114	RRModeMM.mmHeight = randrp->mmHeight;
	115
	116	if (scrp->DriverFunc) {
	117	(*scrp->DriverFunc) (scrp, RR_GET_MODE_MM, &RRModeMM);
	118	}
	119
	120	pSize = RRRegisterSize(pScreen,
	121	randrp->virtualX, randrp->virtualY,
	122	RRModeMM.mmWidth, RRModeMM.mmHeight);
	123	if (!pSize)
	124	return FALSE;
	125	RRRegisterRate(pScreen, pSize, refresh0);
	126	if (scrp->virtualX == randrp->virtualX &&
	127	scrp->virtualY == randrp->virtualY) {
	128	RRSetCurrentConfig(pScreen, randrp->rotation, refresh0, pSize);
	129	}
	130	}
	131
	132	/* If there is driver support for randr, let it set our supported rotations */
	133	if (scrp->DriverFunc) {
	134	xorgRRRotation RRRotation;
	135
	136	RRRotation.RRRotations = *rotations;
	137	if (!(*scrp->DriverFunc) (scrp, RR_GET_INFO, &RRRotation))
	138	return TRUE;
	139	*rotations = RRRotation.RRRotations;
	140	}
	141
	142	return TRUE;
	143	}
	144
	145	static Bool
	146	xf86RandRSetMode(ScreenPtr pScreen,
	147	DisplayModePtr mode,
	148	Bool useVirtual, int mmWidth, int mmHeight)
	149	{
	150	ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
	151	XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
	152	int oldWidth = pScreen->width;
	153	int oldHeight = pScreen->height;
	154	int oldmmWidth = pScreen->mmWidth;
	155	int oldmmHeight = pScreen->mmHeight;
	156	int oldVirtualX = scrp->virtualX;
	157	int oldVirtualY = scrp->virtualY;
	158	WindowPtr pRoot = pScreen->root;
	159	Bool ret = TRUE;
	160
	161	if (pRoot && scrp->vtSema)
	162	(*scrp->EnableDisableFBAccess) (scrp, FALSE);
	163	if (useVirtual) {
	164	scrp->virtualX = randrp->virtualX;
	165	scrp->virtualY = randrp->virtualY;
	166	}
	167	else {
	168	scrp->virtualX = mode->HDisplay;
	169	scrp->virtualY = mode->VDisplay;
	170	}
	171
	172	/*
	173	* The DIX forgets the physical dimensions we passed into RRRegisterSize, so
	174	* reconstruct them if possible.
	175	*/
	176	if (scrp->DriverFunc) {
	177	xorgRRModeMM RRModeMM;
	178
	179	RRModeMM.mode = mode;
	180	RRModeMM.virtX = scrp->virtualX;
	181	RRModeMM.virtY = scrp->virtualY;
	182	RRModeMM.mmWidth = mmWidth;
	183	RRModeMM.mmHeight = mmHeight;
	184
	185	(*scrp->DriverFunc) (scrp, RR_GET_MODE_MM, &RRModeMM);
	186
	187	mmWidth = RRModeMM.mmWidth;
	188	mmHeight = RRModeMM.mmHeight;
	189	}
	190	if (randrp->rotation & (RR_Rotate_90 \| RR_Rotate_270)) {
	191	/* If the screen is rotated 90 or 270 degrees, swap the sizes. */
	192	pScreen->width = scrp->virtualY;
	193	pScreen->height = scrp->virtualX;
	194	pScreen->mmWidth = mmHeight;
	195	pScreen->mmHeight = mmWidth;
	196	}
	197	else {
	198	pScreen->width = scrp->virtualX;
	199	pScreen->height = scrp->virtualY;
	200	pScreen->mmWidth = mmWidth;
	201	pScreen->mmHeight = mmHeight;
	202	}
	203	if (!xf86SwitchMode(pScreen, mode)) {
	204	pScreen->width = oldWidth;
	205	pScreen->height = oldHeight;
	206	pScreen->mmWidth = oldmmWidth;
	207	pScreen->mmHeight = oldmmHeight;
	208	scrp->virtualX = oldVirtualX;
	209	scrp->virtualY = oldVirtualY;
	210	ret = FALSE;
	211	}
	212	/*
	213	* Make sure the layout is correct
	214	*/
	215	xf86ReconfigureLayout();
	216
	217	if (scrp->vtSema) {
	218	/*
	219	* Make sure the whole screen is visible
	220	*/
	221	xf86SetViewport (pScreen, pScreen->width, pScreen->height);
	222	xf86SetViewport (pScreen, 0, 0);
	223	if (pRoot)
	224	(*scrp->EnableDisableFBAccess) (scrp, TRUE);
	225	}
	226	return ret;
	227	}
	228
	229	static Bool
	230	xf86RandRSetConfig(ScreenPtr pScreen,
	231	Rotation rotation, int rate, RRScreenSizePtr pSize)
	232	{
	233	ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
	234	XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
	235	DisplayModePtr mode;
	236	int pos[MAXDEVICES][2];
	237	Bool useVirtual = FALSE;
	238	Rotation oldRotation = randrp->rotation;
	239	DeviceIntPtr dev;
	240	Bool view_adjusted = FALSE;
	241
	242	for (dev = inputInfo.devices; dev; dev = dev->next) {
	243	if (!IsMaster(dev) && !IsFloating(dev))
	244	continue;
	245
	246	miPointerGetPosition(dev, &pos[dev->id][0], &pos[dev->id][1]);
	247	}
	248
	249	for (mode = scrp->modes;; mode = mode->next) {
	250	if (mode->HDisplay == pSize->width &&
	251	mode->VDisplay == pSize->height &&
	252	(rate == 0 \|\| xf86RandRModeRefresh(mode) == rate))
	253	break;
	254	if (mode->next == scrp->modes) {
	255	if (pSize->width == randrp->virtualX &&
	256	pSize->height == randrp->virtualY) {
	257	mode = scrp->modes;
	258	useVirtual = TRUE;
	259	break;
	260	}
	261	return FALSE;
	262	}
	263	}
	264
	265	if (randrp->rotation != rotation) {
	266
	267	/* Have the driver do its thing. */
	268	if (scrp->DriverFunc) {
	269	xorgRRRotation RRRotation;
	270
	271	RRRotation.RRConfig.rotation = rotation;
	272	RRRotation.RRConfig.rate = rate;
	273	RRRotation.RRConfig.width = pSize->width;
	274	RRRotation.RRConfig.height = pSize->height;
	275
	276	/*
	277	* Currently we need to rely on HW support for rotation.
	278	*/
	279	if (!(*scrp->DriverFunc) (scrp, RR_SET_CONFIG, &RRRotation))
	280	return FALSE;
	281	}
	282	else
	283	return FALSE;
	284
	285	randrp->rotation = rotation;
	286	}
	287
	288	if (!xf86RandRSetMode
	289	(pScreen, mode, useVirtual, pSize->mmWidth, pSize->mmHeight)) {
	290	if (randrp->rotation != oldRotation) {
	291	/* Have the driver undo its thing. */
	292	if (scrp->DriverFunc) {
	293	xorgRRRotation RRRotation;
	294
	295	RRRotation.RRConfig.rotation = oldRotation;
	296	RRRotation.RRConfig.rate =
	297	xf86RandRModeRefresh(scrp->currentMode);
	298	RRRotation.RRConfig.width = scrp->virtualX;
	299	RRRotation.RRConfig.height = scrp->virtualY;
	300	(*scrp->DriverFunc) (scrp, RR_SET_CONFIG, &RRRotation);
	301	}
	302
	303	randrp->rotation = oldRotation;
	304	}
	305	return FALSE;
	306	}
	307
	308	update_desktop_dimensions();
	309
	310	/*
	311	* Move the cursor back where it belongs; SwitchMode repositions it
	312	* FIXME: duplicated code, see modes/xf86RandR12.c
	313	*/
	314	for (dev = inputInfo.devices; dev; dev = dev->next) {
	315	if (!IsMaster(dev) && !IsFloating(dev))
	316	continue;
	317
	318	if (pScreen == miPointerGetScreen(dev)) {
	319	int px = pos[dev->id][0];
	320	int py = pos[dev->id][1];
	321
	322	px = (px >= pScreen->width ? (pScreen->width - 1) : px);
	323	py = (py >= pScreen->height ? (pScreen->height - 1) : py);
	324
	325	/* Setting the viewpoint makes only sense on one device */
	326	if (!view_adjusted && IsMaster(dev)) {
	327	xf86SetViewport(pScreen, px, py);
	328	view_adjusted = TRUE;
	329	}
	330
	331	(*pScreen->SetCursorPosition) (dev, pScreen, px, py, FALSE);
	332	}
	333	}
	334
	335	return TRUE;
	336	}
	337
	338	/*
	339	* Wait until the screen is initialized before whacking the
	340	* sizes around; otherwise the screen pixmap will be allocated
	341	* at the current mode size rather than the maximum size
	342	*/
	343	static Bool
	344	xf86RandRCreateScreenResources(ScreenPtr pScreen)
	345	{
	346	XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
	347
	348	#if 0
	349	ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
	350	DisplayModePtr mode;
	351	#endif
	352
	353	pScreen->CreateScreenResources = randrp->CreateScreenResources;
	354	if (!(*pScreen->CreateScreenResources) (pScreen))
	355	return FALSE;
	356
	357	#if 0
	358	mode = scrp->currentMode;
	359	if (mode)
	360	xf86RandRSetMode(pScreen, mode, TRUE);
	361	#endif
	362
	363	return TRUE;
	364	}
	365
	366	/*
	367	* Reset size back to original
	368	*/
	369	static Bool
	370	xf86RandRCloseScreen(ScreenPtr pScreen)
	371	{
	372	ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
	373	XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
	374
	375	scrp->virtualX = pScreen->width = randrp->virtualX;
	376	scrp->virtualY = pScreen->height = randrp->virtualY;
	377	scrp->currentMode = scrp->modes;
	378	pScreen->CloseScreen = randrp->CloseScreen;
	379	free(randrp);
	380	dixSetPrivate(&pScreen->devPrivates, xf86RandRKey, NULL);
	381	return (*pScreen->CloseScreen) (pScreen);
	382	}
	383
	384	Rotation
	385	xf86GetRotation(ScreenPtr pScreen)
	386	{
	387	if (xf86RandRKey == NULL)
	388	return RR_Rotate_0;
	389
	390	return XF86RANDRINFO(pScreen)->rotation;
	391	}
	392
	393	/* Function to change RandR's idea of the virtual screen size */
	394	Bool
	395	xf86RandRSetNewVirtualAndDimensions(ScreenPtr pScreen,
	396	int newvirtX, int newvirtY, int newmmWidth,
	397	int newmmHeight, Bool resetMode)
	398	{
	399	XF86RandRInfoPtr randrp;
	400
	401	if (xf86RandRKey == NULL)
	402	return FALSE;
	403
	404	randrp = XF86RANDRINFO(pScreen);
	405	if (randrp == NULL)
	406	return FALSE;
	407
	408	if (newvirtX > 0)
	409	randrp->virtualX = newvirtX;
	410
	411	if (newvirtY > 0)
	412	randrp->virtualY = newvirtY;
	413
	414	if (newmmWidth > 0)
	415	randrp->mmWidth = newmmWidth;
	416
	417	if (newmmHeight > 0)
	418	randrp->mmHeight = newmmHeight;
	419
	420	/* This is only for during server start */
	421	if (resetMode) {
	422	ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
	423	return (xf86RandRSetMode(pScreen,
	424	pScrn->currentMode,
	425	TRUE, pScreen->mmWidth, pScreen->mmHeight));
	426	}
	427
	428	return TRUE;
	429	}
	430
	431	Bool
	432	xf86RandRInit(ScreenPtr pScreen)
	433	{
	434	rrScrPrivPtr rp;
	435	XF86RandRInfoPtr randrp;
	436	ScrnInfoPtr scrp = xf86ScreenToScrn(pScreen);
	437
	438	#ifdef PANORAMIX
	439	/* XXX disable RandR when using Xinerama */
	440	if (!noPanoramiXExtension)
	441	return TRUE;
	442	#endif
	443
	444	xf86RandRKey = &xf86RandRKeyRec;
	445
	446	if (!dixRegisterPrivateKey(&xf86RandRKeyRec, PRIVATE_SCREEN, 0))
	447	return FALSE;
	448
	449	randrp = malloc(sizeof(XF86RandRInfoRec));
	450	if (!randrp)
	451	return FALSE;
	452
	453	if (!RRScreenInit(pScreen)) {
	454	free(randrp);
	455	return FALSE;
	456	}
	457	rp = rrGetScrPriv(pScreen);
	458	rp->rrGetInfo = xf86RandRGetInfo;
	459	rp->rrSetConfig = xf86RandRSetConfig;
	460
	461	randrp->virtualX = scrp->virtualX;
	462	randrp->virtualY = scrp->virtualY;
	463	randrp->mmWidth = pScreen->mmWidth;
	464	randrp->mmHeight = pScreen->mmHeight;
	465
	466	randrp->CreateScreenResources = pScreen->CreateScreenResources;
	467	pScreen->CreateScreenResources = xf86RandRCreateScreenResources;
	468
	469	randrp->CloseScreen = pScreen->CloseScreen;
	470	pScreen->CloseScreen = xf86RandRCloseScreen;
	471
	472	randrp->rotation = RR_Rotate_0;
	473
	474	dixSetPrivate(&pScreen->devPrivates, xf86RandRKey, randrp);
	475	return TRUE;
	476	}