[deb_xorg-server.git] / hw / xfree86 / ramdac / xf86Cursor.c


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

#include "xf86.h"
#include "xf86CursorPriv.h"
#include "colormapst.h"
#include "cursorstr.h"

/* FIXME: This was added with the ABI change of the miPointerSpriteFuncs for
 * MPX.
 * inputInfo is needed to pass the core pointer as the default argument into
 * the cursor functions.
 *
 * Externing inputInfo is not the nice way to do it but it works.
 */
#include "inputstr.h"

DevPrivateKeyRec xf86CursorScreenKeyRec;

/* sprite functions */

static Bool xf86CursorRealizeCursor(DeviceIntPtr, ScreenPtr, CursorPtr);
static Bool xf86CursorUnrealizeCursor(DeviceIntPtr, ScreenPtr, CursorPtr);
static void xf86CursorSetCursor(DeviceIntPtr, ScreenPtr, CursorPtr, int, int);
static void xf86CursorMoveCursor(DeviceIntPtr, ScreenPtr, int, int);
static Bool xf86DeviceCursorInitialize(DeviceIntPtr, ScreenPtr);
static void xf86DeviceCursorCleanup(DeviceIntPtr, ScreenPtr);

static miPointerSpriteFuncRec xf86CursorSpriteFuncs = {
    xf86CursorRealizeCursor,
    xf86CursorUnrealizeCursor,
    xf86CursorSetCursor,
    xf86CursorMoveCursor,
    xf86DeviceCursorInitialize,
    xf86DeviceCursorCleanup
};

/* Screen functions */

static void xf86CursorInstallColormap(ColormapPtr);
static void xf86CursorRecolorCursor(DeviceIntPtr pDev, ScreenPtr, CursorPtr,
                                    Bool);
static Bool xf86CursorCloseScreen(ScreenPtr);
static void xf86CursorQueryBestSize(int, unsigned short *, unsigned short *,
                                    ScreenPtr);

/* ScrnInfoRec functions */

static void xf86CursorEnableDisableFBAccess(ScrnInfoPtr, Bool);
static Bool xf86CursorSwitchMode(ScrnInfoPtr, DisplayModePtr);

Bool
xf86InitCursor(ScreenPtr pScreen, xf86CursorInfoPtr infoPtr)
{
    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
    xf86CursorScreenPtr ScreenPriv;
    miPointerScreenPtr PointPriv;

    if (!xf86InitHardwareCursor(pScreen, infoPtr))
        return FALSE;

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

    ScreenPriv = calloc(1, sizeof(xf86CursorScreenRec));
    if (!ScreenPriv)
        return FALSE;

    dixSetPrivate(&pScreen->devPrivates, xf86CursorScreenKey, ScreenPriv);

    ScreenPriv->SWCursor = TRUE;
    ScreenPriv->isUp = FALSE;
    ScreenPriv->CurrentCursor = NULL;
    ScreenPriv->CursorInfoPtr = infoPtr;
    ScreenPriv->PalettedCursor = FALSE;
    ScreenPriv->pInstalledMap = NULL;

    ScreenPriv->CloseScreen = pScreen->CloseScreen;
    pScreen->CloseScreen = xf86CursorCloseScreen;
    ScreenPriv->QueryBestSize = pScreen->QueryBestSize;
    pScreen->QueryBestSize = xf86CursorQueryBestSize;
    ScreenPriv->RecolorCursor = pScreen->RecolorCursor;
    pScreen->RecolorCursor = xf86CursorRecolorCursor;

    if ((infoPtr->pScrn->bitsPerPixel == 8) &&
        !(infoPtr->Flags & HARDWARE_CURSOR_TRUECOLOR_AT_8BPP)) {
        ScreenPriv->InstallColormap = pScreen->InstallColormap;
        pScreen->InstallColormap = xf86CursorInstallColormap;
        ScreenPriv->PalettedCursor = TRUE;
    }

    PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey);

    ScreenPriv->showTransparent = PointPriv->showTransparent;
    if (infoPtr->Flags & HARDWARE_CURSOR_SHOW_TRANSPARENT)
        PointPriv->showTransparent = TRUE;
    else
        PointPriv->showTransparent = FALSE;
    ScreenPriv->spriteFuncs = PointPriv->spriteFuncs;
    PointPriv->spriteFuncs = &xf86CursorSpriteFuncs;

    ScreenPriv->EnableDisableFBAccess = pScrn->EnableDisableFBAccess;
    ScreenPriv->SwitchMode = pScrn->SwitchMode;

    ScreenPriv->ForceHWCursorCount = 0;
    ScreenPriv->HWCursorForced = FALSE;

    pScrn->EnableDisableFBAccess = xf86CursorEnableDisableFBAccess;
    if (pScrn->SwitchMode)
        pScrn->SwitchMode = xf86CursorSwitchMode;

    return TRUE;
}

