qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
49012820cb
xenocara/xserver/hw/xfree86/common/xf86Cursor.c

866 lines
22 KiB
C
Raw Blame History

/*
* Copyright (c) 1994-2003 by The XFree86 Project, Inc.
*
* 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 COPYRIGHT HOLDER(S) OR AUTHOR(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 of the copyright holder(s)
* and author(s) shall not be used in advertising or otherwise to promote
* the sale, use or other dealings in this Software without prior written
* authorization from the copyright holder(s) and author(s).
*/
#define NEED_EVENTS
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include "input.h"
#include "cursor.h"
#include "mipointer.h"
#include "scrnintstr.h"
#include "globals.h"
#include "compiler.h"
#include "xf86.h"
#include "xf86Priv.h"
#include "xf86_OSproc.h"
#include <X11/extensions/XIproto.h>
#include "xf86Xinput.h"
#ifdef XFreeXDGA
#include "dgaproc.h"
#endif
typedef struct _xf86EdgeRec {
short screen;
short start;
short end;
DDXPointRec offset;
struct _xf86EdgeRec *next;
} xf86EdgeRec, *xf86EdgePtr;
typedef struct {
xf86EdgePtr left, right, up, down;
} xf86ScreenLayoutRec, *xf86ScreenLayoutPtr;
static Bool xf86CursorOffScreen(ScreenPtr *pScreen, int *x, int *y);
static void xf86CrossScreen(ScreenPtr pScreen, Bool entering);
static void xf86WarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y);
static void xf86PointerMoved(int scrnIndex, int x, int y);
static miPointerScreenFuncRec xf86PointerScreenFuncs = {
xf86CursorOffScreen,
xf86CrossScreen,
xf86WarpCursor,
/* let miPointerInitialize take care of these */
NULL,
NULL
};
static xf86ScreenLayoutRec xf86ScreenLayout[MAXSCREENS];
static Bool HardEdges;
/*
* xf86InitViewport --
* Initialize paning & zooming parameters, so that a driver must only
* check what resolutions are possible and whether the virtual area
* is valid if specified.
*/
void
xf86InitViewport(ScrnInfoPtr pScr)
{
pScr->PointerMoved = xf86PointerMoved;
/*
* Compute the initial Viewport if necessary
*/
if (pScr->display) {
if (pScr->display->frameX0 < 0) {
pScr->frameX0 = (pScr->virtualX - pScr->modes->HDisplay) / 2;
pScr->frameY0 = (pScr->virtualY - pScr->modes->VDisplay) / 2;
} else {
pScr->frameX0 = pScr->display->frameX0;
pScr->frameY0 = pScr->display->frameY0;
}
}
pScr->frameX1 = pScr->frameX0 + pScr->modes->HDisplay - 1;
pScr->frameY1 = pScr->frameY0 + pScr->modes->VDisplay - 1;
/*
* Now adjust the initial Viewport, so it lies within the virtual area
*/
if (pScr->frameX1 >= pScr->virtualX)
{
pScr->frameX0 = pScr->virtualX - pScr->modes->HDisplay;
pScr->frameX1 = pScr->frameX0 + pScr->modes->HDisplay - 1;
}
if (pScr->frameY1 >= pScr->virtualY)
{
pScr->frameY0 = pScr->virtualY - pScr->modes->VDisplay;
pScr->frameY1 = pScr->frameY0 + pScr->modes->VDisplay - 1;
}
}
/*
* xf86SetViewport --
* Scroll the visual part of the screen so the pointer is visible.
*/
void
xf86SetViewport(ScreenPtr pScreen, int x, int y)
{
ScrnInfoPtr pScr = XF86SCRNINFO(pScreen);
(*pScr->PointerMoved)(pScreen->myNum, x, y);
}
static void
xf86PointerMoved(int scrnIndex, int x, int y)
{
Bool frameChanged = FALSE;
ScrnInfoPtr pScr = xf86Screens[scrnIndex];
/*
* check wether (x,y) belongs to the visual part of the screen
* if not, change the base of the displayed frame accoring
*/
if ( pScr->frameX0 > x) {
pScr->frameX0 = x;
pScr->frameX1 = x + pScr->currentMode->HDisplay - 1;
frameChanged = TRUE ;
}
if ( pScr->frameX1 < x) {
pScr->frameX1 = x + 1;
pScr->frameX0 = x - pScr->currentMode->HDisplay + 1;
frameChanged = TRUE ;
}
if ( pScr->frameY0 > y) {
pScr->frameY0 = y;
pScr->frameY1 = y + pScr->currentMode->VDisplay - 1;
frameChanged = TRUE;
}
if ( pScr->frameY1 < y) {
pScr->frameY1 = y;
pScr->frameY0 = y - pScr->currentMode->VDisplay + 1;
frameChanged = TRUE;
}
if (frameChanged && pScr->AdjustFrame != NULL)
pScr->AdjustFrame(pScr->scrnIndex, pScr->frameX0, pScr->frameY0, 0);
}
/*
* xf86LockZoom --
* Enable/disable ZoomViewport
*/
void
xf86LockZoom(ScreenPtr pScreen, Bool lock)
{
XF86SCRNINFO(pScreen)->zoomLocked = lock;
}
/*
* xf86SwitchMode --
* This is called by both keyboard processing and the VidMode extension to
* set a new mode.
*/
Bool
xf86SwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
{
ScrnInfoPtr pScr = XF86SCRNINFO(pScreen);
ScreenPtr pCursorScreen;
Bool Switched;
int px, py;
DeviceIntPtr dev, it;
if (!pScr->vtSema || !mode || !pScr->SwitchMode)
return FALSE;
#ifdef XFreeXDGA
if (DGAActive(pScr->scrnIndex))
return FALSE;
#endif
if (mode == pScr->currentMode)
return TRUE;
if (mode->HDisplay > pScr->virtualX || mode->VDisplay > pScr->virtualY)
return FALSE;
/* Let's take an educated guess for which pointer to take here. And about as
educated as it gets is to take the first pointer we find.
*/
for (dev = inputInfo.devices; dev; dev = dev->next)
{
if (IsPointerDevice(dev) && dev->spriteInfo->spriteOwner)
break;
}
if (!dev)
dev = inputInfo.pointer;
pCursorScreen = miPointerGetScreen(dev);
if (pScreen == pCursorScreen)
miPointerGetPosition(dev, &px, &py);
xf86EnterServerState(SETUP);
Switched = (*pScr->SwitchMode)(pScr->scrnIndex, mode, 0);
if (Switched) {
pScr->currentMode = mode;
/*
* Adjust frame for new display size.
* Frame is centered around cursor position if cursor is on same screen.
*/
if (pScreen == pCursorScreen)
pScr->frameX0 = px - (mode->HDisplay / 2) + 1;
else
pScr->frameX0 = (pScr->frameX0 + pScr->frameX1 + 1 - mode->HDisplay) / 2;
if (pScr->frameX0 < 0)
pScr->frameX0 = 0;
pScr->frameX1 = pScr->frameX0 + mode->HDisplay - 1;
if (pScr->frameX1 >= pScr->virtualX) {
pScr->frameX0 = pScr->virtualX - mode->HDisplay;
pScr->frameX1 = pScr->virtualX - 1;
}
if (pScreen == pCursorScreen)
pScr->frameY0 = py - (mode->VDisplay / 2) + 1;
else
pScr->frameY0 = (pScr->frameY0 + pScr->frameY1 + 1 - mode->VDisplay) / 2;
if (pScr->frameY0 < 0)
pScr->frameY0 = 0;
pScr->frameY1 = pScr->frameY0 + mode->VDisplay - 1;
if (pScr->frameY1 >= pScr->virtualY) {
pScr->frameY0 = pScr->virtualY - mode->VDisplay;
pScr->frameY1 = pScr->virtualY - 1;
}
}
xf86EnterServerState(OPERATING);
if (pScr->AdjustFrame)
(*pScr->AdjustFrame)(pScr->scrnIndex, pScr->frameX0, pScr->frameY0, 0);
/* The original code centered the frame around the cursor if possible.
* Since this is hard to achieve with multiple cursors, we do the following:
* - center around the first pointer
* - move all other pointers to the nearest edge on the screen (or leave
* them unmodified if they are within the boundaries).
*/
if (pScreen == pCursorScreen)
{
xf86WarpCursor(dev, pScreen, px, py);
}
for (it = inputInfo.devices; it; it = it->next)
{
if (it == dev)
continue;
if (IsPointerDevice(it) && it->spriteInfo->spriteOwner)
{
pCursorScreen = miPointerGetScreen(it);
if (pScreen == pCursorScreen)
{
miPointerGetPosition(it, &px, &py);
if (px < pScr->frameX0)
px = pScr->frameX0;
else if (px > pScr->frameX1)
px = pScr->frameX1;
if(py < pScr->frameY0)
py = pScr->frameY0;
else if(py > pScr->frameY1)
py = pScr->frameY1;
xf86WarpCursor(it, pScreen, px, py);
}
}
}
return Switched;
}
/*
* xf86ZoomViewport --
* Reinitialize the visual part of the screen for another mode.
*/
void
xf86ZoomViewport(ScreenPtr pScreen, int zoom)
{
ScrnInfoPtr pScr = XF86SCRNINFO(pScreen);
DisplayModePtr mode;
if (pScr->zoomLocked || !(mode = pScr->currentMode))
return;
do {
if (zoom > 0)
mode = mode->next;
else
mode = mode->prev;
} while (mode != pScr->currentMode && !(mode->type & M_T_USERDEF));
(void)xf86SwitchMode(pScreen, mode);
}
static xf86EdgePtr
FindEdge(xf86EdgePtr edge, int val)
{
while(edge && (edge->end <= val))
edge = edge->next;
if(edge && (edge->start <= val))
return edge;
return NULL;
}
/*
* xf86CursorOffScreen --
* Check whether it is necessary to switch to another screen
*/
static Bool
xf86CursorOffScreen(ScreenPtr *pScreen, int *x, int *y)
{
xf86EdgePtr edge;
int tmp;
if(screenInfo.numScreens == 1)
return FALSE;
if(*x < 0) {
tmp = *y;
if(tmp < 0) tmp = 0;
if(tmp >= (*pScreen)->height) tmp = (*pScreen)->height - 1;
if((edge = xf86ScreenLayout[(*pScreen)->myNum].left))
edge = FindEdge(edge, tmp);
if(!edge) *x = 0;
else {
*x += edge->offset.x;
*y += edge->offset.y;
*pScreen = xf86Screens[edge->screen]->pScreen;
}
}
if(*x >= (*pScreen)->width) {
tmp = *y;
if(tmp < 0) tmp = 0;
if(tmp >= (*pScreen)->height) tmp = (*pScreen)->height - 1;
if((edge = xf86ScreenLayout[(*pScreen)->myNum].right))
edge = FindEdge(edge, tmp);
if(!edge) *x = (*pScreen)->width - 1;
else {
*x += edge->offset.x;
*y += edge->offset.y;
*pScreen = xf86Screens[edge->screen]->pScreen;
}
}
if(*y < 0) {
tmp = *x;
if(tmp < 0) tmp = 0;
if(tmp >= (*pScreen)->width) tmp = (*pScreen)->width - 1;
if((edge = xf86ScreenLayout[(*pScreen)->myNum].up))
edge = FindEdge(edge, tmp);
if(!edge) *y = 0;
else {
*x += edge->offset.x;
*y += edge->offset.y;
*pScreen = xf86Screens[edge->screen]->pScreen;
}
}
if(*y >= (*pScreen)->height) {
tmp = *x;
if(tmp < 0) tmp = 0;
if(tmp >= (*pScreen)->width) tmp = (*pScreen)->width - 1;
if((edge = xf86ScreenLayout[(*pScreen)->myNum].down))
edge = FindEdge(edge, tmp);
if(!edge) *y = (*pScreen)->height - 1;
else {
*x += edge->offset.x;
*y += edge->offset.y;
(*pScreen) = xf86Screens[edge->screen]->pScreen;
}
}
#if 0
/* This presents problems for overlapping screens when
HardEdges is used. Have to think about the logic more */
if((*x < 0) || (*x >= (*pScreen)->width) ||
(*y < 0) || (*y >= (*pScreen)->height)) {
/* We may have crossed more than one screen */
xf86CursorOffScreen(pScreen, x, y);
}
#endif
return TRUE;
}
/*
* xf86CrossScreen --
* Switch to another screen
*
* Currently nothing special happens, but mi assumes the CrossScreen
* method exists.
*/
static void
xf86CrossScreen (ScreenPtr pScreen, Bool entering)
{
}
/*
* xf86WarpCursor --
* Warp possible to another screen
*/
/* ARGSUSED */
static void
xf86WarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{
int sigstate;
sigstate = xf86BlockSIGIO ();
miPointerWarpCursor(pDev, pScreen, x, y);
xf86Info.currentScreen = pScreen;
xf86UnblockSIGIO (sigstate);
}
_X_EXPORT void *
xf86GetPointerScreenFuncs(void)
{
return (void *)&xf86PointerScreenFuncs;
}
static xf86EdgePtr
AddEdge(
xf86EdgePtr edge,
short min,
short max,
short dx,
short dy,
short screen
){
xf86EdgePtr pEdge = edge, pPrev = NULL, pNew;
while(1) {
while(pEdge && (min >= pEdge->end)) {
pPrev = pEdge;
pEdge = pEdge->next;
}
if(!pEdge) {
if(!(pNew = xalloc(sizeof(xf86EdgeRec))))
break;
pNew->screen = screen;
pNew->start = min;
pNew->end = max;
pNew->offset.x = dx;
pNew->offset.y = dy;
pNew->next = NULL;
if(pPrev)
pPrev->next = pNew;
else
edge = pNew;
break;
} else if (min < pEdge->start) {
if(!(pNew = xalloc(sizeof(xf86EdgeRec))))
break;
pNew->screen = screen;
pNew->start = min;
pNew->offset.x = dx;
pNew->offset.y = dy;
pNew->next = pEdge;
if(pPrev) pPrev->next = pNew;
else edge = pNew;
if(max <= pEdge->start) {
pNew->end = max;
break;
} else {
pNew->end = pEdge->start;
min = pEdge->end;
}
} else
min = pEdge->end;
pPrev = pEdge;
pEdge = pEdge->next;
if(max <= min) break;
}
return edge;
}
static void
FillOutEdge(xf86EdgePtr pEdge, int limit)
{
xf86EdgePtr pNext;
int diff;
if(pEdge->start > 0) pEdge->start = 0;
while((pNext = pEdge->next)) {
diff = pNext->start - pEdge->end;
if(diff > 0) {
pEdge->end += diff >> 1;
pNext->start -= diff - (diff >> 1);
}
pEdge = pNext;
}
if(pEdge->end < limit)
pEdge->end = limit;
}
/*
* xf86InitOrigins() can deal with a maximum of 32 screens
* on 32 bit architectures, 64 on 64 bit architectures.
*/
void
xf86InitOrigins(void)
{
unsigned long screensLeft, prevScreensLeft, mask;
screenLayoutPtr screen;
ScreenPtr pScreen;
int x1, x2, y1, y2, left, right, top, bottom;
int i, j, ref, minX, minY, min, max;
xf86ScreenLayoutPtr pLayout;
Bool OldStyleConfig = FALSE;
/* need to have this set up with a config file option */
HardEdges = FALSE;
bzero(xf86ScreenLayout, MAXSCREENS * sizeof(xf86ScreenLayoutRec));
screensLeft = prevScreensLeft = (1 << xf86NumScreens) - 1;
while(1) {
for(mask = screensLeft, i = 0; mask; mask >>= 1, i++) {
if(!(mask & 1L)) continue;
screen = &xf86ConfigLayout.screens[i];
if (screen->refscreen != NULL &&
screen->refscreen->screennum >= xf86NumScreens) {
screensLeft &= ~(1 << i);
xf86Msg(X_WARNING, "Not including screen \"%s\" in origins calculation.\n",
screen->screen->id);
continue;
}
switch(screen->where) {
case PosObsolete:
OldStyleConfig = TRUE;
pLayout = &xf86ScreenLayout[i];
/* force edge lists */
if(screen->left) {
ref = screen->left->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pLayout->left = AddEdge(pLayout->left,
0, xf86Screens[i]->pScreen->height,
xf86Screens[ref]->pScreen->width, 0, ref);
}
if(screen->right) {
ref = screen->right->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pScreen = xf86Screens[i]->pScreen;
pLayout->right = AddEdge(pLayout->right,
0, pScreen->height, -pScreen->width, 0, ref);
}
if(screen->top) {
ref = screen->top->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pLayout->up = AddEdge(pLayout->up,
0, xf86Screens[i]->pScreen->width,
0, xf86Screens[ref]->pScreen->height, ref);
}
if(screen->bottom) {
ref = screen->bottom->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pScreen = xf86Screens[i]->pScreen;
pLayout->down = AddEdge(pLayout->down,
0, pScreen->width, 0, -pScreen->height, ref);
}
/* we could also try to place it based on those
relative locations if we wanted to */
screen->x = screen->y = 0;
/* FALLTHROUGH */
case PosAbsolute:
dixScreenOrigins[i].x = screen->x;
dixScreenOrigins[i].y = screen->y;
screensLeft &= ~(1 << i);
break;
case PosRelative:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x + screen->x;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y + screen->y;
screensLeft &= ~(1 << i);
break;
case PosRightOf:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[ref]->pScreen;
dixScreenOrigins[i].x =
dixScreenOrigins[ref].x + pScreen->width;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y;
screensLeft &= ~(1 << i);
break;
case PosLeftOf:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[i]->pScreen;
dixScreenOrigins[i].x =
dixScreenOrigins[ref].x - pScreen->width;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y;
screensLeft &= ~(1 << i);
break;
case PosBelow:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[ref]->pScreen;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
dixScreenOrigins[i].y =
dixScreenOrigins[ref].y + pScreen->height;
screensLeft &= ~(1 << i);
break;
case PosAbove:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[i]->pScreen;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
dixScreenOrigins[i].y =
dixScreenOrigins[ref].y - pScreen->height;
screensLeft &= ~(1 << i);
break;
default:
ErrorF("Illegal placement keyword in Layout!\n");
break;
}
}
if(!screensLeft) break;
if(screensLeft == prevScreensLeft) {
/* All the remaining screens are referencing each other.
Assign a value to one of them and go through again */
i = 0;
while(!((1 << i) & screensLeft)){ i++; }
ref = xf86ConfigLayout.screens[i].refscreen->screennum;
dixScreenOrigins[ref].x = dixScreenOrigins[ref].y = 0;
screensLeft &= ~(1 << ref);
}
prevScreensLeft = screensLeft;
}
/* justify the topmost and leftmost to (0,0) */
minX = dixScreenOrigins[0].x;
minY = dixScreenOrigins[0].y;
for(i = 1; i < xf86NumScreens; i++) {
if(dixScreenOrigins[i].x < minX)
minX = dixScreenOrigins[i].x;
if(dixScreenOrigins[i].y < minY)
minY = dixScreenOrigins[i].y;
}
if (minX || minY) {
for(i = 0; i < xf86NumScreens; i++) {
dixScreenOrigins[i].x -= minX;
dixScreenOrigins[i].y -= minY;
}
}
/* Create the edge lists */
if(!OldStyleConfig) {
for(i = 0; i < xf86NumScreens; i++) {
pLayout = &xf86ScreenLayout[i];
pScreen = xf86Screens[i]->pScreen;
left = dixScreenOrigins[i].x;
right = left + pScreen->width;
top = dixScreenOrigins[i].y;
bottom = top + pScreen->height;
for(j = 0; j < xf86NumScreens; j++) {
if(i == j) continue;
x1 = dixScreenOrigins[j].x;
x2 = x1 + xf86Screens[j]->pScreen->width;
y1 = dixScreenOrigins[j].y;
y2 = y1 + xf86Screens[j]->pScreen->height;
if((bottom > y1) && (top < y2)) {
min = y1 - top;
if(min < 0) min = 0;
max = pScreen->height - (bottom - y2);
if(max > pScreen->height) max = pScreen->height;
if(((left - 1) >= x1) && ((left - 1) < x2))
pLayout->left = AddEdge(pLayout->left, min, max,
dixScreenOrigins[i].x - dixScreenOrigins[j].x,
dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);
if((right >= x1) && (right < x2))
pLayout->right = AddEdge(pLayout->right, min, max,
dixScreenOrigins[i].x - dixScreenOrigins[j].x,
dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);
}
if((left < x2) && (right > x1)) {
min = x1 - left;
if(min < 0) min = 0;
max = pScreen->width - (right - x2);
if(max > pScreen->width) max = pScreen->width;
if(((top - 1) >= y1) && ((top - 1) < y2))
pLayout->up = AddEdge(pLayout->up, min, max,
dixScreenOrigins[i].x - dixScreenOrigins[j].x,
dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);
if((bottom >= y1) && (bottom < y2))
pLayout->down = AddEdge(pLayout->down, min, max,
dixScreenOrigins[i].x - dixScreenOrigins[j].x,
dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);
}
}
}
}
if(!HardEdges && !OldStyleConfig) {
for(i = 0; i < xf86NumScreens; i++) {
pLayout = &xf86ScreenLayout[i];
pScreen = xf86Screens[i]->pScreen;
if(pLayout->left)
FillOutEdge(pLayout->left, pScreen->height);
if(pLayout->right)
FillOutEdge(pLayout->right, pScreen->height);
if(pLayout->up)
FillOutEdge(pLayout->up, pScreen->width);
if(pLayout->down)
FillOutEdge(pLayout->down, pScreen->width);
}
}
}
void
xf86ReconfigureLayout(void)
{
int i;
for (i = 0; i < MAXSCREENS; i++) {
xf86ScreenLayoutPtr sl = &xf86ScreenLayout[i];
/* we don't have to zero these, xf86InitOrigins() takes care of that */
if (sl->left) xfree(sl->left);
if (sl->right) xfree(sl->right);
if (sl->up) xfree(sl->up);
if (sl->down) xfree(sl->down);
}
xf86InitOrigins();
}
Reference in New Issue View Git Blame Copy Permalink