1 /*
2 Defines the operations for the X PetscDraw implementation.
3 */
4
5 #include <../src/sys/classes/draw/impls/x/ximpl.h> /*I "petscsys.h" I*/
6
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)))))
12
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))
15
PetscDrawSetViewport_X(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal 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;
21
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 }
36
PetscDrawCoordinateToPixel_X(PetscDraw draw,PetscReal x,PetscReal y,int * i,int * j)37 static PetscErrorCode PetscDrawCoordinateToPixel_X(PetscDraw draw, PetscReal x, PetscReal y, int *i, int *j)
38 {
39 PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
40
41 PetscFunctionBegin;
42 *i = XTRANS(draw, XiWin, x);
43 *j = YTRANS(draw, XiWin, y);
44 PetscFunctionReturn(PETSC_SUCCESS);
45 }
46
PetscDrawPixelToCoordinate_X(PetscDraw draw,int i,int j,PetscReal * x,PetscReal * y)47 static PetscErrorCode PetscDrawPixelToCoordinate_X(PetscDraw draw, int i, int j, PetscReal *x, PetscReal *y)
48 {
49 PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
50
51 PetscFunctionBegin;
52 *x = ITRANS(draw, XiWin, i);
53 *y = JTRANS(draw, XiWin, j);
54 PetscFunctionReturn(PETSC_SUCCESS);
55 }
56
PetscDrawPoint_X(PetscDraw draw,PetscReal x,PetscReal y,int c)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;
61
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 }
71
PetscDrawPointPixel_X(PetscDraw draw,int x,int y,int c)72 static PetscErrorCode PetscDrawPointPixel_X(PetscDraw draw, int x, int y, int c)
73 {
74 PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
75
76 PetscFunctionBegin;
77 PetscDrawXiSetColor(XiWin, c);
78 XDrawPoint(XiWin->disp, PetscDrawXiDrawable(XiWin), XiWin->gc.set, x, y);
79 PetscFunctionReturn(PETSC_SUCCESS);
80 }
81
PetscDrawLine_X(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int cl)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;
86
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 }
96
PetscDrawArrow_X(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int cl)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;
101
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 }
130
PetscDrawRectangle_X(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int c1,int c2,int c3,int c4)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;
135
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 }
147
PetscDrawEllipse_X(PetscDraw draw,PetscReal x,PetscReal y,PetscReal a,PetscReal b,int c)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;
152
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 }
164
165 PETSC_INTERN PetscErrorCode PetscDrawInterpolatedTriangle_X(PetscDraw_X *, int, int, int, int, int, int, int, int, int);
166
PetscDrawTriangle_X(PetscDraw draw,PetscReal X1,PetscReal Y_1,PetscReal X2,PetscReal Y2,PetscReal X3,PetscReal Y3,int c1,int c2,int c3)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;
170
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 }
194
PetscDrawStringSetSize_X(PetscDraw draw,PetscReal x,PetscReal y)195 static PetscErrorCode PetscDrawStringSetSize_X(PetscDraw draw, PetscReal x, PetscReal y)
196 {
197 PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
198 int w, h;
199
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 }
207
PetscDrawStringGetSize_X(PetscDraw draw,PetscReal * x,PetscReal * y)208 static PetscErrorCode PetscDrawStringGetSize_X(PetscDraw draw, PetscReal *x, PetscReal *y)
209 {
210 PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
211 PetscReal w, h;
212
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 }
220
PetscDrawString_X(PetscDraw draw,PetscReal x,PetscReal y,int c,const char chrs[])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;
228
229 PetscFunctionBegin;
230 xx = XTRANS(draw, XiWin, x);
231 yy = YTRANS(draw, XiWin, y);
232 PetscDrawXiSetColor(XiWin, c);
233
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 }
245
PetscDrawStringVertical_X(PetscDraw draw,PetscReal x,PetscReal y,int c,const char text[])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};
251
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 }
262
PetscDrawFlush_X(PetscDraw draw)263 static PetscErrorCode PetscDrawFlush_X(PetscDraw draw)
264 {
265 PetscDraw_X *XiWin = (PetscDraw_X *)draw->data;
266 PetscMPIInt rank;
267
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)));
274
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 }
286
PetscDrawClear_X(PetscDraw draw)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;
294
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)));
301
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 }
318
PetscDrawSetDoubleBuffer_X(PetscDraw draw)319 static PetscErrorCode PetscDrawSetDoubleBuffer_X(PetscDraw draw)
320 {
321 PetscDraw_X *win = (PetscDraw_X *)draw->data;
322 PetscMPIInt rank;
323
324 PetscFunctionBegin;
325 if (win->drw) PetscFunctionReturn(PETSC_SUCCESS);
326 PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
327
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 }
334
PetscDrawGetPopup_X(PetscDraw draw,PetscDraw * popup)335 static PetscErrorCode PetscDrawGetPopup_X(PetscDraw draw, PetscDraw *popup)
336 {
337 PetscDraw_X *win = (PetscDraw_X *)draw->data;
338 PetscBool flg = PETSC_TRUE;
339
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 }
346
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 }
354
PetscDrawSetTitle_X(PetscDraw draw,const char title[])355 static PetscErrorCode PetscDrawSetTitle_X(PetscDraw draw, const char title[])
356 {
357 PetscDraw_X *win = (PetscDraw_X *)draw->data;
358 PetscMPIInt rank;
359
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 }
377
PetscDrawCheckResizedWindow_X(PetscDraw draw)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;
383
384 PetscFunctionBegin;
385 if (!win->win) PetscFunctionReturn(PETSC_SUCCESS);
386 PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
387
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)));
392
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];
400
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 }
410
PetscDrawResizeWindow_X(PetscDraw draw,int w,int h)411 static PetscErrorCode PetscDrawResizeWindow_X(PetscDraw draw, int w, int h)
412 {
413 PetscDraw_X *win = (PetscDraw_X *)draw->data;
414 PetscMPIInt rank;
415
416 PetscFunctionBegin;
417 if (w == win->w && h == win->h) PetscFunctionReturn(PETSC_SUCCESS);
418 PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
419
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 }
438
439 #include <X11/cursorfont.h>
440
PetscDrawGetMouseButton_X(PetscDraw draw,PetscDrawButton * button,PetscReal * x_user,PetscReal * y_user,PetscReal * x_phys,PetscReal * y_phys)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;
452
453 PetscFunctionBegin;
454 *button = PETSC_BUTTON_NONE;
455 if (!win->win) PetscFunctionReturn(PETSC_SUCCESS);
456 PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)draw), &rank));
457
458 PetscDrawCollectiveBegin(draw);
459 if (rank) goto finally;
460
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);
478
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;
515
516 finally:
517 PetscDrawCollectiveEnd(draw);
518 PetscCall(PetscDrawCheckResizedWindow_X(draw));
519 PetscFunctionReturn(PETSC_SUCCESS);
520 }
521
PetscDrawSetVisible_X(PetscDraw draw,PetscBool visible)522 static PetscErrorCode PetscDrawSetVisible_X(PetscDraw draw, PetscBool visible)
523 {
524 PetscDraw_X *Xwin = (PetscDraw_X *)draw->data;
525 PetscMPIInt rank;
526
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 }
543
PetscDrawPause_X(PetscDraw draw)544 static PetscErrorCode PetscDrawPause_X(PetscDraw draw)
545 {
546 PetscDraw_X *win = (PetscDraw_X *)draw->data;
547
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 }
558
PetscDrawDestroy_X(PetscDraw draw)559 static PetscErrorCode PetscDrawDestroy_X(PetscDraw draw)
560 {
561 PetscDraw_X *win = (PetscDraw_X *)draw->data;
562
563 PetscFunctionBegin;
564 PetscCall(PetscDrawDestroy(&draw->popup));
565 PetscCall(PetscDrawXiClose(win));
566 PetscCall(PetscFree(draw->data));
567 PetscFunctionReturn(PETSC_SUCCESS);
568 }
569
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 *[]);
573
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};
575
PetscDrawGetSingleton_X(PetscDraw draw,PetscDraw * sdraw)576 static PetscErrorCode PetscDrawGetSingleton_X(PetscDraw draw, PetscDraw *sdraw)
577 {
578 PetscDraw_X *Xwin = (PetscDraw_X *)draw->data, *sXwin;
579
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;
584
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;
595
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 }
614
PetscDrawRestoreSingleton_X(PetscDraw draw,PetscDraw * sdraw)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 }
632
PetscDrawXGetDisplaySize_Private(const char name[],int * width,int * height,PetscBool * has_display)633 static PetscErrorCode PetscDrawXGetDisplaySize_Private(const char name[], int *width, int *height, PetscBool *has_display)
634 {
635 Display *display;
636
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 }
656
657 /*MC
658 PETSC_DRAW_X - PETSc graphics device that uses either X windows or its virtual version Xvfb
659
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)
668
669 Level: beginner
670
671 .seealso: `PetscDraw`, `PetscDrawOpenX()`, `PetscDrawSetDisplay()`, `PetscDrawSetFromOptions()`
672 M*/
673
PetscDrawCreate_X(PetscDraw draw)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;
684
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 }
691
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 }
702
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 }
748
749 PetscCall(PetscOptionsGetBool(((PetscObject)draw)->options, ((PetscObject)draw)->prefix, "-draw_virtual", &dvirtual, NULL));
750
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;
768
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.
773
774 +0,0-------------------------------------------+
775 | Region used so far +xavailable,yavailable |
776 | | |
777 | | |
778 +--------------------- +ybottom |
779 | |
780 | |
781 +----------------------------------------------+xmax,ymax
782
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 }
808
809 } /* endif (!dvirtual) */
810
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");
813
814 PetscCall(PetscNew(&Xwin));
815 draw->ops[0] = DvOps;
816 draw->data = (void *)Xwin;
817
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;
841
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 }
846