/***** Screen functions *****/

static Bool
xf86CursorCloseScreen(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
    miPointerScreenPtr PointPriv =
        (miPointerScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                              miPointerScreenKey);
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    if (ScreenPriv->isUp && pScrn->vtSema)
        xf86SetCursor(pScreen, NullCursor, ScreenPriv->x, ScreenPriv->y);

    if (ScreenPriv->CurrentCursor)
        FreeCursor(ScreenPriv->CurrentCursor, None);

    pScreen->CloseScreen = ScreenPriv->CloseScreen;
    pScreen->QueryBestSize = ScreenPriv->QueryBestSize;
    pScreen->RecolorCursor = ScreenPriv->RecolorCursor;
    if (ScreenPriv->InstallColormap)
        pScreen->InstallColormap = ScreenPriv->InstallColormap;

    PointPriv->spriteFuncs = ScreenPriv->spriteFuncs;
    PointPriv->showTransparent = ScreenPriv->showTransparent;

    pScrn->EnableDisableFBAccess = ScreenPriv->EnableDisableFBAccess;
    pScrn->SwitchMode = ScreenPriv->SwitchMode;

    free(ScreenPriv->transparentData);
    free(ScreenPriv);

    return (*pScreen->CloseScreen) (pScreen);
}

static void
xf86CursorQueryBestSize(int class,
                        unsigned short *width,
                        unsigned short *height, ScreenPtr pScreen)
{
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    if (class == CursorShape) {
        if (*width > ScreenPriv->CursorInfoPtr->MaxWidth)
            *width = ScreenPriv->CursorInfoPtr->MaxWidth;
        if (*height > ScreenPriv->CursorInfoPtr->MaxHeight)
            *height = ScreenPriv->CursorInfoPtr->MaxHeight;
    }
    else
        (*ScreenPriv->QueryBestSize) (class, width, height, pScreen);
}

static void
xf86CursorInstallColormap(ColormapPtr pMap)
{
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pMap->pScreen->devPrivates,
                                               xf86CursorScreenKey);

    ScreenPriv->pInstalledMap = pMap;

    (*ScreenPriv->InstallColormap) (pMap);
}

static void
xf86CursorRecolorCursor(DeviceIntPtr pDev,
                        ScreenPtr pScreen, CursorPtr pCurs, Bool displayed)
{
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    if (!displayed)
        return;

    if (ScreenPriv->SWCursor)
        (*ScreenPriv->RecolorCursor) (pDev, pScreen, pCurs, displayed);
    else
        xf86RecolorCursor(pScreen, pCurs, displayed);
}

/***** ScrnInfoRec functions *********/

static void
xf86CursorEnableDisableFBAccess(ScrnInfoPtr pScrn, Bool enable)
{
    DeviceIntPtr pDev = inputInfo.pointer;

    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    if (!enable && ScreenPriv->CurrentCursor != NullCursor) {
        CursorPtr currentCursor = ScreenPriv->CurrentCursor;

        xf86CursorSetCursor(pDev, pScreen, NullCursor, ScreenPriv->x,
                            ScreenPriv->y);
        ScreenPriv->isUp = FALSE;
        ScreenPriv->SWCursor = TRUE;
        ScreenPriv->SavedCursor = currentCursor;
    }

    if (ScreenPriv->EnableDisableFBAccess)
        (*ScreenPriv->EnableDisableFBAccess) (pScrn, enable);

    if (enable && ScreenPriv->SavedCursor) {
        /*
         * Re-set current cursor so drivers can react to FB access having been
         * temporarily disabled.
         */
        xf86CursorSetCursor(pDev, pScreen, ScreenPriv->SavedCursor,
                            ScreenPriv->x, ScreenPriv->y);
        ScreenPriv->SavedCursor = NULL;
    }
}

