frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xserver/hw/xfree86/utils/xorgcfg/screen.c

985 lines
30 KiB
C
Raw Blame History

/*
* Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)
*
* 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
* CONECTIVA LINUX 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 Conectiva Linux shall
* not be used in advertising or otherwise to promote the sale, use or other
* dealings in this Software without prior written authorization from
* Conectiva Linux.
*
* Author: Paulo César Pereira de Andrade <pcpa@conectiva.com.br>
*
* $XFree86: xc/programs/Xserver/hw/xfree86/xf86cfg/screen.c,v 1.9 2002/06/06 21:03:32 paulo Exp $
*/
#include <X11/IntrinsicP.h>
#include <X11/extensions/shape.h>
#include <X11/Xaw/Simple.h>
#include "screen.h"
#define CW 1
#define CCW -1
/*
* Prototypes
*/
void ReshapeScreenWidget(xf86cfgScreen*);
static int qcmp_screen(_Xconst void*, _Xconst void*);
/*
* Initialization
*/
extern Widget work;
static int rows, columns; /* number of rows/columns of monitors */
static int mon_width, mon_height;
static int *mon_widths, *mon_heights;
/*
* Implementation
*/
void
SetScreenRotate(xf86cfgScreen *screen)
{
static char *Rotate = "Rotate", *_CW = "CW", *_CCW = "CCW";
int rotate = 0;
XF86OptionPtr option, options;
/* This is the only place where xf86cfg is intrusive, and deletes options
* added by the user directly in the config file. The "Rotate" option
* will be kept in the screen section.
*/
if (screen->monitor != NULL) {
options = ((XF86ConfMonitorPtr)(screen->monitor->config))->mon_option_lst;
if ((option = xf86findOption(options, Rotate)) != NULL) {
if (option->opt_val != NULL)
rotate = strcasecmp(option->opt_val, _CW) == 0 ? CW :
strcasecmp(option->opt_val, _CCW) == 0 ? CCW : 0;
xf86removeOption(&((XF86ConfMonitorPtr)(screen->monitor->config))
->mon_option_lst, Rotate);
}
}
if (screen->card != NULL) {
options = ((XF86ConfDevicePtr)(screen->card->config))->dev_option_lst;
if ((option = xf86findOption(options, Rotate)) != NULL) {
if (option->opt_val != NULL)
rotate += strcasecmp(option->opt_val, _CW) == 0 ? CW :
strcasecmp(option->opt_val, _CCW) == 0 ? CCW : 0;
xf86removeOption(&((XF86ConfDevicePtr)(screen->card->config))
->dev_option_lst, Rotate);
}
}
options = screen->screen->scrn_option_lst;
if ((option = xf86findOption(options, Rotate)) != NULL) {
if (option->opt_val != NULL)
rotate += strcasecmp(option->opt_val, _CW) == 0 ? CW :
strcasecmp(option->opt_val, _CCW) == 0 ? CCW : 0;
xf86removeOption(&screen->screen->scrn_option_lst, Rotate);
}
rotate = rotate > 0 ? CW : rotate < 0 ? CCW : 0;
if (rotate)
screen->screen->scrn_option_lst =
xf86addNewOption(screen->screen->scrn_option_lst,
XtNewString(Rotate),
XtNewString(rotate > 0 ? _CW : _CCW));
screen->rotate = rotate;
}
void
CreateScreenWidget(xf86cfgScreen *screen)
{
Widget w = XtCreateWidget("screen", simpleWidgetClass,
XtParent(computer.cpu), NULL, 0);
SetScreenRotate(screen);
XtRealizeWidget(w);
screen->widget = w;
screen->column = screen->row = -1;
ReshapeScreenWidget(screen);
}
void
ReshapeScreenWidget(xf86cfgScreen *screen)
{
Pixmap pixmap;
XGCValues values;
GC gc;
int x = 0, y = 0, width = screen->rect.width, height = screen->rect.height;
Widget w = screen->widget;
if (screen->state == USED && screen->row >= 0) {
if (screen->column == 0)
x = w->core.width - width;
else if (screen->column == columns - 1)
x = w->core.width - mon_widths[screen->column];
else
x = (w->core.width - mon_widths[screen->column]) +
((mon_widths[screen->column] - width) >> 1);
if (screen->row == 0)
y = w->core.height - height;
else if (screen->row == rows - 1)
y = w->core.height - mon_heights[screen->row];
else
y = (w->core.height - mon_heights[screen->row]) +
((mon_heights[screen->row] - height) >> 1);
}
else if (screen->rect.width == 0) {
width = w->core.width;
height = w->core.height;
}
screen->rect.x = x;
screen->rect.y = y;
screen->rect.width = width;
screen->rect.height = height;
pixmap = XCreatePixmap(XtDisplay(w), XtWindow(w),
w->core.width, w->core.height, 1);
values.foreground = 0;
values.background = 1;
gc = XCreateGC(XtDisplay(w), pixmap, GCForeground | GCBackground, &values);
XFillRectangle(XtDisplay(w), pixmap, gc, 0, 0, w->core.width, w->core.height);
XSetForeground(XtDisplay(w), gc, 1);
DrawScreenMask(XtDisplay(w), pixmap, gc, x, y, x + width, y + height,
screen->rotate);
XShapeCombineMask(XtDisplay(w), XtWindow(w), ShapeBounding,
0, 0, pixmap, ShapeSet);
/* Do not call XtSetValues, to avoid all extra code for caching pixmaps */
XFreePixmap(XtDisplay(w), pixmap);
if (XtIsRealized(w)) {
pixmap = XCreatePixmap(XtDisplay(w), XtWindow(w),
w->core.width, w->core.height,
DefaultDepthOfScreen(XtScreen(w)));
DrawScreen(XtDisplay(w), pixmap, x, y, x + width, y + height,
screen->state == USED ? True : False, screen->rotate);
XSetWindowBackgroundPixmap(XtDisplay(w), XtWindow(w), pixmap);
XClearWindow(XtDisplay(w), XtWindow(w));
XFreePixmap(XtDisplay(w), pixmap);
}
XFreeGC(XtDisplay(w), gc);
}
void
AddScreen(xf86cfgDevice *mon, xf86cfgDevice *dev)
{
int nscreens = 0;
char screen_name[48];
XF86ConfScreenPtr screen = XF86Config->conf_screen_lst;
XF86ConfAdjacencyPtr adj;
while (screen != NULL) {
++nscreens;
screen = (XF86ConfScreenPtr)(screen->list.next);
}
do {
XmuSnprintf(screen_name, sizeof(screen_name), "Screen%d",
nscreens);
++nscreens;
} while (xf86findScreen(screen_name,
XF86Config->conf_screen_lst) != NULL);
screen = (XF86ConfScreenPtr)XtCalloc(1, sizeof(XF86ConfScreenRec));
screen->scrn_identifier = XtNewString(screen_name);
screen->scrn_device_str = XtNewString(((XF86ConfDevicePtr)(dev->config))->dev_identifier);
screen->scrn_device = (XF86ConfDevicePtr)(dev->config);
screen->scrn_monitor_str = XtNewString(((XF86ConfMonitorPtr)(mon->config))->mon_identifier);
screen->scrn_monitor = (XF86ConfMonitorPtr)(mon->config);
XF86Config->conf_screen_lst =
xf86addScreen(XF86Config->conf_screen_lst, screen);
adj = (XF86ConfAdjacencyPtr)XtCalloc(1, sizeof(XF86ConfAdjacencyRec));
adj->adj_screen = screen;
adj->adj_screen_str = XtNewString(screen_name);
if (computer.layout == NULL)
computer.layout = XF86Config->conf_layout_lst = (XF86ConfLayoutPtr)
XtCalloc(1, sizeof(XF86ConfLayoutRec));
computer.layout->lay_adjacency_lst = (XF86ConfAdjacencyPtr)
xf86addListItem((GenericListPtr)computer.layout->lay_adjacency_lst,
(GenericListPtr)adj);
computer.screens = (xf86cfgScreen**)
XtRealloc((XtPointer)computer.screens, sizeof(xf86cfgScreen*) *
(computer.num_screens + 1));
computer.screens[computer.num_screens] =
(xf86cfgScreen*)XtCalloc(1, sizeof(xf86cfgScreen));
computer.screens[computer.num_screens]->screen = screen;
computer.screens[computer.num_screens]->card = dev;
computer.screens[computer.num_screens]->monitor = mon;
++dev->refcount;
++mon->refcount;
CreateScreenWidget(computer.screens[computer.num_screens]);
computer.screens[computer.num_screens]->type = SCREEN;
SetTip((xf86cfgDevice*)computer.screens[computer.num_screens]);
++computer.num_screens;
}
void
RemoveScreen(xf86cfgDevice *mon, xf86cfgDevice *dev)
{
XF86ConfScreenPtr screen = XF86Config->conf_screen_lst;
int i;
mon->state = dev->state = UNUSED;
while (screen != NULL) {
if ((XtPointer)screen->scrn_monitor == mon->config &&
(XtPointer)screen->scrn_device == dev->config)
break;
screen = (XF86ConfScreenPtr)(screen->list.next);
}
--mon->refcount;
--dev->refcount;
for (i = 0; i < computer.num_screens; i++) {
if (computer.screens[i]->screen == screen) {
XtDestroyWidget(computer.screens[i]->widget);
if (i < --computer.num_screens)
memmove(&computer.screens[i], &computer.screens[i + 1],
(computer.num_screens - i) * sizeof(xf86cfgScreen*));
break;
}
}
xf86removeScreen(XF86Config, screen);
}
void
ChangeScreen(XF86ConfMonitorPtr mon, XF86ConfMonitorPtr oldmon,
XF86ConfDevicePtr dev, XF86ConfDevicePtr olddev)
{
int ioldm, im, ioldc, ic;
if (mon == oldmon && dev == olddev)
return;
if (mon != NULL) {
for (im = 0; im < computer.num_devices; im++)
if (computer.devices[im]->config == (XtPointer)mon)
break;
}
else
im = -1;
if (oldmon != NULL) {
for (ioldm = 0; ioldm < computer.num_devices; ioldm++)
if (computer.devices[ioldm]->config == (XtPointer)oldmon)
break;
}
else
ioldm = -1;
if (dev != NULL) {
for (ic = 0; ic < computer.num_devices; ic++)
if (computer.devices[ic]->config == (XtPointer)dev)
break;
}
else
ic = -1;
if (olddev != NULL) {
for (ioldc = 0; ioldc < computer.num_devices; ioldc++)
if (computer.devices[ioldc]->config == (XtPointer)olddev)
break;
}
else
ioldc = -1;
if (ioldm >= 0 && ioldc >= 0) {
RemoveScreen(computer.devices[ioldm], computer.devices[ioldc]);
computer.devices[ioldm]->state = UNUSED;
/* computer.devices[ioldc]->state = UNUSED;*/
}
if (im >= 0 && ic >= 0) {
AddScreen(computer.devices[im], computer.devices[ic]);
computer.devices[im]->state = USED;
/* computer.devices[ic]->state = USED;*/
}
}
/*
+------------------------------------------------+
| |
| +------------------------------------------+ |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| +------------------------------------------+ |
| |
+------------------------------------------------+
| |
+-------+ +-------+
| |
+----------------------------------------+
*/
static double oxs = 0.0, oys = 0.0, oxe = 100.0, oye = 70.0;
static double ixs = 7.0, iys = 7.0, ixe = 93.0, iye = 63.0;
static double lin[] = { 25.0, 70.0, 25.0, 75.0, 5.0, 75.0, 5.0, 80.0,
95.0, 80.0, 95.0, 75.0, 75.0, 75.0, 75.0, 70.0 };
void
DrawScreen(Display *dpy, Drawable win, int xs, int ys, int xe, int ye,
Bool active, int rotate)
{
double xfact, yfact;
XPoint points[(sizeof(lin) / sizeof(lin[0])) >> 1];
int i;
static GC gray0, gray1, gray2, black, red;
if (black == NULL) {
XColor color, exact;
XGCValues values;
XAllocNamedColor(XtDisplay(toplevel), toplevel->core.colormap, "gray95",
&color, &exact);
values.foreground = color.pixel;
gray0 = XCreateGC(XtDisplay(toplevel), win, GCForeground, &values);
XAllocNamedColor(XtDisplay(toplevel), toplevel->core.colormap, "gray75",
&color, &exact);
values.foreground = color.pixel;
gray1 = XCreateGC(XtDisplay(toplevel), win, GCForeground, &values);
XAllocNamedColor(XtDisplay(toplevel), toplevel->core.colormap, "gray60",
&color, &exact);
values.foreground = color.pixel;
gray2 = XCreateGC(XtDisplay(toplevel), win, GCForeground, &values);
XAllocNamedColor(XtDisplay(toplevel), toplevel->core.colormap, "gray20",
&color, &exact);
values.foreground = color.pixel;
black = XCreateGC(XtDisplay(toplevel), win, GCForeground, &values);
XAllocNamedColor(XtDisplay(toplevel), toplevel->core.colormap, "red",
&color, &exact);
values.foreground = color.pixel;
values.line_width = 4;
values.cap_style = CapButt;
red = XCreateGC(XtDisplay(toplevel), win,
GCForeground | GCLineWidth | GCCapStyle, &values);
}
if (rotate) {
xfact = (xe - xs) / 80.0;
yfact = (ye - ys) / 100.0;
if (rotate == CW) {
/* outer rectangle */
XFillRectangle(dpy, win, gray1,
oxs * xfact + xs + .5,
oys * yfact + ys + .5,
(oye - oys) * xfact + .5,
(oxe - oxs) * yfact + .5);
XDrawLine(dpy, win, gray2,
xs, ye - 1,
70 * xfact + xs - 1 + .5, ye - 1);
XDrawLine(dpy, win, gray2,
70 * xfact + xs - 1 + .5, ye - 1,
70 * xfact + xs - 1 + .5, ys);
/* inner rectangle */
XFillRectangle(dpy, win, black,
ixs * xfact + xs + .5,
iys * yfact + ys + .5,
(iye - iys) * xfact + .5,
(ixe - ixs) * yfact + .5);
for (i = 0; i < sizeof(points) / sizeof(points[0]); i++) {
points[i].x = lin[(i<<1) + 1] * xfact + xs + .5;
points[i].y = lin[(i<<1)] * yfact + ys + .5;
}
XFillPolygon(dpy, win, gray2, points, i, Convex, CoordModeOrigin);
XDrawLine(dpy, win, gray0,
(oxe - 10) * xfact + xs + .5, oys * yfact + ys + .5,
xs, oys * yfact + ys + .5);
XDrawLine(dpy, win, gray0,
xs, ys,
xs, xe);
XDrawLine(dpy, win, black,
lin[7] * xfact + xs - 1 + .5, lin[6] * yfact + ys + .5,
lin[9] * xfact + xs - 1 + .5, lin[8] * yfact + ys - 1 + .5);
XDrawLine(dpy, win, black,
lin[9] * xfact + xs - 1 + .5, lin[8] * yfact + ys - 1 + .5,
lin[11] * xfact + xs + .5, lin[10] * yfact + ys - 1 + .5);
XDrawLine(dpy, win, black,
lin[13] * xfact + xs + .5, lin[12] * yfact + ys - 1 + .5,
lin[15] * xfact + xs + .5, lin[14] * yfact + ys - 1 + .5);
if (!active) {
XDrawLine(dpy, win, red,
iys * xfact, ixs * yfact, iye * xfact, ixe * yfact);
XDrawLine(dpy, win, red,
iye * xfact, ixs * yfact, iys * xfact, ixe * yfact);
}
}
else if (rotate == CCW) {
/* outer rectangle */
XFillRectangle(dpy, win, gray1,
10 * xfact + xs + .5,
oys * yfact + ys + .5,
(oye - oys) * xfact + .5,
(oxe - oxs) * yfact + .5);
XDrawLine(dpy, win, gray2,
10 * xfact + xs + .5, ye - 1,
oxe * xfact + xs - 1 + .5, ye - 1);
XDrawLine(dpy, win, gray2,
xe - 1, ye - 1,
xe - 1, ys);
/* inner rectangle */
XFillRectangle(dpy, win, black,
(ixs + 10) * xfact + xs + .5,
iys * yfact + ys + .5,
(iye - iys) * xfact + .5,
(ixe - ixs) * yfact + .5);
for (i = 0; i < sizeof(points) / sizeof(points[0]); i++) {
points[i].x = (-lin[(i<<1) + 1] + 80.0) * xfact + xs + .5;
points[i].y = lin[(i<<1)] * yfact + ys + .5;
}
XFillPolygon(dpy, win, gray2, points, i, Convex, CoordModeOrigin);
XDrawLine(dpy, win, gray0,
oxe * xfact + xs + .5, oys * yfact + ys + .5,
(oxs - 10) * xfact + xs + .5, oys * yfact + ys + .5);
XDrawLine(dpy, win, gray0,
(oxs + 10) * xfact + xs + .5, ys,
(oxs + 10) * xfact + xs + .5, xe);
XDrawLine(dpy, win, black,
xs, lin[8] * yfact - 1 + ys + .5,
4 * xfact + xs + .5, lin[8] * yfact - 1 + ys + .5);
XDrawLine(dpy, win, black,
4 * xfact + xs, lin[8] * yfact - 1 + ys + .5,
4 * xfact + xs, lin[3] * yfact - 1 + ys + .5);
XDrawLine(dpy, win, black,
4 * xfact + xs + .5, lin[3] * yfact - 1 + ys + .5,
10 * xfact + xs + .5 - 1, lin[3] * yfact - 1 + ys + .5);
XDrawLine(dpy, win, black,
4 * xfact + xs, lin[0] * yfact - 1 + ys + .5,
4 * xfact + xs, lin[4] * yfact - 1 + ys + .5);
if (!active) {
XDrawLine(dpy, win, red,
(iys + 10) * xfact, ixs * yfact,
(iye + 10) * xfact, ixe * yfact);
XDrawLine(dpy, win, red,
(iye + 10) * xfact, ixs * yfact,
(iys + 10) * xfact, ixe * yfact);
}
}
}
else {
xfact = (xe - xs) / 100.0;
yfact = (ye - ys) / 80.0;
/* outer rectangle */
XFillRectangle(dpy, win, gray1,
oxs * xfact + xs + .5,
oys * yfact + ys + .5,
(oxe - oxs) * xfact + .5,
(oye - oys) * yfact + .5);
XDrawLine(dpy, win, gray2,
oxs * xfact + xs + .5, oye * yfact + ys - 1 + .5,
oxe * xfact + xs - 1 + .5, oye * yfact + ys - 1 + .5);
XDrawLine(dpy, win, gray2,
oxe * xfact + xs - 1 + .5, oys * yfact + ys + .5,
oxe * xfact + xs - 1 + .5, oye * yfact + ys - 1 + .5);
/* inner rectangle */
XFillRectangle(dpy, win, black,
ixs * xfact + xs + .5,
iys * yfact + ys + .5,
(ixe - ixs) * xfact + .5,
(iye - iys) * yfact + .5);
for (i = 0; i < sizeof(points) / sizeof(points[0]); i++) {
points[i].x = lin[i<<1] * xfact + xs + .5;
points[i].y = lin[(i<<1) + 1] * yfact + ys + .5;
}
XFillPolygon(dpy, win, gray2, points, i, Convex, CoordModeOrigin);
XDrawLine(dpy, win, black,
lin[6] * xfact + xs + .5, lin[7] * yfact + ys - 1 + .5,
lin[8] * xfact + xs - 1 + .5, lin[9] * yfact + ys - 1 + .5);
XDrawLine(dpy, win, black,
lin[8] * xfact + xs - 1 + .5, lin[9] * yfact + ys - 1 + .5,
lin[10] * xfact + xs - 1 + .5, lin[11] * yfact + ys + .5);
XDrawLine(dpy, win, black,
lin[12] * xfact + xs - 1 + .5, lin[13] * yfact + ys + .5,
lin[14] * xfact + xs - 1 + .5, lin[15] * yfact + ys + .5);
XDrawLine(dpy, win, gray0,
oxe * xfact + xs + .5, oys * yfact + ys + .5,
oxs * xfact + xs + .5, oys * yfact + ys + .5);
XDrawLine(dpy, win, gray0,
oxs * xfact + xs + .5, oys * yfact + ys + .5,
oxs * xfact + xs + .5, lin[1] * yfact + ys + .5);
if (!active) {
XDrawLine(dpy, win, red,
ixs * xfact, iys * yfact, ixe * xfact, iye * yfact);
XDrawLine(dpy, win, red,
ixe * xfact, iys * yfact, ixs * xfact, iye * yfact);
}
}
}
void
DrawScreenMask(Display *dpy, Drawable win, GC gc, int xs, int ys, int xe, int ye,
int rotate)
{
double xfact, yfact;
XPoint points[(sizeof(lin) / sizeof(lin[0])) >> 1];
int i = 0, x = 0, y = 0, width, height;
if (rotate) {
xfact = (xe - xs) / 80.0;
yfact = (ye - ys) / 100.0;
width = (oye - oys) * xfact + .5;
height = (oxe - oxs) * yfact + .5;
if (rotate == CW) {
x = oxs * xfact + xs + .5;
y = oys * yfact + ys + .5;
for (i = 0; i < sizeof(points) / sizeof(points[0]); i++) {
points[i].x = lin[(i<<1) + 1] * xfact + xs + .5;
points[i].y = lin[(i<<1)] * yfact + ys + .5;
}
}
else if (rotate == CCW) {
x = 10 * xfact + xs + .5;
y = oys * yfact + ys + .5;
for (i = 0; i < sizeof(points) / sizeof(points[0]); i++) {
points[i].x = (-lin[(i<<1) + 1] + 80.0) * xfact + xs + .5;
points[i].y = lin[(i<<1)] * yfact + ys + .5;
}
}
}
else {
xfact = (xe - xs) / 100.0;
yfact = (ye - ys) / 80.0;
x = oxs * xfact + xs + .5;
y = oys * yfact + ys + .5;
width = (oxe - oxs) * xfact + .5;
height = (oye - oys) * yfact + .5;
for (i = 0; i < sizeof(points) / sizeof(points[0]); i++) {
points[i].x = lin[(i<<1)] * xfact + xs + .5;
points[i].y = lin[(i<<1) + 1] * yfact + ys + .5;
}
}
/* rectangle */
XFillRectangle(dpy, win, gc, x, y, width, height);
XFillPolygon(dpy, win, gc, points, i, Convex, CoordModeOrigin);
}
void
AdjustScreenUI(void)
{
XF86ConfLayoutPtr lay = computer.layout;
XF86ConfAdjacencyPtr adj;
int i, dx, dy, x, y, w, h, base = -1;
double xf, yf;
if (lay == NULL)
return;
adj = lay->lay_adjacency_lst;
#define USED1 -USED
XtFree((XtPointer)mon_widths);
XtFree((XtPointer)mon_heights);
mon_widths = (int*)XtCalloc(1, sizeof(int) * columns);
mon_heights = (int*)XtCalloc(1, sizeof(int) * rows);
mon_width = mon_height = 0;
for (i = 0; i < computer.num_screens; i++) {
if (base == -1 && computer.screens[i]->state == USED)
base = i;
if (computer.screens[i]->screen->scrn_monitor->mon_width > mon_width)
mon_width = computer.screens[i]->screen->scrn_monitor->mon_width;
if (computer.screens[i]->screen->scrn_monitor->mon_height > mon_height)
mon_height = computer.screens[i]->screen->scrn_monitor->mon_height;
}
if (base < 0) {
for (i = 0; i < computer.num_screens; i++)
ReshapeScreenWidget(computer.screens[i]);
return;
}
if (mon_width == 0) {
mon_width = 10;
mon_height = 8;
}
XtUnmapWidget(work);
while (adj) {
xf86cfgScreen *scr = NULL,
*topscr = NULL, *botscr = NULL, *lefscr = NULL, *rigscr = NULL;
for (i = 0; i < computer.num_screens; i++)
if (computer.screens[i]->screen == adj->adj_screen)
break;
if (i < computer.num_screens)
scr = computer.screens[i];
if (adj->adj_top != NULL) {
for (i = 0; i < computer.num_screens; i++)
if (computer.screens[i]->screen == adj->adj_top)
break;
if (i < computer.num_screens)
topscr = computer.screens[i];
}
if (adj->adj_bottom != NULL) {
for (i = 0; i < computer.num_screens; i++)
if (computer.screens[i]->screen == adj->adj_bottom)
break;
if (i < computer.num_screens)
botscr = computer.screens[i];
}
if (adj->adj_left != NULL) {
for (i = 0; i < computer.num_screens; i++)
if (computer.screens[i]->screen == adj->adj_left)
break;
if (i < computer.num_screens)
lefscr = computer.screens[i];
}
if (adj->adj_right != NULL) {
for (i = 0; i < computer.num_screens; i++)
if (computer.screens[i]->screen == adj->adj_right)
break;
if (i < computer.num_screens)
rigscr = computer.screens[i];
}
if (lefscr == NULL && rigscr == NULL && topscr == NULL && lefscr == NULL) {
XF86ConfScreenPtr s;
if (adj->adj_where >= CONF_ADJ_RIGHTOF < adj->adj_where <= CONF_ADJ_BELOW) {
s = xf86findScreen(adj->adj_refscreen, XF86Config->conf_screen_lst);
for (i = 0; i < computer.num_screens; i++)
if (computer.screens[i]->screen == s)
break;
if (i < computer.num_screens) {
switch (adj->adj_where) {
case CONF_ADJ_RIGHTOF:
lefscr = computer.screens[i];
break;
case CONF_ADJ_LEFTOF:
rigscr = computer.screens[i];
break;
case CONF_ADJ_ABOVE:
botscr = computer.screens[i];
break;
case CONF_ADJ_BELOW:
topscr = computer.screens[i];
break;
}
}
}
}
XtMoveWidget(scr->widget, 0, 0);
scr->state = USED1;
if (lefscr != NULL) {
if (lefscr->state == USED1)
XtMoveWidget(scr->widget,
lefscr->widget->core.x + lefscr->widget->core.width,
lefscr->widget->core.y);
else
XtMoveWidget(lefscr->widget,
-(int)(lefscr->widget->core.width),
scr->widget->core.y);
}
if (rigscr != NULL) {
if (rigscr->state == USED1) {
dx = rigscr->widget->core.x - scr->widget->core.width - scr->widget->core.x;
dy = rigscr->widget->core.y - scr->widget->core.y;
XtMoveWidget(scr->widget, scr->widget->core.x + dx,
scr->widget->core.y + dy);
if (lefscr != NULL && lefscr->state != USED1)
XtMoveWidget(lefscr->widget, lefscr->widget->core.x + dx,
lefscr->widget->core.y + dy);
}
else
XtMoveWidget(rigscr->widget, scr->widget->core.width,
scr->widget->core.y);
}
if (topscr != NULL) {
if (topscr->state == USED1) {
dx = topscr->widget->core.x - scr->widget->core.x;
dy = topscr->widget->core.y + topscr->widget->core.height -
scr->widget->core.y;
XtMoveWidget(scr->widget, scr->widget->core.x + dx,
scr->widget->core.y + dy);
if (lefscr != NULL && lefscr->state != USED1)
XtMoveWidget(lefscr->widget, lefscr->widget->core.x + dx,
lefscr->widget->core.y + dy);
if (rigscr != NULL && rigscr->state != USED1)
XtMoveWidget(rigscr->widget, rigscr->widget->core.x + dx,
rigscr->widget->core.y + dy);
}
else
XtMoveWidget(topscr->widget, scr->widget->core.x,
scr->widget->core.y - topscr->widget->core.height);
}
if (botscr != NULL) {
if (botscr->state == USED1) {
dx = botscr->widget->core.x - scr->widget->core.x;
dy = botscr->widget->core.y - scr->widget->core.height - scr->widget->core.y;
XtMoveWidget(scr->widget, scr->widget->core.x + dx,
scr->widget->core.y + dy);
if (lefscr != NULL && lefscr->state != USED1)
XtMoveWidget(lefscr->widget, lefscr->widget->core.x + dx,
lefscr->widget->core.y + dy);
if (rigscr != NULL && rigscr->state != USED1)
XtMoveWidget(rigscr->widget, rigscr->widget->core.x + dx,
rigscr->widget->core.y + dy);
if (botscr != NULL && botscr->state != USED1)
XtMoveWidget(botscr->widget, botscr->widget->core.x + dx,
botscr->widget->core.y + dy);
}
else
XtMoveWidget(botscr->widget, scr->widget->core.x,
scr->widget->core.y + scr->widget->core.height);
}
adj = (XF86ConfAdjacencyPtr)(adj->list.next);
}
for (i = 0; i < computer.num_screens; i++)
if (computer.screens[i]->state == USED1)
computer.screens[i]->state = USED;
else
XLowerWindow(XtDisplay(computer.screens[i]->widget),
XtWindow(computer.screens[i]->widget));
w = work->core.width / (columns + 1) - 5;
h = work->core.height / (rows + 1) - 5;
if (w > h)
w = h;
else
h = w;
dx = (work->core.width - (columns * w)) >> 1;
dy = (work->core.height - (rows * h)) >> 1;
xf = (double)w / (double)computer.screens[0]->widget->core.width;
yf = (double)h / (double)computer.screens[0]->widget->core.height;
for (i = 0; i < computer.num_screens; i++) {
Widget z = computer.screens[i]->widget;
if (computer.screens[i]->state == USED)
XtConfigureWidget(z, z->core.x * xf + dx,
z->core.y * yf + dy, w, h, 0);
else
XtConfigureWidget(z, z->core.x, z->core.y, w, h, 0);
}
if (computer.screens[base]->row >= 0) {
double xf, yf;
int width, height;
for (i = 0; i < computer.num_screens; i++) {
width = computer.screens[i]->screen->scrn_monitor->mon_width;
height = computer.screens[i]->screen->scrn_monitor->mon_height;
if (width <= 0) {
width = mon_width;
height = mon_height;
}
if (computer.screens[i]->rotate) {
xf = (double)width / (double)mon_width * 8. / 10.;
yf = (double)height / (double)mon_height;
}
else {
xf = (double)width / (double)mon_width;
yf = (double)height / (double)mon_height * 8. / 10.;
}
width = computer.screens[i]->widget->core.width * xf;
height = computer.screens[i]->widget->core.height * yf;
if (computer.screens[i]->state == USED) {
if (mon_widths[computer.screens[i]->column] < width)
mon_widths[computer.screens[i]->column] = width;
if (mon_heights[computer.screens[i]->row] < height)
mon_heights[computer.screens[i]->row] = height;
}
/* do it here to avoid recalculation */
computer.screens[i]->rect.width = width;
computer.screens[i]->rect.height = height;
}
}
for (i = 0; i < computer.num_screens; i++)
ReshapeScreenWidget(computer.screens[i]);
/* do a new pass, to avoid gaps if the monitors have different
* sizes.
*/
if (computer.screens[base]->row >= 0) {
x = computer.screens[base]->widget->core.x;
y = computer.screens[base]->widget->core.y;
/* screens representations are already ordered */
for (i = base; i < computer.num_screens; i++) {
if (computer.screens[i]->state == UNUSED)
continue;
if (computer.screens[i]->column != 0)
x += mon_widths[computer.screens[i]->column];
else {
x = computer.screens[base]->widget->core.x;
if (i != base)
y += mon_heights[computer.screens[i]->row];
}
XtMoveWidget(computer.screens[i]->widget, x, y);
}
}
XtMapWidget(work);
}
static int
qcmp_screen(_Xconst void *a, _Xconst void *b)
{
xf86cfgScreen *s1, *s2;
s1 = *(xf86cfgScreen**)a;
s2 = *(xf86cfgScreen**)b;
if (s1->widget->core.x > s2->widget->core.x) {
if (s2->widget->core.y >=
s1->widget->core.y + (s1->widget->core.height >> 1))
return (-1);
return (1);
}
else {
if (s1->widget->core.y >=
s2->widget->core.y + (s2->widget->core.height >> 1))
return (1);
return (-1);
}
/*NOTREACHED*/
}
void
UpdateScreenUI(void)
{
XF86ConfLayoutPtr lay = computer.layout;
XF86ConfAdjacencyPtr adj, prev, left, base;
int i, p, cols, scrno;
if (lay == NULL)
return;
rows = columns = cols = 1;
qsort(computer.screens, computer.num_screens, sizeof(xf86cfgScreen*),
qcmp_screen);
adj = prev = left = base = NULL;
for (i = p = scrno = 0; i < computer.num_screens; i++) {
XF86ConfScreenPtr scr = computer.screens[i]->screen;
if (computer.screens[i]->state == UNUSED)
continue;
adj = (XF86ConfAdjacencyPtr)XtCalloc(1, sizeof(XF86ConfAdjacencyRec));
adj->adj_scrnum = scrno++;
adj->adj_screen = scr;
adj->adj_screen_str = XtNewString(scr->scrn_identifier);
if (base == NULL) {
base = left = adj;
computer.screens[i]->row = computer.screens[i]->column = 0;
}
else {
int dy = computer.screens[i]->widget->core.y -
computer.screens[p]->widget->core.y;
prev->list.next = adj;
if (dy > (computer.screens[i]->widget->core.height >> 1)) {
adj->adj_where = CONF_ADJ_BELOW;
adj->adj_refscreen = XtNewString(left->adj_screen_str);
left = adj;
computer.screens[i]->row = rows;
computer.screens[i]->column = 0;
cols = 1;
++rows;
}
else {
computer.screens[i]->row = rows - 1;
computer.screens[i]->column = cols;
adj->adj_where = CONF_ADJ_RIGHTOF;
if (++cols > columns)
columns = cols;
adj->adj_refscreen = XtNewString(prev->adj_screen_str);
}
}
prev = adj;
p = i;
}
adj = lay->lay_adjacency_lst;
while (adj != NULL) {
prev = adj;
adj = (XF86ConfAdjacencyPtr)(adj->list.next);
XtFree(prev->adj_screen_str);
XtFree(prev->adj_right_str);
XtFree(prev->adj_left_str);
XtFree(prev->adj_top_str);
XtFree(prev->adj_bottom_str);
XtFree(prev->adj_refscreen);
XtFree((char*)prev);
}
lay->lay_adjacency_lst = base;
}
Reference in New Issue View Git Blame Copy Permalink