Actual source code: xops.c
1: /*
2: Defines the operations for the X PetscDraw implementation.
3: */
5: #include <../src/sys/classes/draw/impls/x/ximpl.h>
7: /*
8: These macros transform from the users coordinates to the X-window pixel coordinates.
9: */
10: #define XTRANS(draw, xwin, x) ((int)(((xwin)->w - 1) * ((draw)->port_xl + (((x - (draw)->coor_xl) * ((draw)->port_xr - (draw)->port_xl)) / ((draw)->coor_xr - (draw)->coor_xl)))))
11: #define YTRANS(draw, xwin, y) (((xwin)->h - 1) - (int)(((xwin)->h - 1) * ((draw)->port_yl + (((y - (draw)->coor_yl) * ((draw)->port_yr - (draw)->port_yl)) / ((draw)->coor_yr - (draw)->coor_yl)))))
13: #define ITRANS(draw, xwin, i) ((draw)->coor_xl + (((PetscReal)(i)) * ((draw)->coor_xr - (draw)->coor_xl) / ((xwin)->w - 1) - (draw)->port_xl) / ((draw)->port_xr - (draw)->port_xl))
14: #define JTRANS(draw, xwin, j) ((draw)->coor_yl + (((PetscReal)(j)) / ((xwin)->h - 1) + (draw)->port_yl - 1) * ((draw)->coor_yr - (draw)->coor_yl) / ((draw)->port_yl - (draw)->port_yr))
16: static PetscErrorCode PetscDrawSetViewport_X(PetscDraw draw, PetscReal xl, PetscReal yl, PetscReal xr, PetscReal yr)
17: {
18: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
19: int xa, ya, xb, yb, xmax = XiWin->w - 1, ymax = XiWin->h - 1;
20: XRectangle box;
22: PetscFunctionBegin;
23: xa = (int)(xl * (PetscReal)xmax);
24: ya = ymax - (int)(yr * (PetscReal)ymax);
25: xb = (int)(xr * (PetscReal)xmax);
26: yb = ymax - (int)(yl * (PetscReal)ymax);
27: PetscDrawCollectiveBegin(draw);
28: box.x = (short)xa;
29: box.width = (unsigned short)(xb + 1 - xa);
30: box.y = (short)ya;
31: box.height = (unsigned short)(yb + 1 - ya);
32: XSetClipRectangles(XiWin->disp, XiWin->gc.set, 0, 0, &box, 1, Unsorted);
33: PetscDrawCollectiveEnd(draw);
34: PetscFunctionReturn(PETSC_SUCCESS);
35: }
37: static PetscErrorCode PetscDrawCoordinateToPixel_X(PetscDraw draw, PetscReal x, PetscReal y, int *i, int *j)
38: {
39: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
41: PetscFunctionBegin;
42: *i = XTRANS(draw, XiWin, x);
43: *j = YTRANS(draw, XiWin, y);
44: PetscFunctionReturn(PETSC_SUCCESS);
45: }
47: static PetscErrorCode PetscDrawPixelToCoordinate_X(PetscDraw draw, int i, int j, PetscReal *x, PetscReal *y)
48: {
49: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
51: PetscFunctionBegin;
52: *x = ITRANS(draw, XiWin, i);
53: *y = JTRANS(draw, XiWin, j);
54: PetscFunctionReturn(PETSC_SUCCESS);
55: }
57: static PetscErrorCode PetscDrawPoint_X(PetscDraw draw, PetscReal x, PetscReal y, int c)
58: {
59: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
60: int xx, yy, i, j;
62: PetscFunctionBegin;
63: xx = XTRANS(draw, XiWin, x);
64: yy = YTRANS(draw, XiWin, y);
65: PetscDrawXiSetColor(XiWin, c);
66: for (i = -1; i < 2; i++) {
67: for (j = -1; j < 2; j++) XDrawPoint(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, xx + i, yy + j);
68: }
69: PetscFunctionReturn(PETSC_SUCCESS);
70: }
72: static PetscErrorCode PetscDrawPointPixel_X(PetscDraw draw, int x, int y, int c)
73: {
74: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
76: PetscFunctionBegin;
77: PetscDrawXiSetColor(XiWin, c);
78: XDrawPoint(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x, y);
79: PetscFunctionReturn(PETSC_SUCCESS);
80: }
82: static PetscErrorCode PetscDrawLine_X(PetscDraw draw, PetscReal xl, PetscReal yl, PetscReal xr, PetscReal yr, int cl)
83: {
84: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
85: int x_1, y_1, x_2, y_2;
87: PetscFunctionBegin;
88: PetscDrawXiSetColor(XiWin, cl);
89: x_1 = XTRANS(draw, XiWin, xl);
90: x_2 = XTRANS(draw, XiWin, xr);
91: y_1 = YTRANS(draw, XiWin, yl);
92: y_2 = YTRANS(draw, XiWin, yr);
93: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_1, y_1, x_2, y_2);
94: PetscFunctionReturn(PETSC_SUCCESS);
95: }
97: static PetscErrorCode PetscDrawArrow_X(PetscDraw draw, PetscReal xl, PetscReal yl, PetscReal xr, PetscReal yr, int cl)
98: {
99: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
100: int x_1, y_1, x_2, y_2;
102: PetscFunctionBegin;
103: PetscDrawXiSetColor(XiWin, cl);
104: x_1 = XTRANS(draw, XiWin, xl);
105: x_2 = XTRANS(draw, XiWin, xr);
106: y_1 = YTRANS(draw, XiWin, yl);
107: y_2 = YTRANS(draw, XiWin, yr);
108: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_1, y_1, x_2, y_2);
109: if (x_1 == x_2 && y_1 == y_2) PetscFunctionReturn(PETSC_SUCCESS);
110: if (x_1 == x_2 && PetscAbs(y_1 - y_2) > 7) {
111: if (y_2 > y_1) {
112: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_2, y_2, x_2 - 3, y_2 - 3);
113: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_2, y_2, x_2 + 3, y_2 - 3);
114: } else {
115: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_2, y_2, x_2 - 3, y_2 + 3);
116: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_2, y_2, x_2 + 3, y_2 + 3);
117: }
118: }
119: if (y_1 == y_2 && PetscAbs(x_1 - x_2) > 7) {
120: if (x_2 > x_1) {
121: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_2 - 3, y_2 - 3, x_2, y_2);
122: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_2 - 3, y_2 + 3, x_2, y_2);
123: } else {
124: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_2, y_2, x_2 + 3, y_2 - 3);
125: XDrawLine(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x_2, y_2, x_2 + 3, y_2 + 3);
126: }
127: }
128: PetscFunctionReturn(PETSC_SUCCESS);
129: }
131: static PetscErrorCode PetscDrawRectangle_X(PetscDraw draw, PetscReal xl, PetscReal yl, PetscReal xr, PetscReal yr, int c1, int c2, int c3, int c4)
132: {
133: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
134: int x, y, w, h, c = (c1 + c2 + c3 + c4) / 4;
136: PetscFunctionBegin;
137: PetscDrawXiSetColor(XiWin, c);
138: x = XTRANS(draw, XiWin, xl);
139: w = XTRANS(draw, XiWin, xr) + 1 - x;
140: if (w <= 0) w = 1;
141: y = YTRANS(draw, XiWin, yr);
142: h = YTRANS(draw, XiWin, yl) + 1 - y;
143: if (h <= 0) h = 1;
144: XFillRectangle(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x, y, w, h);
145: PetscFunctionReturn(PETSC_SUCCESS);
146: }
148: static PetscErrorCode PetscDrawEllipse_X(PetscDraw draw, PetscReal x, PetscReal y, PetscReal a, PetscReal b, int c)
149: {
150: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
151: int xA, yA, w, h;
153: PetscFunctionBegin;
154: PetscDrawXiSetColor(XiWin, c);
155: xA = XTRANS(draw, XiWin, x - a / 2);
156: w = XTRANS(draw, XiWin, x + a / 2) + 1 - xA;
157: w = PetscAbs(w);
158: yA = YTRANS(draw, XiWin, y + b / 2);
159: h = YTRANS(draw, XiWin, y - b / 2) + 1 - yA;
160: h = PetscAbs(h);
161: XFillArc(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, xA, yA, w, h, 0, 360 * 64);
162: PetscFunctionReturn(PETSC_SUCCESS);
163: }
165: PETSC_INTERN PetscErrorCode PetscDrawInterpolatedTriangle_X(PetscDraw_X *, int, int, int, int, int, int, int, int, int);
167: static PetscErrorCode PetscDrawTriangle_X(PetscDraw draw, PetscReal X1, PetscReal Y_1, PetscReal X2, PetscReal Y2, PetscReal X3, PetscReal Y3, int c1, int c2, int c3)
168: {
169: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
171: PetscFunctionBegin;
172: if (c1 == c2 && c2 == c3) {
173: XPoint pt[3];
174: PetscDrawXiSetColor(XiWin, c1);
175: pt[0].x = (short)XTRANS(draw, XiWin, X1);
176: pt[0].y = (short)YTRANS(draw, XiWin, Y_1);
177: pt[1].x = (short)XTRANS(draw, XiWin, X2);
178: pt[1].y = (short)YTRANS(draw, XiWin, Y2);
179: pt[2].x = (short)XTRANS(draw, XiWin, X3);
180: pt[2].y = (short)YTRANS(draw, XiWin, Y3);
181: XFillPolygon(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, pt, 3, Convex, CoordModeOrigin);
182: } else {
183: int x1, y_1, x2, y2, x3, y3;
184: x1 = XTRANS(draw, XiWin, X1);
185: y_1 = YTRANS(draw, XiWin, Y_1);
186: x2 = XTRANS(draw, XiWin, X2);
187: y2 = YTRANS(draw, XiWin, Y2);
188: x3 = XTRANS(draw, XiWin, X3);
189: y3 = YTRANS(draw, XiWin, Y3);
190: PetscCall(PetscDrawInterpolatedTriangle_X(XiWin, x1, y_1, c1, x2, y2, c2, x3, y3, c3));
191: }
192: PetscFunctionReturn(PETSC_SUCCESS);
193: }
195: static PetscErrorCode PetscDrawStringSetSize_X(PetscDraw draw, PetscReal x, PetscReal y)
196: {
197: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
198: int w, h;
200: PetscFunctionBegin;
201: w = (int)(XiWin->w * x * (draw->port_xr - draw->port_xl) / (draw->coor_xr - draw->coor_xl));
202: h = (int)(XiWin->h * y * (draw->port_yr - draw->port_yl) / (draw->coor_yr - draw->coor_yl));
203: PetscCall(PetscFree(XiWin->font));
204: PetscCall(PetscDrawXiFontFixed(XiWin, w, h, &XiWin->font));
205: PetscFunctionReturn(PETSC_SUCCESS);
206: }
208: static PetscErrorCode PetscDrawStringGetSize_X(PetscDraw draw, PetscReal *x, PetscReal *y)
209: {
210: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
211: PetscReal w, h;
213: PetscFunctionBegin;
214: w = XiWin->font->font_w;
215: h = XiWin->font->font_h;
216: if (x) *x = w * (draw->coor_xr - draw->coor_xl) / (XiWin->w * (draw->port_xr - draw->port_xl));
217: if (y) *y = h * (draw->coor_yr - draw->coor_yl) / (XiWin->h * (draw->port_yr - draw->port_yl));
218: PetscFunctionReturn(PETSC_SUCCESS);
219: }
221: static PetscErrorCode PetscDrawString_X(PetscDraw draw, PetscReal x, PetscReal y, int c, const char chrs[])
222: {
223: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
224: int xx, yy, descent = XiWin->font->font_descent;
225: size_t len;
226: const char *substr;
227: PetscToken token;
229: PetscFunctionBegin;
230: xx = XTRANS(draw, XiWin, x);
231: yy = YTRANS(draw, XiWin, y);
232: PetscDrawXiSetColor(XiWin, c);
234: PetscCall(PetscTokenCreate(chrs, '\n', &token));
235: PetscCall(PetscTokenFind(token, &substr));
236: while (substr) {
237: PetscCall(PetscStrlen(substr, &len));
238: XDrawString(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, xx, yy - descent, substr, (int)len);
239: yy += XiWin->font->font_h;
240: PetscCall(PetscTokenFind(token, &substr));
241: }
242: PetscCall(PetscTokenDestroy(&token));
243: PetscFunctionReturn(PETSC_SUCCESS);
244: }
246: static PetscErrorCode PetscDrawStringVertical_X(PetscDraw draw, PetscReal x, PetscReal y, int c, const char text[])
247: {
248: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
249: int xx, yy, offset = XiWin->font->font_h - XiWin->font->font_descent;
250: char chr[2] = {0, 0};
252: PetscFunctionBegin;
253: xx = XTRANS(draw, XiWin, x);
254: yy = YTRANS(draw, XiWin, y);
255: PetscDrawXiSetColor(XiWin, c);
256: while ((chr[0] = *text++)) {
257: XDrawString(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, xx, yy + offset, chr, 1);
258: yy += XiWin->font->font_h;
259: }
260: PetscFunctionReturn(PETSC_SUCCESS);
261: }
263: static PetscErrorCode PetscDrawFlush_X(PetscDraw draw)
264: {
265: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
266: PetscMPIInt rank;
268: PetscFunctionBegin;
269: /* make sure the X server processed requests from all processes */
270: PetscDrawCollectiveBegin(draw);
271: XSync(XiWin->disp, False);
272: PetscDrawCollectiveEnd(draw);
273: PetscCallMPI(MPI_Barrier(PetscObjectComm((PetscObject)draw)));
275: /* transfer pixmap contents to window (only the first process does this) */
276: if (XiWin->drw && XiWin->win) {
277: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
278: PetscDrawCollectiveBegin(draw);
279: if (rank == 0) XCopyArea(XiWin->disp, XiWin->drw, XiWin->win, XiWin->gc.set, 0, 0, XiWin->w, XiWin->h, 0, 0);
280: if (rank == 0) XSync(XiWin->disp, False);
281: PetscDrawCollectiveEnd(draw);
282: PetscCallMPI(MPI_Barrier(PetscObjectComm((PetscObject)draw)));
283: }
284: PetscFunctionReturn(PETSC_SUCCESS);
285: }
287: static PetscErrorCode PetscDrawClear_X(PetscDraw draw)
288: {
289: PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
290: int xmax = XiWin->w - 1, ymax = XiWin->h - 1;
291: PetscReal xl = draw->port_xl, yl = draw->port_yl;
292: PetscReal xr = draw->port_xr, yr = draw->port_yr;
293: PetscMPIInt rank;
295: PetscFunctionBegin;
296: /* make sure the X server processed requests from all processes */
297: PetscDrawCollectiveBegin(draw);
298: XSync(XiWin->disp, False);
299: PetscDrawCollectiveEnd(draw);
300: PetscCallMPI(MPI_Barrier(PetscObjectComm((PetscObject)draw)));
302: /* only the first process handles the clearing business */
303: PetscDrawCollectiveBegin(draw);
304: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
305: if (rank == 0) {
306: int xa = (int)(xl * xmax), ya = ymax - (int)(yr * ymax);
307: int xb = (int)(xr * xmax), yb = ymax - (int)(yl * ymax);
308: unsigned int w = (unsigned int)(xb + 1 - xa);
309: unsigned int h = (unsigned int)(yb + 1 - ya);
310: PetscDrawXiSetPixVal(XiWin, XiWin->background);
311: XFillRectangle(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, xa, ya, w, h);
312: XSync(XiWin->disp, False);
313: }
314: PetscDrawCollectiveEnd(draw);
315: PetscCallMPI(MPI_Barrier(PetscObjectComm((PetscObject)draw)));
316: PetscFunctionReturn(PETSC_SUCCESS);
317: }
319: static PetscErrorCode PetscDrawSetDoubleBuffer_X(PetscDraw draw)
320: {
321: PetscDraw_X *win = (PetscDraw_X *)draw->data;
322: PetscMPIInt rank;
324: PetscFunctionBegin;
325: if (win->drw) PetscFunctionReturn(PETSC_SUCCESS);
326: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
328: PetscDrawCollectiveBegin(draw);
329: if (rank == 0) PetscCall(PetscDrawXiQuickPixmap(win));
330: PetscDrawCollectiveEnd(draw);
331: PetscCallMPI(MPI_Bcast(&win->drw, 1, MPI_UNSIGNED_LONG, 0, PetscObjectComm((PetscObject)draw)));
332: PetscFunctionReturn(PETSC_SUCCESS);
333: }
335: static PetscErrorCode PetscDrawGetPopup_X(PetscDraw draw, PetscDraw *popup)
336: {
337: PetscDraw_X *win = (PetscDraw_X *)draw->data;
338: PetscBool flg = PETSC_TRUE;
340: PetscFunctionBegin;
341: PetscCall(PetscOptionsGetBool(((PetscObject)draw)->options, ((PetscObject)draw)->prefix, "-draw_popup", &flg, NULL));
342: if (!flg || !win->win) {
343: *popup = NULL;
344: PetscFunctionReturn(PETSC_SUCCESS);
345: }
347: PetscCall(PetscDrawCreate(PetscObjectComm((PetscObject)draw), draw->display, NULL, win->x, win->y + win->h + 10, 220, 220, popup));
348: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)*popup, "popup_"));
349: PetscCall(PetscObjectAppendOptionsPrefix((PetscObject)*popup, ((PetscObject)draw)->prefix));
350: PetscCall(PetscDrawSetType(*popup, PETSC_DRAW_X));
351: draw->popup = *popup;
352: PetscFunctionReturn(PETSC_SUCCESS);
353: }
355: static PetscErrorCode PetscDrawSetTitle_X(PetscDraw draw, const char title[])
356: {
357: PetscDraw_X *win = (PetscDraw_X *)draw->data;
358: PetscMPIInt rank;
360: PetscFunctionBegin;
361: if (!win->win) PetscFunctionReturn(PETSC_SUCCESS);
362: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
363: PetscDrawCollectiveBegin(draw);
364: if (rank == 0) {
365: size_t len;
366: XTextProperty prop;
367: PetscCall(PetscStrlen(title, &len));
368: XGetWMName(win->disp, win->win, &prop);
369: XFree((void *)prop.value);
370: prop.value = (unsigned char *)title;
371: prop.nitems = (long)len;
372: XSetWMName(win->disp, win->win, &prop);
373: }
374: PetscDrawCollectiveEnd(draw);
375: PetscFunctionReturn(PETSC_SUCCESS);
376: }
378: static PetscErrorCode PetscDrawCheckResizedWindow_X(PetscDraw draw)
379: {
380: PetscDraw_X *win = (PetscDraw_X *)draw->data;
381: int xywh[4] = {0, 0, 0, 0};
382: PetscMPIInt rank;
384: PetscFunctionBegin;
385: if (!win->win) PetscFunctionReturn(PETSC_SUCCESS);
386: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
388: PetscDrawCollectiveBegin(draw);
389: if (rank == 0) PetscCall(PetscDrawXiGetGeometry(win, xywh, xywh + 1, xywh + 2, xywh + 3));
390: PetscDrawCollectiveEnd(draw);
391: PetscCallMPI(MPI_Bcast(xywh, 4, MPI_INT, 0, PetscObjectComm((PetscObject)draw)));
393: /* record new window position */
394: draw->x = win->x = xywh[0];
395: draw->y = win->y = xywh[1];
396: if (xywh[2] == win->w && xywh[3] == win->h) PetscFunctionReturn(PETSC_SUCCESS);
397: /* record new window sizes */
398: draw->w = win->w = xywh[2];
399: draw->h = win->h = xywh[3];
401: /* recreate pixmap (only first processor does this) */
402: PetscDrawCollectiveBegin(draw);
403: if (rank == 0 && win->drw) PetscCall(PetscDrawXiQuickPixmap(win));
404: PetscDrawCollectiveEnd(draw);
405: PetscCallMPI(MPI_Bcast(&win->drw, 1, MPI_UNSIGNED_LONG, 0, PetscObjectComm((PetscObject)draw)));
406: /* reset the clipping */
407: PetscCall(PetscDrawSetViewport_X(draw, draw->port_xl, draw->port_yl, draw->port_xr, draw->port_yr));
408: PetscFunctionReturn(PETSC_SUCCESS);
409: }
411: static PetscErrorCode PetscDrawResizeWindow_X(PetscDraw draw, int w, int h)
412: {
413: PetscDraw_X *win = (PetscDraw_X *)draw->data;
414: PetscMPIInt rank;
416: PetscFunctionBegin;
417: if (w == win->w && h == win->h) PetscFunctionReturn(PETSC_SUCCESS);
418: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
420: if (win->win) {
421: PetscDrawCollectiveBegin(draw);
422: if (rank == 0) PetscCall(PetscDrawXiResizeWindow(win, w, h));
423: PetscDrawCollectiveEnd(draw);
424: PetscCall(PetscDrawCheckResizedWindow_X(draw));
425: } else if (win->drw) {
426: draw->w = win->w = w;
427: draw->h = win->h = h;
428: /* recreate pixmap (only first processor does this) */
429: PetscDrawCollectiveBegin(draw);
430: if (rank == 0) PetscCall(PetscDrawXiQuickPixmap(win));
431: PetscCallMPI(MPI_Bcast(&win->drw, 1, MPI_UNSIGNED_LONG, 0, PetscObjectComm((PetscObject)draw)));
432: /* reset the clipping */
433: PetscDrawCollectiveEnd(draw);
434: PetscCall(PetscDrawSetViewport_X(draw, draw->port_xl, draw->port_yl, draw->port_xr, draw->port_yr));
435: }
436: PetscFunctionReturn(PETSC_SUCCESS);
437: }
439: #include <X11/cursorfont.h>
441: static PetscErrorCode PetscDrawGetMouseButton_X(PetscDraw draw, PetscDrawButton *button, PetscReal *x_user, PetscReal *y_user, PetscReal *x_phys, PetscReal *y_phys)
442: {
443: PetscDraw_X *win = (PetscDraw_X *)draw->data;
444: Cursor cursor;
445: XEvent report;
446: Window root, child;
447: int root_x, root_y, px = 0, py = 0;
448: unsigned int w, h, border, depth;
449: unsigned int keys_button;
450: PetscMPIInt rank;
451: PetscReal xx, yy;
453: PetscFunctionBegin;
454: *button = PETSC_BUTTON_NONE;
455: if (!win->win) PetscFunctionReturn(PETSC_SUCCESS);
456: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
458: PetscDrawCollectiveBegin(draw);
459: if (rank) goto finally;
461: /* change cursor to indicate input */
462: cursor = XCreateFontCursor(win->disp, XC_hand2);
463: PetscCheck(cursor, PETSC_COMM_SELF, PETSC_ERR_LIB, "Unable to create X cursor");
464: XDefineCursor(win->disp, win->win, cursor);
465: /* wait for mouse button events */
466: XSelectInput(win->disp, win->win, ButtonPressMask | ButtonReleaseMask);
467: while (XCheckTypedEvent(win->disp, ButtonPress, &report));
468: XMaskEvent(win->disp, ButtonReleaseMask, &report);
469: /* get mouse pointer coordinates */
470: XQueryPointer(win->disp, report.xmotion.window, &root, &child, &root_x, &root_y, &px, &py, &keys_button);
471: /* the user may resize the window before pressing the mouse button */
472: XGetGeometry(win->disp, win->win, &root, &root_x, &root_y, &w, &h, &border, &depth);
473: /* cleanup input event handler and cursor */
474: XSelectInput(win->disp, win->win, NoEventMask);
475: XUndefineCursor(win->disp, win->win);
476: XFreeCursor(win->disp, cursor);
477: XSync(win->disp, False);
479: switch (report.xbutton.button) {
480: case Button1:
481: *button = PETSC_BUTTON_LEFT;
482: break;
483: case Button2:
484: *button = PETSC_BUTTON_CENTER;
485: break;
486: case Button3:
487: *button = PETSC_BUTTON_RIGHT;
488: break;
489: case Button4:
490: *button = PETSC_BUTTON_WHEEL_UP;
491: break;
492: case Button5:
493: *button = PETSC_BUTTON_WHEEL_DOWN;
494: break;
495: }
496: if (report.xbutton.state & ShiftMask) {
497: switch (report.xbutton.button) {
498: case Button1:
499: *button = PETSC_BUTTON_LEFT_SHIFT;
500: break;
501: case Button2:
502: *button = PETSC_BUTTON_CENTER_SHIFT;
503: break;
504: case Button3:
505: *button = PETSC_BUTTON_RIGHT_SHIFT;
506: break;
507: }
508: }
509: xx = ((PetscReal)px) / w;
510: yy = 1 - ((PetscReal)py) / h;
511: if (x_user) *x_user = draw->coor_xl + (xx - draw->port_xl) * (draw->coor_xr - draw->coor_xl) / (draw->port_xr - draw->port_xl);
512: if (y_user) *y_user = draw->coor_yl + (yy - draw->port_yl) * (draw->coor_yr - draw->coor_yl) / (draw->port_yr - draw->port_yl);
513: if (x_phys) *x_phys = xx;
514: if (y_phys) *y_phys = yy;
516: finally:
517: PetscDrawCollectiveEnd(draw);
518: PetscCall(PetscDrawCheckResizedWindow_X(draw));
519: PetscFunctionReturn(PETSC_SUCCESS);
520: }
522: static PetscErrorCode PetscDrawSetVisible_X(PetscDraw draw, PetscBool visible)
523: {
524: PetscDraw_X *Xwin = (PetscDraw_X *)draw->data;
525: PetscMPIInt rank;
527: PetscFunctionBegin;
528: PetscDrawCollectiveBegin(draw);
529: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
530: if (rank == 0) {
531: if (Xwin->win) {
532: if (visible) {
533: XMapWindow(Xwin->disp, Xwin->win);
534: } else {
535: XUnmapWindow(Xwin->disp, Xwin->win);
536: XFlush(Xwin->disp);
537: }
538: }
539: }
540: PetscDrawCollectiveEnd(draw);
541: PetscFunctionReturn(PETSC_SUCCESS);
542: }
544: static PetscErrorCode PetscDrawPause_X(PetscDraw draw)
545: {
546: PetscDraw_X *win = (PetscDraw_X *)draw->data;
548: PetscFunctionBegin;
549: if (!win->win) PetscFunctionReturn(PETSC_SUCCESS);
550: if (draw->pause > 0) PetscCall(PetscSleep(draw->pause));
551: else if (draw->pause == -1) {
552: PetscDrawButton button = PETSC_BUTTON_NONE;
553: PetscCall(PetscDrawGetMouseButton(draw, &button, NULL, NULL, NULL, NULL));
554: if (button == PETSC_BUTTON_CENTER) draw->pause = 0;
555: }
556: PetscFunctionReturn(PETSC_SUCCESS);
557: }
559: static PetscErrorCode PetscDrawDestroy_X(PetscDraw draw)
560: {
561: PetscDraw_X *win = (PetscDraw_X *)draw->data;
563: PetscFunctionBegin;
564: PetscCall(PetscDrawDestroy(&draw->popup));
565: PetscCall(PetscDrawXiClose(win));
566: PetscCall(PetscFree(draw->data));
567: PetscFunctionReturn(PETSC_SUCCESS);
568: }
570: static PetscErrorCode PetscDrawGetSingleton_X(PetscDraw, PetscDraw *);
571: static PetscErrorCode PetscDrawRestoreSingleton_X(PetscDraw, PetscDraw *);
572: PETSC_INTERN PetscErrorCode PetscDrawGetImage_X(PetscDraw, unsigned char[][3], unsigned int *, unsigned int *, unsigned char *[]);
574: static struct _PetscDrawOps DvOps = {PetscDrawSetDoubleBuffer_X, PetscDrawFlush_X, PetscDrawLine_X, NULL, NULL, PetscDrawPoint_X, NULL, PetscDrawString_X, PetscDrawStringVertical_X, PetscDrawStringSetSize_X, PetscDrawStringGetSize_X, PetscDrawSetViewport_X, PetscDrawClear_X, PetscDrawRectangle_X, PetscDrawTriangle_X, PetscDrawEllipse_X, PetscDrawGetMouseButton_X, PetscDrawPause_X, NULL, NULL, PetscDrawGetPopup_X, PetscDrawSetTitle_X, PetscDrawCheckResizedWindow_X, PetscDrawResizeWindow_X, PetscDrawDestroy_X, NULL, PetscDrawGetSingleton_X, PetscDrawRestoreSingleton_X, NULL, PetscDrawGetImage_X, NULL, PetscDrawArrow_X, PetscDrawCoordinateToPixel_X, PetscDrawPixelToCoordinate_X, PetscDrawPointPixel_X, NULL, PetscDrawSetVisible_X};
576: static PetscErrorCode PetscDrawGetSingleton_X(PetscDraw draw, PetscDraw *sdraw)
577: {
578: PetscDraw_X *Xwin = (PetscDraw_X *)draw->data, *sXwin;
580: PetscFunctionBegin;
581: PetscCall(PetscDrawCreate(PETSC_COMM_SELF, draw->display, draw->title, draw->x, draw->y, draw->w, draw->h, sdraw));
582: PetscCall(PetscObjectChangeTypeName((PetscObject)*sdraw, PETSC_DRAW_X));
583: (*sdraw)->ops[0] = DvOps;
585: if (draw->popup) PetscCall(PetscDrawGetSingleton(draw->popup, &(*sdraw)->popup));
586: (*sdraw)->pause = draw->pause;
587: (*sdraw)->coor_xl = draw->coor_xl;
588: (*sdraw)->coor_xr = draw->coor_xr;
589: (*sdraw)->coor_yl = draw->coor_yl;
590: (*sdraw)->coor_yr = draw->coor_yr;
591: (*sdraw)->port_xl = draw->port_xl;
592: (*sdraw)->port_xr = draw->port_xr;
593: (*sdraw)->port_yl = draw->port_yl;
594: (*sdraw)->port_yr = draw->port_yr;
596: /* share drawables (windows and/or pixmap) from the parent draw */
597: PetscCall(PetscNew(&sXwin));
598: (*sdraw)->data = (void *)sXwin;
599: PetscCall(PetscDrawXiInit(sXwin, draw->display));
600: if (Xwin->win) {
601: PetscCall(PetscDrawXiQuickWindowFromWindow(sXwin, Xwin->win));
602: sXwin->drw = Xwin->drw; /* XXX If the window is ever resized, this is wrong! */
603: } else if (Xwin->drw) {
604: PetscCall(PetscDrawXiColormap(sXwin));
605: sXwin->drw = Xwin->drw;
606: }
607: PetscCall(PetscDrawXiGetGeometry(sXwin, &sXwin->x, &sXwin->y, &sXwin->w, &sXwin->h));
608: (*sdraw)->x = sXwin->x;
609: (*sdraw)->y = sXwin->y;
610: (*sdraw)->w = sXwin->w;
611: (*sdraw)->h = sXwin->h;
612: PetscFunctionReturn(PETSC_SUCCESS);
613: }
615: static PetscErrorCode PetscDrawRestoreSingleton_X(PetscDraw draw, PetscDraw *sdraw)
616: {
617: PetscFunctionBegin;
618: if (draw->popup && (*sdraw)->popup) {
619: PetscBool isdrawx;
620: PetscDraw_X *pXwin = (PetscDraw_X *)draw->popup->data;
621: PetscDraw_X *sXwin = (PetscDraw_X *)(*sdraw)->popup->data;
622: PetscCall(PetscObjectTypeCompare((PetscObject)draw->popup, PETSC_DRAW_X, &isdrawx));
623: if (!isdrawx) goto finally;
624: PetscCall(PetscObjectTypeCompare((PetscObject)(*sdraw)->popup, PETSC_DRAW_X, &isdrawx));
625: if (!isdrawx) goto finally;
626: if (sXwin->win == pXwin->win) PetscCall(PetscDrawRestoreSingleton(draw->popup, &(*sdraw)->popup));
627: }
628: finally:
629: PetscCall(PetscDrawDestroy(sdraw));
630: PetscFunctionReturn(PETSC_SUCCESS);
631: }
633: static PetscErrorCode PetscDrawXGetDisplaySize_Private(const char name[], int *width, int *height, PetscBool *has_display)
634: {
635: Display *display;
637: PetscFunctionBegin;
638: display = XOpenDisplay(name);
639: if (display) {
640: *has_display = PETSC_TRUE;
641: *width = DisplayWidth(display, DefaultScreen(display));
642: *height = DisplayHeight(display, DefaultScreen(display));
643: XCloseDisplay(display);
644: } else {
645: *has_display = PETSC_FALSE;
646: *width = 0;
647: *height = 0;
648: PetscCall((*PetscErrorPrintf)("Unable to open display on %s\n\
649: Make sure your COMPUTE NODES are authorized to connect\n\
650: to this X server and either your DISPLAY variable\n\
651: is set or you use the -display name option\n",
652: name));
653: }
654: PetscFunctionReturn(PETSC_SUCCESS);
655: }
657: /*MC
658: PETSC_DRAW_X - PETSc graphics device that uses either X windows or its virtual version Xvfb
660: Options Database Keys:
661: + -display <display> - sets the display to use
662: . -x_virtual - forces use of a X virtual display Xvfb that will not display anything but -draw_save will still work.
663: Xvfb is automatically started up in PetscSetDisplay() with this option
664: . -draw_size w,h - percentage of screen (either 1, .5, .3, .25), or size in pixels
665: . -geometry x,y,w,h - set location and size in pixels
666: . -draw_virtual - do not open a window (draw on a pixmap), -draw_save will still work
667: - -draw_double_buffer - avoid window flickering (draw on pixmap and flush to window)
669: Level: beginner
671: .seealso: `PetscDraw`, `PetscDrawOpenX()`, `PetscDrawSetDisplay()`, `PetscDrawSetFromOptions()`
672: M*/
674: PETSC_EXTERN PetscErrorCode PetscDrawCreate_X(PetscDraw draw)
675: {
676: PetscDraw_X *Xwin;
677: PetscMPIInt rank;
678: int x = draw->x, y = draw->y, w = draw->w, h = draw->h;
679: static int xavailable = 0, yavailable = 0, ybottom = 0, xmax = 0, ymax = 0;
680: PetscBool set, dvirtual = PETSC_FALSE, doublebuffer = PETSC_TRUE, has_display;
681: PetscInt xywh[4], osize = 4, nsizes = 2;
682: PetscReal sizes[2] = {.3, .3};
683: static size_t DISPLAY_LENGTH = 265;
685: PetscFunctionBegin;
686: /* get the display variable */
687: if (!draw->display) {
688: PetscCall(PetscMalloc1(DISPLAY_LENGTH, &draw->display));
689: PetscCall(PetscGetDisplay(draw->display, DISPLAY_LENGTH));
690: }
692: /* initialize the display size */
693: if (!xmax) {
694: PetscCall(PetscDrawXGetDisplaySize_Private(draw->display, &xmax, &ymax, &has_display));
695: /* if some processors fail on this and others succeed then this is a problem ! */
696: if (!has_display) {
697: PetscCall((*PetscErrorPrintf)("PETSc unable to use X windows\nproceeding without graphics\n"));
698: PetscCall(PetscDrawSetType(draw, PETSC_DRAW_NULL));
699: PetscFunctionReturn(PETSC_SUCCESS);
700: }
701: }
703: /* allow user to set size of drawable */
704: PetscCall(PetscOptionsGetRealArray(((PetscObject)draw)->options, ((PetscObject)draw)->prefix, "-draw_size", sizes, &nsizes, &set));
705: if (set && nsizes == 1 && sizes[0] > 1.0) sizes[1] = sizes[0];
706: if (set) {
707: if (sizes[0] > 1.0) w = (int)sizes[0];
708: else if (sizes[0] == 1.0) w = PETSC_DRAW_FULL_SIZE;
709: else if (sizes[0] == .5) w = PETSC_DRAW_HALF_SIZE;
710: else if (PetscEqualReal(sizes[0], .3)) w = PETSC_DRAW_THIRD_SIZE; /* sizes == 0.3 will never be true */
711: else if (sizes[0] == .25) w = PETSC_DRAW_QUARTER_SIZE;
712: if (sizes[1] > 1.0) h = (int)sizes[1];
713: else if (sizes[1] == 1.0) h = PETSC_DRAW_FULL_SIZE;
714: else if (sizes[1] == .5) h = PETSC_DRAW_HALF_SIZE;
715: else if (PetscEqualReal(sizes[1], .3)) h = PETSC_DRAW_THIRD_SIZE; /* sizes == 0.3 will never be true */
716: else if (sizes[1] == .25) h = PETSC_DRAW_QUARTER_SIZE;
717: }
718: if (w == PETSC_DECIDE || w == PETSC_DEFAULT) w = draw->w = 300;
719: if (h == PETSC_DECIDE || h == PETSC_DEFAULT) h = draw->h = 300;
720: switch (w) {
721: case PETSC_DRAW_FULL_SIZE:
722: w = draw->w = (xmax - 10);
723: break;
724: case PETSC_DRAW_HALF_SIZE:
725: w = draw->w = (xmax - 20) / 2;
726: break;
727: case PETSC_DRAW_THIRD_SIZE:
728: w = draw->w = (xmax - 30) / 3;
729: break;
730: case PETSC_DRAW_QUARTER_SIZE:
731: w = draw->w = (xmax - 40) / 4;
732: break;
733: }
734: switch (h) {
735: case PETSC_DRAW_FULL_SIZE:
736: h = draw->h = (ymax - 10);
737: break;
738: case PETSC_DRAW_HALF_SIZE:
739: h = draw->h = (ymax - 20) / 2;
740: break;
741: case PETSC_DRAW_THIRD_SIZE:
742: h = draw->h = (ymax - 30) / 3;
743: break;
744: case PETSC_DRAW_QUARTER_SIZE:
745: h = draw->h = (ymax - 40) / 4;
746: break;
747: }
749: PetscCall(PetscOptionsGetBool(((PetscObject)draw)->options, ((PetscObject)draw)->prefix, "-draw_virtual", &dvirtual, NULL));
751: if (!dvirtual) {
752: /* allow user to set location and size of window */
753: xywh[0] = x;
754: xywh[1] = y;
755: xywh[2] = w;
756: xywh[3] = h;
757: PetscCall(PetscOptionsGetIntArray(((PetscObject)draw)->options, ((PetscObject)draw)->prefix, "-geometry", xywh, &osize, NULL));
758: PetscCall(PetscCIntCast(xywh[0], &x));
759: PetscCall(PetscCIntCast(xywh[1], &y));
760: PetscCall(PetscCIntCast(xywh[2], &w));
761: PetscCall(PetscCIntCast(xywh[3], &h));
762: if (w == PETSC_DECIDE || w == PETSC_DEFAULT) w = 300;
763: if (h == PETSC_DECIDE || h == PETSC_DEFAULT) h = 300;
764: draw->x = x;
765: draw->y = y;
766: draw->w = w;
767: draw->h = h;
769: if (draw->x == PETSC_DECIDE || draw->y == PETSC_DECIDE) {
770: /*
771: PETSc tries to place windows starting in the upper left corner
772: and moving across to the right.
774: +0,0-------------------------------------------+
775: | Region used so far +xavailable,yavailable |
776: | | |
777: | | |
778: +--------------------- +ybottom |
779: | |
780: | |
781: +----------------------------------------------+xmax,ymax
783: */
784: /* First: can we add it to the right? */
785: if (xavailable + w + 10 <= xmax) {
786: x = xavailable;
787: y = yavailable;
788: ybottom = PetscMax(ybottom, y + h + 30);
789: } else {
790: /* No, so add it below on the left */
791: xavailable = x = 0;
792: yavailable = y = ybottom;
793: ybottom = ybottom + h + 30;
794: }
795: }
796: /* update available region */
797: xavailable = PetscMax(xavailable, x + w + 10);
798: if (xavailable >= xmax) {
799: xavailable = 0;
800: yavailable = yavailable + h + 30;
801: ybottom = yavailable;
802: }
803: if (yavailable >= ymax) {
804: y = 0;
805: yavailable = 0;
806: ybottom = 0;
807: }
809: } /* endif (!dvirtual) */
811: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
812: PetscCheck(rank != 0 || (w > 0 && h > 0), PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Negative window width or height");
814: PetscCall(PetscNew(&Xwin));
815: draw->ops[0] = DvOps;
816: draw->data = (void *)Xwin;
818: PetscCall(PetscDrawXiInit(Xwin, draw->display));
819: if (!dvirtual) {
820: Xwin->x = x;
821: Xwin->y = y;
822: Xwin->w = w;
823: Xwin->h = h;
824: if (rank == 0) PetscCall(PetscDrawXiQuickWindow(Xwin, draw->title, x, y, w, h));
825: PetscCallMPI(MPI_Bcast(&Xwin->win, 1, MPI_UNSIGNED_LONG, 0, PetscObjectComm((PetscObject)draw)));
826: if (rank) PetscCall(PetscDrawXiQuickWindowFromWindow(Xwin, Xwin->win));
827: } else {
828: Xwin->x = 0;
829: Xwin->y = 0;
830: Xwin->w = w;
831: Xwin->h = h;
832: PetscCall(PetscDrawXiColormap(Xwin));
833: if (rank == 0) PetscCall(PetscDrawXiQuickPixmap(Xwin));
834: PetscCallMPI(MPI_Bcast(&Xwin->drw, 1, MPI_UNSIGNED_LONG, 0, PetscObjectComm((PetscObject)draw)));
835: }
836: PetscCall(PetscDrawXiGetGeometry(Xwin, &Xwin->x, &Xwin->y, &Xwin->w, &Xwin->h));
837: draw->x = Xwin->x;
838: draw->y = Xwin->y;
839: draw->w = Xwin->w;
840: draw->h = Xwin->h;
842: PetscCall(PetscOptionsGetBool(((PetscObject)draw)->options, ((PetscObject)draw)->prefix, "-draw_double_buffer", &doublebuffer, NULL));
843: if (doublebuffer) PetscCall(PetscDrawSetDoubleBuffer(draw));
844: PetscFunctionReturn(PETSC_SUCCESS);
845: }