static Bool
xf86CursorSwitchMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
    Bool ret;
    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    if (ScreenPriv->isUp) {
        xf86SetCursor(pScreen, NullCursor, ScreenPriv->x, ScreenPriv->y);
        ScreenPriv->isUp = FALSE;
    }

    ret = (*ScreenPriv->SwitchMode) (pScrn, mode);

    /*
     * Cannot restore cursor here because the new frame[XY][01] haven't been
     * calculated yet.  However, because the hardware cursor was removed above,
     * ensure the cursor is repainted by miPointerWarpCursor().
     */
    ScreenPriv->CursorToRestore = ScreenPriv->CurrentCursor;
    miPointerSetWaitForUpdate(pScreen, FALSE);  /* Force cursor repaint */

    return ret;
}

/****** miPointerSpriteFunctions *******/

static Bool
xf86CursorRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
{
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    if (CursorRefCount(pCurs) <= 1)
        dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen,
                            NULL);

    return (*ScreenPriv->spriteFuncs->RealizeCursor) (pDev, pScreen, pCurs);
}

static Bool
xf86CursorUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
{
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    if (CursorRefCount(pCurs) <= 1) {
        free(dixLookupScreenPrivate
             (&pCurs->devPrivates, CursorScreenKey, pScreen));
        dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen,
                            NULL);
    }

    return (*ScreenPriv->spriteFuncs->UnrealizeCursor) (pDev, pScreen, pCurs);
}

static void
xf86CursorSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs,
                    int x, int y)
{
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);
    xf86CursorInfoPtr infoPtr = ScreenPriv->CursorInfoPtr;

    if (pCurs == NullCursor) {  /* means we're supposed to remove the cursor */
        if (ScreenPriv->SWCursor ||
            !(GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer))
            (*ScreenPriv->spriteFuncs->SetCursor) (pDev, pScreen, NullCursor, x,
                                                   y);
        else if (ScreenPriv->isUp) {
            xf86SetCursor(pScreen, NullCursor, x, y);
            ScreenPriv->isUp = FALSE;
        }
        if (ScreenPriv->CurrentCursor)
            FreeCursor(ScreenPriv->CurrentCursor, None);
        ScreenPriv->CurrentCursor = NullCursor;
        return;
    }

    /* only update for VCP, otherwise we get cursor jumps when removing a
       sprite. The second cursor is never HW rendered anyway. */
    if (GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer) {
        CursorPtr cursor = RefCursor(pCurs);
        if (ScreenPriv->CurrentCursor)
            FreeCursor(ScreenPriv->CurrentCursor, None);
        ScreenPriv->CurrentCursor = cursor;
        ScreenPriv->x = x;
        ScreenPriv->y = y;
        ScreenPriv->CursorToRestore = NULL;
        ScreenPriv->HotX = cursor->bits->xhot;
        ScreenPriv->HotY = cursor->bits->yhot;

        if (!infoPtr->pScrn->vtSema)
            ScreenPriv->SavedCursor = cursor;

        if (infoPtr->pScrn->vtSema && xorg_list_is_empty(&pScreen->pixmap_dirty_list) &&
            (ScreenPriv->ForceHWCursorCount ||
             ((
#ifdef ARGB_CURSOR
               cursor->bits->argb &&
               infoPtr->UseHWCursorARGB &&
               (*infoPtr->UseHWCursorARGB)(pScreen, cursor)) ||
              (cursor->bits->argb == 0 &&
#endif
               (cursor->bits->height <= infoPtr->MaxHeight) &&
               (cursor->bits->width <= infoPtr->MaxWidth) &&
               (!infoPtr->UseHWCursor || (*infoPtr->UseHWCursor) (pScreen, cursor)))))) {
            
            if (ScreenPriv->SWCursor)   /* remove the SW cursor */
                (*ScreenPriv->spriteFuncs->SetCursor) (pDev, pScreen,
                                                       NullCursor, x, y);

            xf86SetCursor(pScreen, cursor, x, y);
            ScreenPriv->SWCursor = FALSE;
            ScreenPriv->isUp = TRUE;

            miPointerSetWaitForUpdate(pScreen, !infoPtr->pScrn->silkenMouse);
            return;
        }

        miPointerSetWaitForUpdate(pScreen, TRUE);

        if (ScreenPriv->isUp) {
            /* Remove the HW cursor, or make it transparent */
            if (infoPtr->Flags & HARDWARE_CURSOR_SHOW_TRANSPARENT) {
                xf86SetTransparentCursor(pScreen);
            }
            else {
                xf86SetCursor(pScreen, NullCursor, x, y);
                ScreenPriv->isUp = FALSE;
            }
        }

        if (!ScreenPriv->SWCursor)
            ScreenPriv->SWCursor = TRUE;

    }

    if (pCurs->bits->emptyMask && !ScreenPriv->showTransparent)
        pCurs = NullCursor;

    (*ScreenPriv->spriteFuncs->SetCursor) (pDev, pScreen, pCurs, x, y);
}

static void
xf86CursorMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    /* only update coordinate state for first sprite, otherwise we get jumps
       when removing a sprite. The second sprite is never HW rendered anyway */
    if (GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer) {
        ScreenPriv->x = x;
        ScreenPriv->y = y;

        if (ScreenPriv->CursorToRestore)
            xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CursorToRestore, x,
                                y);
        else if (ScreenPriv->SWCursor)
            (*ScreenPriv->spriteFuncs->MoveCursor) (pDev, pScreen, x, y);
        else if (ScreenPriv->isUp)
            xf86MoveCursor(pScreen, x, y);
    }
    else
        (*ScreenPriv->spriteFuncs->MoveCursor) (pDev, pScreen, x, y);
}

void
xf86ForceHWCursor(ScreenPtr pScreen, Bool on)
{
    DeviceIntPtr pDev = inputInfo.pointer;
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    if (on) {
        if (ScreenPriv->ForceHWCursorCount++ == 0) {
            if (ScreenPriv->SWCursor && ScreenPriv->CurrentCursor) {
                ScreenPriv->HWCursorForced = TRUE;
                xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CurrentCursor,
                                    ScreenPriv->x, ScreenPriv->y);
            }
            else
                ScreenPriv->HWCursorForced = FALSE;
        }
    }
    else {
        if (--ScreenPriv->ForceHWCursorCount == 0) {
            if (ScreenPriv->HWCursorForced && ScreenPriv->CurrentCursor)
                xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CurrentCursor,
                                    ScreenPriv->x, ScreenPriv->y);
        }
    }
}

xf86CursorInfoPtr
xf86CreateCursorInfoRec(void)
{
    return calloc(1, sizeof(xf86CursorInfoRec));
}

void
xf86DestroyCursorInfoRec(xf86CursorInfoPtr infoPtr)
{
    free(infoPtr);
}

/**
 * New cursor has been created. Do your initalizations here.
 */
static Bool
xf86DeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
{
    int ret;
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    /* Init SW cursor */
    ret = (*ScreenPriv->spriteFuncs->DeviceCursorInitialize) (pDev, pScreen);

    return ret;
}

/**
 * Cursor has been removed. Clean up after yourself.
 */
static void
xf86DeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
{
    xf86CursorScreenPtr ScreenPriv =
        (xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
                                               xf86CursorScreenKey);

    /* Clean up SW cursor */
    (*ScreenPriv->spriteFuncs->DeviceCursorCleanup) (pDev, pScreen);
}
Commit	Line	Data
a09e091a JB	1
	2	#ifdef HAVE_XORG_CONFIG_H
	3	#include <xorg-config.h>
	4	#endif
	5
	6	#include "xf86.h"
	7	#include "xf86CursorPriv.h"
	8	#include "colormapst.h"
	9	#include "cursorstr.h"
	10
	11	/* FIXME: This was added with the ABI change of the miPointerSpriteFuncs for
	12	* MPX.
	13	* inputInfo is needed to pass the core pointer as the default argument into
	14	* the cursor functions.
	15	*
	16	* Externing inputInfo is not the nice way to do it but it works.
	17	*/
	18	#include "inputstr.h"
	19
	20	DevPrivateKeyRec xf86CursorScreenKeyRec;
	21
	22	/* sprite functions */
	23
	24	static Bool xf86CursorRealizeCursor(DeviceIntPtr, ScreenPtr, CursorPtr);
	25	static Bool xf86CursorUnrealizeCursor(DeviceIntPtr, ScreenPtr, CursorPtr);
	26	static void xf86CursorSetCursor(DeviceIntPtr, ScreenPtr, CursorPtr, int, int);
	27	static void xf86CursorMoveCursor(DeviceIntPtr, ScreenPtr, int, int);
	28	static Bool xf86DeviceCursorInitialize(DeviceIntPtr, ScreenPtr);
	29	static void xf86DeviceCursorCleanup(DeviceIntPtr, ScreenPtr);
	30
	31	static miPointerSpriteFuncRec xf86CursorSpriteFuncs = {
	32	xf86CursorRealizeCursor,
	33	xf86CursorUnrealizeCursor,
	34	xf86CursorSetCursor,
	35	xf86CursorMoveCursor,
	36	xf86DeviceCursorInitialize,
	37	xf86DeviceCursorCleanup
	38	};
	39
	40	/* Screen functions */
	41
	42	static void xf86CursorInstallColormap(ColormapPtr);
	43	static void xf86CursorRecolorCursor(DeviceIntPtr pDev, ScreenPtr, CursorPtr,
	44	Bool);
	45	static Bool xf86CursorCloseScreen(ScreenPtr);
	46	static void xf86CursorQueryBestSize(int, unsigned short , unsigned short ,
	47	ScreenPtr);
	48
	49	/* ScrnInfoRec functions */
	50
	51	static void xf86CursorEnableDisableFBAccess(ScrnInfoPtr, Bool);
	52	static Bool xf86CursorSwitchMode(ScrnInfoPtr, DisplayModePtr);
	53
	54	Bool
	55	xf86InitCursor(ScreenPtr pScreen, xf86CursorInfoPtr infoPtr)
	56	{
	57	ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
	58	xf86CursorScreenPtr ScreenPriv;
	59	miPointerScreenPtr PointPriv;
	60
	61	if (!xf86InitHardwareCursor(pScreen, infoPtr))
	62	return FALSE;
	63
	64	if (!dixRegisterPrivateKey(&xf86CursorScreenKeyRec, PRIVATE_SCREEN, 0))
65	return FALSE;
66
67	ScreenPriv = calloc(1, sizeof(xf86CursorScreenRec));
68	if (!ScreenPriv)
69	return FALSE;
70
71	dixSetPrivate(&pScreen->devPrivates, xf86CursorScreenKey, ScreenPriv);
72
73	ScreenPriv->SWCursor = TRUE;
74	ScreenPriv->isUp = FALSE;
75	ScreenPriv->CurrentCursor = NULL;
76	ScreenPriv->CursorInfoPtr = infoPtr;
77	ScreenPriv->PalettedCursor = FALSE;
78	ScreenPriv->pInstalledMap = NULL;
79
80	ScreenPriv->CloseScreen = pScreen->CloseScreen;
81	pScreen->CloseScreen = xf86CursorCloseScreen;
82	ScreenPriv->QueryBestSize = pScreen->QueryBestSize;
83	pScreen->QueryBestSize = xf86CursorQueryBestSize;
84	ScreenPriv->RecolorCursor = pScreen->RecolorCursor;
85	pScreen->RecolorCursor = xf86CursorRecolorCursor;
86
87	if ((infoPtr->pScrn->bitsPerPixel == 8) &&
88	!(infoPtr->Flags & HARDWARE_CURSOR_TRUECOLOR_AT_8BPP)) {
89	ScreenPriv->InstallColormap = pScreen->InstallColormap;
90	pScreen->InstallColormap = xf86CursorInstallColormap;
91	ScreenPriv->PalettedCursor = TRUE;
92	}
93
94	PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey);
95
96	ScreenPriv->showTransparent = PointPriv->showTransparent;
97	if (infoPtr->Flags & HARDWARE_CURSOR_SHOW_TRANSPARENT)
98	PointPriv->showTransparent = TRUE;
99	else
100	PointPriv->showTransparent = FALSE;
101	ScreenPriv->spriteFuncs = PointPriv->spriteFuncs;
102	PointPriv->spriteFuncs = &xf86CursorSpriteFuncs;
103
104	ScreenPriv->EnableDisableFBAccess = pScrn->EnableDisableFBAccess;
105	ScreenPriv->SwitchMode = pScrn->SwitchMode;
106
107	ScreenPriv->ForceHWCursorCount = 0;
108	ScreenPriv->HWCursorForced = FALSE;
109
110	pScrn->EnableDisableFBAccess = xf86CursorEnableDisableFBAccess;
111	if (pScrn->SwitchMode)
112	pScrn->SwitchMode = xf86CursorSwitchMode;
113
114	return TRUE;
115	}
116
117	/*** Screen functions ***/
118
119	static Bool
120	xf86CursorCloseScreen(ScreenPtr pScreen)
121	{
122	ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
123	miPointerScreenPtr PointPriv =
124	(miPointerScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
125	miPointerScreenKey);
126	xf86CursorScreenPtr ScreenPriv =
127	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
128	xf86CursorScreenKey);
129
130	if (ScreenPriv->isUp && pScrn->vtSema)
131	xf86SetCursor(pScreen, NullCursor, ScreenPriv->x, ScreenPriv->y);
132
133	if (ScreenPriv->CurrentCursor)
134	FreeCursor(ScreenPriv->CurrentCursor, None);
135
136	pScreen->CloseScreen = ScreenPriv->CloseScreen;
137	pScreen->QueryBestSize = ScreenPriv->QueryBestSize;
138	pScreen->RecolorCursor = ScreenPriv->RecolorCursor;
139	if (ScreenPriv->InstallColormap)
140	pScreen->InstallColormap = ScreenPriv->InstallColormap;
141
142	PointPriv->spriteFuncs = ScreenPriv->spriteFuncs;
143	PointPriv->showTransparent = ScreenPriv->showTransparent;
144
145	pScrn->EnableDisableFBAccess = ScreenPriv->EnableDisableFBAccess;
146	pScrn->SwitchMode = ScreenPriv->SwitchMode;
147
148	free(ScreenPriv->transparentData);
149	free(ScreenPriv);
150
151	return (*pScreen->CloseScreen) (pScreen);
152	}
153
154	static void
155	xf86CursorQueryBestSize(int class,
156	unsigned short *width,
157	unsigned short *height, ScreenPtr pScreen)
158	{
159	xf86CursorScreenPtr ScreenPriv =
160	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
161	xf86CursorScreenKey);
162
163	if (class == CursorShape) {
164	if (*width > ScreenPriv->CursorInfoPtr->MaxWidth)
165	*width = ScreenPriv->CursorInfoPtr->MaxWidth;
166	if (*height > ScreenPriv->CursorInfoPtr->MaxHeight)
167	*height = ScreenPriv->CursorInfoPtr->MaxHeight;
168	}
169	else
170	(*ScreenPriv->QueryBestSize) (class, width, height, pScreen);
171	}
172
173	static void
174	xf86CursorInstallColormap(ColormapPtr pMap)
175	{
176	xf86CursorScreenPtr ScreenPriv =
177	(xf86CursorScreenPtr) dixLookupPrivate(&pMap->pScreen->devPrivates,
178	xf86CursorScreenKey);
179
180	ScreenPriv->pInstalledMap = pMap;
181
182	(*ScreenPriv->InstallColormap) (pMap);
183	}
184
185	static void
186	xf86CursorRecolorCursor(DeviceIntPtr pDev,
187	ScreenPtr pScreen, CursorPtr pCurs, Bool displayed)
188	{
189	xf86CursorScreenPtr ScreenPriv =
190	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
191	xf86CursorScreenKey);
192
193	if (!displayed)
194	return;
195
196	if (ScreenPriv->SWCursor)
197	(*ScreenPriv->RecolorCursor) (pDev, pScreen, pCurs, displayed);
198	else
199	xf86RecolorCursor(pScreen, pCurs, displayed);
200	}
201
202	/*** ScrnInfoRec functions *******/
203
204	static void
205	xf86CursorEnableDisableFBAccess(ScrnInfoPtr pScrn, Bool enable)
206	{
207	DeviceIntPtr pDev = inputInfo.pointer;
208
209	ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
210	xf86CursorScreenPtr ScreenPriv =
211	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
212	xf86CursorScreenKey);
213
214	if (!enable && ScreenPriv->CurrentCursor != NullCursor) {
215	CursorPtr currentCursor = ScreenPriv->CurrentCursor;
216
217	xf86CursorSetCursor(pDev, pScreen, NullCursor, ScreenPriv->x,
218	ScreenPriv->y);
219	ScreenPriv->isUp = FALSE;
220	ScreenPriv->SWCursor = TRUE;
221	ScreenPriv->SavedCursor = currentCursor;
222	}
223
224	if (ScreenPriv->EnableDisableFBAccess)
225	(*ScreenPriv->EnableDisableFBAccess) (pScrn, enable);
226
227	if (enable && ScreenPriv->SavedCursor) {
228	/*
229	* Re-set current cursor so drivers can react to FB access having been
230	* temporarily disabled.
231	*/
232	xf86CursorSetCursor(pDev, pScreen, ScreenPriv->SavedCursor,
233	ScreenPriv->x, ScreenPriv->y);
234	ScreenPriv->SavedCursor = NULL;
235	}
236	}
237
238	static Bool
239	xf86CursorSwitchMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
240	{
241	Bool ret;
242	ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
243	xf86CursorScreenPtr ScreenPriv =
244	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
245	xf86CursorScreenKey);
246
247	if (ScreenPriv->isUp) {
248	xf86SetCursor(pScreen, NullCursor, ScreenPriv->x, ScreenPriv->y);
249	ScreenPriv->isUp = FALSE;
250	}
251
252	ret = (*ScreenPriv->SwitchMode) (pScrn, mode);
253
254	/*
255	* Cannot restore cursor here because the new frame[XY][01] haven't been
256	* calculated yet. However, because the hardware cursor was removed above,
257	* ensure the cursor is repainted by miPointerWarpCursor().
258	*/
259	ScreenPriv->CursorToRestore = ScreenPriv->CurrentCursor;
260	miPointerSetWaitForUpdate(pScreen, FALSE); /* Force cursor repaint */
261
262	return ret;
263	}
264
265	/**** miPointerSpriteFunctions *****/
266
267	static Bool
268	xf86CursorRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
269	{
270	xf86CursorScreenPtr ScreenPriv =
271	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
272	xf86CursorScreenKey);
273
274	if (CursorRefCount(pCurs) <= 1)
275	dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen,
276	NULL);
277
278	return (*ScreenPriv->spriteFuncs->RealizeCursor) (pDev, pScreen, pCurs);
279	}
280
281	static Bool
282	xf86CursorUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
283	{
284	xf86CursorScreenPtr ScreenPriv =
285	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
286	xf86CursorScreenKey);
287
288	if (CursorRefCount(pCurs) <= 1) {
289	free(dixLookupScreenPrivate
290	(&pCurs->devPrivates, CursorScreenKey, pScreen));
291	dixSetScreenPrivate(&pCurs->devPrivates, CursorScreenKey, pScreen,
292	NULL);
293	}
294
295	return (*ScreenPriv->spriteFuncs->UnrealizeCursor) (pDev, pScreen, pCurs);
296	}
297
298	static void
299	xf86CursorSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs,
300	int x, int y)
301	{
302	xf86CursorScreenPtr ScreenPriv =
303	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
304	xf86CursorScreenKey);
305	xf86CursorInfoPtr infoPtr = ScreenPriv->CursorInfoPtr;
306
307	if (pCurs == NullCursor) { /* means we're supposed to remove the cursor */
308	if (ScreenPriv->SWCursor \|\|
309	!(GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer))
310	(*ScreenPriv->spriteFuncs->SetCursor) (pDev, pScreen, NullCursor, x,
311	y);
312	else if (ScreenPriv->isUp) {
313	xf86SetCursor(pScreen, NullCursor, x, y);
314	ScreenPriv->isUp = FALSE;
315	}
316	if (ScreenPriv->CurrentCursor)
317	FreeCursor(ScreenPriv->CurrentCursor, None);
318	ScreenPriv->CurrentCursor = NullCursor;
319	return;
320	}
321
322	/* only update for VCP, otherwise we get cursor jumps when removing a
323	sprite. The second cursor is never HW rendered anyway. */
324	if (GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer) {
325	CursorPtr cursor = RefCursor(pCurs);
326	if (ScreenPriv->CurrentCursor)
327	FreeCursor(ScreenPriv->CurrentCursor, None);
328	ScreenPriv->CurrentCursor = cursor;
329	ScreenPriv->x = x;
330	ScreenPriv->y = y;
331	ScreenPriv->CursorToRestore = NULL;
332	ScreenPriv->HotX = cursor->bits->xhot;
333	ScreenPriv->HotY = cursor->bits->yhot;
334
335	if (!infoPtr->pScrn->vtSema)
336	ScreenPriv->SavedCursor = cursor;
337
338	if (infoPtr->pScrn->vtSema && xorg_list_is_empty(&pScreen->pixmap_dirty_list) &&
339	(ScreenPriv->ForceHWCursorCount \|\|
340	((
341	#ifdef ARGB_CURSOR
342	cursor->bits->argb &&
343	infoPtr->UseHWCursorARGB &&
344	(*infoPtr->UseHWCursorARGB)(pScreen, cursor)) \|\|
345	(cursor->bits->argb == 0 &&
346	#endif
347	(cursor->bits->height <= infoPtr->MaxHeight) &&
348	(cursor->bits->width <= infoPtr->MaxWidth) &&
349	(!infoPtr->UseHWCursor \|\| (*infoPtr->UseHWCursor) (pScreen, cursor)))))) {
350
351	if (ScreenPriv->SWCursor) /* remove the SW cursor */
352	(*ScreenPriv->spriteFuncs->SetCursor) (pDev, pScreen,
353	NullCursor, x, y);
354
355	xf86SetCursor(pScreen, cursor, x, y);
356	ScreenPriv->SWCursor = FALSE;
357	ScreenPriv->isUp = TRUE;
358
359	miPointerSetWaitForUpdate(pScreen, !infoPtr->pScrn->silkenMouse);
360	return;
361	}
362
363	miPointerSetWaitForUpdate(pScreen, TRUE);
364
365	if (ScreenPriv->isUp) {
366	/* Remove the HW cursor, or make it transparent */
367	if (infoPtr->Flags & HARDWARE_CURSOR_SHOW_TRANSPARENT) {
368	xf86SetTransparentCursor(pScreen);
369	}
370	else {
371	xf86SetCursor(pScreen, NullCursor, x, y);
372	ScreenPriv->isUp = FALSE;
373	}
374	}
375
376	if (!ScreenPriv->SWCursor)
377	ScreenPriv->SWCursor = TRUE;
378
379	}
380
381	if (pCurs->bits->emptyMask && !ScreenPriv->showTransparent)
382	pCurs = NullCursor;
383
384	(*ScreenPriv->spriteFuncs->SetCursor) (pDev, pScreen, pCurs, x, y);
385	}
386
387	static void
388	xf86CursorMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
389	{
390	xf86CursorScreenPtr ScreenPriv =
391	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
392	xf86CursorScreenKey);
393
394	/* only update coordinate state for first sprite, otherwise we get jumps
395	when removing a sprite. The second sprite is never HW rendered anyway */
396	if (GetMaster(pDev, MASTER_POINTER) == inputInfo.pointer) {
397	ScreenPriv->x = x;
398	ScreenPriv->y = y;
399
400	if (ScreenPriv->CursorToRestore)
401	xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CursorToRestore, x,
402	y);
403	else if (ScreenPriv->SWCursor)
404	(*ScreenPriv->spriteFuncs->MoveCursor) (pDev, pScreen, x, y);
405	else if (ScreenPriv->isUp)
406	xf86MoveCursor(pScreen, x, y);
407	}
408	else
409	(*ScreenPriv->spriteFuncs->MoveCursor) (pDev, pScreen, x, y);
410	}
411
412	void
413	xf86ForceHWCursor(ScreenPtr pScreen, Bool on)
414	{
415	DeviceIntPtr pDev = inputInfo.pointer;
416	xf86CursorScreenPtr ScreenPriv =
417	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
418	xf86CursorScreenKey);
419
420	if (on) {
421	if (ScreenPriv->ForceHWCursorCount++ == 0) {
422	if (ScreenPriv->SWCursor && ScreenPriv->CurrentCursor) {
423	ScreenPriv->HWCursorForced = TRUE;
424	xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CurrentCursor,
425	ScreenPriv->x, ScreenPriv->y);
426	}
427	else
428	ScreenPriv->HWCursorForced = FALSE;
429	}
430	}
431	else {
432	if (--ScreenPriv->ForceHWCursorCount == 0) {
433	if (ScreenPriv->HWCursorForced && ScreenPriv->CurrentCursor)
434	xf86CursorSetCursor(pDev, pScreen, ScreenPriv->CurrentCursor,
435	ScreenPriv->x, ScreenPriv->y);
436	}
437	}
438	}
439
440	xf86CursorInfoPtr
441	xf86CreateCursorInfoRec(void)
442	{
443	return calloc(1, sizeof(xf86CursorInfoRec));
444	}
445
446	void
447	xf86DestroyCursorInfoRec(xf86CursorInfoPtr infoPtr)
448	{
449	free(infoPtr);
450	}
451
452	/**
453	* New cursor has been created. Do your initalizations here.
454	*/
455	static Bool
456	xf86DeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
457	{
458	int ret;
459	xf86CursorScreenPtr ScreenPriv =
460	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
461	xf86CursorScreenKey);
462
463	/* Init SW cursor */
464	ret = (*ScreenPriv->spriteFuncs->DeviceCursorInitialize) (pDev, pScreen);
465
466	return ret;
467	}
468
469	/**
470	* Cursor has been removed. Clean up after yourself.
471	*/
472	static void
473	xf86DeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
474	{
475	xf86CursorScreenPtr ScreenPriv =
476	(xf86CursorScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
477	xf86CursorScreenKey);
478
479	/* Clean up SW cursor */
480	(*ScreenPriv->spriteFuncs->DeviceCursorCleanup) (pDev, pScreen);
481	}