Actual source code: xops.c

petsc-3.7.3 2016-08-01
Report Typos and Errors
  1: /*
  2:     Defines the operations for the X PetscDraw implementation.
  3: */

  5: #include <../src/sys/classes/draw/impls/x/ximpl.h>         /*I  "petscsys.h" I*/

  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))


 19: static PetscErrorCode PetscDrawSetViewport_X(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr)
 20: {
 21:   PetscDraw_X    *XiWin = (PetscDraw_X*)draw->data;
 22:   int            xa,ya,xb,yb,xmax = XiWin->w-1,ymax = XiWin->h-1;
 23:   XRectangle     box;

 27:   xa = (int)(xl*xmax); ya = ymax - (int)(yr*ymax);
 28:   xb = (int)(xr*xmax); yb = ymax - (int)(yl*ymax);
 29:   PetscDrawCollectiveBegin(draw);
 30:   box.x = (short)xa; box.width  = (unsigned short)(xb + 1 - xa);
 31:   box.y = (short)ya; box.height = (unsigned short)(yb + 1 - ya);
 32:   XSetClipRectangles(XiWin->disp,XiWin->gc.set,0,0,&box,1,Unsorted);
 33:   PetscDrawCollectiveEnd(draw);
 34:   return(0);
 35: }

 39: static PetscErrorCode PetscDrawCoordinateToPixel_X(PetscDraw draw,PetscReal x,PetscReal y,int *i,int *j)
 40: {
 41:   PetscDraw_X *XiWin = (PetscDraw_X*)draw->data;

 44:   *i = XTRANS(draw,XiWin,x);
 45:   *j = YTRANS(draw,XiWin,y);
 46:   return(0);
 47: }

 51: static PetscErrorCode PetscDrawPixelToCoordinate_X(PetscDraw draw,int i,int j,PetscReal *x,PetscReal *y)
 52: {
 53:   PetscDraw_X *XiWin = (PetscDraw_X*)draw->data;

 56:   *x = ITRANS(draw,XiWin,i);
 57:   *y = JTRANS(draw,XiWin,j);
 58:   return(0);
 59: }

 63: static PetscErrorCode PetscDrawPoint_X(PetscDraw draw,PetscReal x,PetscReal y,int c)
 64: {
 65:   PetscDraw_X *XiWin = (PetscDraw_X*)draw->data;
 66:   int         xx,yy,i,j;

 69:   xx = XTRANS(draw,XiWin,x);
 70:   yy = YTRANS(draw,XiWin,y);
 71:   PetscDrawXiSetColor(XiWin,c);
 72:   for (i=-1; i<2; i++) {
 73:     for (j=-1; j<2; j++) {
 74:       XDrawPoint(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,xx+i,yy+j);
 75:     }
 76:   }
 77:   return(0);
 78: }

 82: static PetscErrorCode PetscDrawPointPixel_X(PetscDraw draw,int x,int y,int c)
 83: {
 84:   PetscDraw_X *XiWin = (PetscDraw_X*)draw->data;

 87:   PetscDrawXiSetColor(XiWin,c);
 88:   XDrawPoint(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x,y);
 89:   return(0);
 90: }

 94: static PetscErrorCode PetscDrawLine_X(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int cl)
 95: {
 96:   PetscDraw_X *XiWin = (PetscDraw_X*)draw->data;
 97:   int         x_1,y_1,x_2,y_2;

100:   PetscDrawXiSetColor(XiWin,cl);
101:   x_1 = XTRANS(draw,XiWin,xl); x_2  = XTRANS(draw,XiWin,xr);
102:   y_1 = YTRANS(draw,XiWin,yl); y_2  = YTRANS(draw,XiWin,yr);
103:   XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_1,y_1,x_2,y_2);
104:   return(0);
105: }

109: static PetscErrorCode PetscDrawArrow_X(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int cl)
110: {
111:   PetscDraw_X *XiWin = (PetscDraw_X*)draw->data;
112:   int         x_1,y_1,x_2,y_2;

115:   PetscDrawXiSetColor(XiWin,cl);
116:   x_1 = XTRANS(draw,XiWin,xl); x_2 = XTRANS(draw,XiWin,xr);
117:   y_1 = YTRANS(draw,XiWin,yl); y_2 = YTRANS(draw,XiWin,yr);
118:   XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_1,y_1,x_2,y_2);
119:   if (x_1 == x_2 && y_1 == y_2) return(0);
120:   if (x_1 == x_2 && PetscAbs(y_1 - y_2) > 7) {
121:     if (y_2 > y_1) {
122:       XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_2,y_2,x_2-3,y_2-3);
123:       XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_2,y_2,x_2+3,y_2-3);
124:     } else {
125:       XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_2,y_2,x_2-3,y_2+3);
126:       XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_2,y_2,x_2+3,y_2+3);
127:     }
128:   }
129:   if (y_1 == y_2 && PetscAbs(x_1 - x_2) > 7) {
130:     if (x_2 > x_1) {
131:       XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_2-3,y_2-3,x_2,y_2);
132:       XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_2-3,y_2+3,x_2,y_2);
133:     } else {
134:       XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_2,y_2,x_2+3,y_2-3);
135:       XDrawLine(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x_2,y_2,x_2+3,y_2+3);
136:     }
137:   }
138:   return(0);
139: }

143: static PetscErrorCode PetscDrawRectangle_X(PetscDraw draw,PetscReal xl,PetscReal yl,PetscReal xr,PetscReal yr,int c1,int c2,int c3,int c4)
144: {
145:   PetscDraw_X *XiWin = (PetscDraw_X*)draw->data;
146:   int         x,y,w,h,c = (c1 + c2 + c3 + c4)/4;

149:   PetscDrawXiSetColor(XiWin,c);
150:   x = XTRANS(draw,XiWin,xl); w = XTRANS(draw,XiWin,xr) + 1 - x; if (w <= 0) w = 1;
151:   y = YTRANS(draw,XiWin,yr); h = YTRANS(draw,XiWin,yl) + 1 - y; if (h <= 0) h = 1;
152:   XFillRectangle(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,x,y,w,h);
153:   return(0);
154: }

158: static PetscErrorCode PetscDrawEllipse_X(PetscDraw draw,PetscReal x,PetscReal y,PetscReal a,PetscReal b,int c)
159: {
160:   PetscDraw_X *XiWin = (PetscDraw_X*)draw->data;
161:   int         xA,yA,w,h;

164:   PetscDrawXiSetColor(XiWin, c);
165:   xA = XTRANS(draw,XiWin, x - a/2); w = XTRANS(draw,XiWin, x + a/2) + 1 - xA; w = PetscAbs(w);
166:   yA = YTRANS(draw,XiWin, y + b/2); h = YTRANS(draw,XiWin, y - b/2) + 1 - yA; h = PetscAbs(h);
167:   XFillArc(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,xA,yA,w,h,0,360*64);
168:   return(0);
169: }

171: PETSC_INTERN PetscErrorCode PetscDrawInterpolatedTriangle_X(PetscDraw_X*,int,int,int,int,int,int,int,int,int);

175: 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)
176: {
177:   PetscDraw_X    *XiWin = (PetscDraw_X*)draw->data;

181:   if (c1 == c2 && c2 == c3) {
182:     XPoint pt[3];
183:     PetscDrawXiSetColor(XiWin,c1);
184:     pt[0].x = XTRANS(draw,XiWin,X1);
185:     pt[0].y = YTRANS(draw,XiWin,Y_1);
186:     pt[1].x = XTRANS(draw,XiWin,X2);
187:     pt[1].y = YTRANS(draw,XiWin,Y2);
188:     pt[2].x = XTRANS(draw,XiWin,X3);
189:     pt[2].y = YTRANS(draw,XiWin,Y3);
190:     XFillPolygon(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,pt,3,Convex,CoordModeOrigin);
191:   } else {
192:     int x1,y_1,x2,y2,x3,y3;
193:     x1   = XTRANS(draw,XiWin,X1);
194:     y_1  = YTRANS(draw,XiWin,Y_1);
195:     x2   = XTRANS(draw,XiWin,X2);
196:     y2   = YTRANS(draw,XiWin,Y2);
197:     x3   = XTRANS(draw,XiWin,X3);
198:     y3   = YTRANS(draw,XiWin,Y3);
199:     PetscDrawInterpolatedTriangle_X(XiWin,x1,y_1,c1,x2,y2,c2,x3,y3,c3);
200:   }
201:   return(0);
202: }

206: static PetscErrorCode PetscDrawStringSetSize_X(PetscDraw draw,PetscReal x,PetscReal y)
207: {
208:   PetscDraw_X    *XiWin = (PetscDraw_X*)draw->data;
209:   int            w,h;

213:   w    = (int)((XiWin->w)*x*(draw->port_xr - draw->port_xl)/(draw->coor_xr - draw->coor_xl));
214:   h    = (int)((XiWin->h)*y*(draw->port_yr - draw->port_yl)/(draw->coor_yr - draw->coor_yl));
215:   PetscFree(XiWin->font);
216:   PetscDrawXiFontFixed(XiWin,w,h,&XiWin->font);
217:   return(0);
218: }

222: static PetscErrorCode PetscDrawStringGetSize_X(PetscDraw draw,PetscReal *x,PetscReal  *y)
223: {
224:   PetscDraw_X *XiWin = (PetscDraw_X*)draw->data;
225:   PetscReal   w,h;

228:   w = XiWin->font->font_w; h = XiWin->font->font_h;
229:   if (x) *x = w*(draw->coor_xr - draw->coor_xl)/((XiWin->w)*(draw->port_xr - draw->port_xl));
230:   if (y) *y = h*(draw->coor_yr - draw->coor_yl)/((XiWin->h)*(draw->port_yr - draw->port_yl));
231:   return(0);
232: }

236: static PetscErrorCode PetscDrawString_X(PetscDraw draw,PetscReal x,PetscReal y,int c,const char chrs[])
237: {
238:   PetscDraw_X    *XiWin = (PetscDraw_X*)draw->data;
239:   int            xx,yy,descent = XiWin->font->font_descent;
240:   size_t         len;
241:   char           *substr;
242:   PetscToken     token;

246:   xx = XTRANS(draw,XiWin,x);
247:   yy = YTRANS(draw,XiWin,y);
248:   PetscDrawXiSetColor(XiWin,c);

250:   PetscTokenCreate(chrs,'\n',&token);
251:   PetscTokenFind(token,&substr);
252:   while (substr) {
253:     PetscStrlen(substr,&len);
254:     XDrawString(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,xx,yy-descent,substr,len);
255:     yy  += XiWin->font->font_h;
256:     PetscTokenFind(token,&substr);
257:   }
258:   PetscTokenDestroy(&token);
259:   return(0);
260: }

264: static PetscErrorCode PetscDrawStringVertical_X(PetscDraw draw,PetscReal x,PetscReal y,int c,const char text[])
265: {
266:   PetscDraw_X    *XiWin = (PetscDraw_X*)draw->data;
267:   int            xx,yy,offset = XiWin->font->font_h - XiWin->font->font_descent;
268:   char           chr[2] = {0, 0};

271:   xx = XTRANS(draw,XiWin,x);
272:   yy = YTRANS(draw,XiWin,y);
273:   PetscDrawXiSetColor(XiWin,c);
274:   while ((chr[0] = *text++)) {
275:     XDrawString(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,xx,yy+offset,chr,1);
276:     yy += XiWin->font->font_h;
277:   }
278:   return(0);
279: }

283: static PetscErrorCode PetscDrawFlush_X(PetscDraw draw)
284: {
285:   PetscDraw_X    *XiWin = (PetscDraw_X*)draw->data;
286:   PetscMPIInt    rank;

290:   /* make sure the X server processed requests from all processes */
291:   PetscDrawCollectiveBegin(draw);
292:   XSync(XiWin->disp,False);
293:   PetscDrawCollectiveEnd(draw);
294:   MPI_Barrier(PetscObjectComm((PetscObject)draw));

296:   /* transfer pixmap contents to window (only the first process does this) */
297:   if (XiWin->drw && XiWin->win) {
298:     MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);
299:     PetscDrawCollectiveBegin(draw);
300:     if (!rank) XCopyArea(XiWin->disp,XiWin->drw,XiWin->win,XiWin->gc.set,0,0,XiWin->w,XiWin->h,0,0);
301:     if (!rank) XSync(XiWin->disp,False);
302:     PetscDrawCollectiveEnd(draw);
303:     MPI_Barrier(PetscObjectComm((PetscObject)draw));
304:   }
305:   return(0);
306: }

310: static PetscErrorCode PetscDrawClear_X(PetscDraw draw)
311: {
312:   PetscDraw_X    *XiWin = (PetscDraw_X*)draw->data;
313:   int            xmax = XiWin->w-1,  ymax = XiWin->h-1;
314:   PetscReal      xl = draw->port_xl, yl = draw->port_yl;
315:   PetscReal      xr = draw->port_xr, yr = draw->port_yr;
316:   PetscMPIInt    rank;

320:   /* make sure the X server processed requests from all processes */
321:   PetscDrawCollectiveBegin(draw);
322:   XSync(XiWin->disp,False);
323:   PetscDrawCollectiveEnd(draw);
324:   MPI_Barrier(PetscObjectComm((PetscObject)draw));

326:   /* only the first process handles the clearing business */
327:   PetscDrawCollectiveBegin(draw);
328:   MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);
329:   if (!rank) {
330:     int xa = (int)(xl*xmax), ya = ymax - (int)(yr*ymax);
331:     int xb = (int)(xr*xmax), yb = ymax - (int)(yl*ymax);
332:     unsigned int w = (unsigned int)(xb + 1 - xa);
333:     unsigned int h = (unsigned int)(yb + 1 - ya);
334:     PetscDrawXiSetPixVal(XiWin,XiWin->background);
335:     XFillRectangle(XiWin->disp,PetscDrawXiDrawable(XiWin),XiWin->gc.set,xa,ya,w,h);
336:     XSync(XiWin->disp,False);
337:   }
338:   PetscDrawCollectiveEnd(draw);
339:   MPI_Barrier(PetscObjectComm((PetscObject)draw));
340:   return(0);
341: }

345: static PetscErrorCode PetscDrawSetDoubleBuffer_X(PetscDraw draw)
346: {
347:   PetscDraw_X    *win = (PetscDraw_X*)draw->data;
348:   PetscMPIInt    rank;

352:   if (win->drw) return(0);
353:   MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);

355:   PetscDrawCollectiveBegin(draw);
356:   if (!rank) {PetscDrawXiQuickPixmap(win);}
357:   PetscDrawCollectiveEnd(draw);
358:   MPI_Bcast(&win->drw,1,MPI_UNSIGNED_LONG,0,PetscObjectComm((PetscObject)draw));
359:   return(0);
360: }

364: static PetscErrorCode PetscDrawGetPopup_X(PetscDraw draw,PetscDraw *popup)
365: {
366:   PetscDraw_X    *win = (PetscDraw_X*)draw->data;
367:   PetscBool      flg  = PETSC_TRUE;

371:   PetscOptionsGetBool(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-draw_popup",&flg,NULL);
372:   if (!flg || !win->win) {*popup = NULL; return(0);}

374:   PetscDrawCreate(PetscObjectComm((PetscObject)draw),draw->display,NULL,win->x,win->y+win->h+10,220,220,popup);
375:   PetscObjectSetOptionsPrefix((PetscObject)*popup,"popup_");
376:   PetscObjectAppendOptionsPrefix((PetscObject)*popup,((PetscObject)draw)->prefix);
377:   PetscDrawSetType(*popup,PETSC_DRAW_X);
378:   draw->popup = *popup;
379:   return(0);
380: }

384: static PetscErrorCode PetscDrawSetTitle_X(PetscDraw draw,const char title[])
385: {
386:   PetscDraw_X    *win = (PetscDraw_X*)draw->data;
387:   PetscMPIInt    rank;

391:   if (!win->win) return(0);
392:   MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);
393:   PetscDrawCollectiveBegin(draw);
394:   if (!rank) {
395:     size_t        len;
396:     XTextProperty prop;
397:     PetscStrlen(title,&len);
398:     XGetWMName(win->disp,win->win,&prop);
399:     XFree((void*)prop.value);
400:     prop.value  = (unsigned char*)title;
401:     prop.nitems = (long)len;
402:     XSetWMName(win->disp,win->win,&prop);
403:   }
404:   PetscDrawCollectiveEnd(draw);
405:   return(0);
406: }

410: static PetscErrorCode PetscDrawCheckResizedWindow_X(PetscDraw draw)
411: {
412:   PetscDraw_X    *win = (PetscDraw_X*)draw->data;
413:   int            xywh[4];
414:   PetscMPIInt    rank;

418:   if (!win->win) return(0);
419:   MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);

421:   PetscDrawCollectiveBegin(draw);
422:   if (!rank) {PetscDrawXiGetGeometry(win,xywh,xywh+1,xywh+2,xywh+3);}
423:   PetscDrawCollectiveEnd(draw);
424:   MPI_Bcast(xywh,4,MPI_INT,0,PetscObjectComm((PetscObject)draw));

426:   /* record new window position */
427:   draw->x = win->x = xywh[0];
428:   draw->y = win->y = xywh[1];
429:   if (xywh[2] == win->w && xywh[3] == win->h) return(0);
430:   /* record new window sizes */
431:   draw->w = win->w = xywh[2];
432:   draw->h = win->h = xywh[3];

434:   /* recreate pixmap (only first processor does this) */
435:   PetscDrawCollectiveBegin(draw);
436:   if (!rank && win->drw) {PetscDrawXiQuickPixmap(win);}
437:   PetscDrawCollectiveEnd(draw);
438:   MPI_Bcast(&win->drw,1,MPI_UNSIGNED_LONG,0,PetscObjectComm((PetscObject)draw));
439:   /* reset the clipping */
440:   PetscDrawSetViewport_X(draw,draw->port_xl,draw->port_yl,draw->port_xr,draw->port_yr);
441:   return(0);
442: }

446: static PetscErrorCode PetscDrawResizeWindow_X(PetscDraw draw,int w,int h)
447: {
448:   PetscDraw_X    *win = (PetscDraw_X*)draw->data;
449:   PetscMPIInt    rank;

453:   if (w == win->w && h == win->h) return(0);
454:   MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);

456:   if (win->win) {
457:     PetscDrawCollectiveBegin(draw);
458:     if (!rank) {PetscDrawXiResizeWindow(win,w,h);}
459:     PetscDrawCollectiveEnd(draw);
460:     PetscDrawCheckResizedWindow_X(draw);
461:   } else if (win->drw) {
462:     draw->w = win->w = w; draw->h = win->h = h;
463:     /* recreate pixmap (only first processor does this) */
464:     PetscDrawCollectiveBegin(draw);
465:     if (!rank) {PetscDrawXiQuickPixmap(win);}
466:     MPI_Bcast(&win->drw,1,MPI_UNSIGNED_LONG,0,PetscObjectComm((PetscObject)draw));
467:     /* reset the clipping */
468:     PetscDrawCollectiveEnd(draw);
469:     PetscDrawSetViewport_X(draw,draw->port_xl,draw->port_yl,draw->port_xr,draw->port_yr);
470:   }
471:   return(0);
472: }

474: #include <X11/cursorfont.h>

478: static PetscErrorCode PetscDrawGetMouseButton_X(PetscDraw draw,PetscDrawButton *button,PetscReal *x_user,PetscReal *y_user,PetscReal *x_phys,PetscReal *y_phys)
479: {
480:   PetscDraw_X    *win = (PetscDraw_X*)draw->data;
481:   Cursor         cursor;
482:   XEvent         report;
483:   Window         root,child;
484:   int            root_x,root_y,px=0,py=0;
485:   unsigned int   w,h,border,depth;
486:   unsigned int   keys_button;
487:   PetscMPIInt    rank;
488:   PetscReal      xx,yy;

492:   *button = PETSC_BUTTON_NONE;
493:   if (!win->win) return(0);
494:   MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);

496:   PetscDrawCollectiveBegin(draw);
497:   if (rank) goto finally;

499:   /* change cursor to indicate input */
500:   cursor = XCreateFontCursor(win->disp,XC_hand2); if (!cursor) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"Unable to create X cursor");
501:   XDefineCursor(win->disp,win->win,cursor);
502:   /* wait for mouse button events */
503:   XSelectInput(win->disp,win->win,ButtonPressMask|ButtonReleaseMask);
504:   while (XCheckTypedEvent(win->disp,ButtonPress,&report));
505:   XMaskEvent(win->disp,ButtonReleaseMask,&report);
506:   /* get mouse pointer coordinates */
507:   XQueryPointer(win->disp,report.xmotion.window,&root,&child,&root_x,&root_y,&px,&py,&keys_button);
508:   /* the user may resize the window before pressing the mouse button */
509:   XGetGeometry(win->disp,win->win,&root,&root_x,&root_y,&w,&h,&border,&depth);
510:   /* cleanup input event handler and cursor  */
511:   XSelectInput(win->disp,win->win,NoEventMask);
512:   XUndefineCursor(win->disp,win->win);
513:   XFreeCursor(win->disp, cursor);
514:   XSync(win->disp,False);

516:   switch (report.xbutton.button) {
517:   case Button1: *button = PETSC_BUTTON_LEFT; break;
518:   case Button2: *button = PETSC_BUTTON_CENTER; break;
519:   case Button3: *button = PETSC_BUTTON_RIGHT; break;
520:   case Button4: *button = PETSC_BUTTON_WHEEL_UP; break;
521:   case Button5: *button = PETSC_BUTTON_WHEEL_DOWN; break;
522:   }
523:   if (report.xbutton.state & ShiftMask) {
524:     switch (report.xbutton.button) {
525:     case Button1: *button = PETSC_BUTTON_LEFT_SHIFT; break;
526:     case Button2: *button = PETSC_BUTTON_CENTER_SHIFT; break;
527:     case Button3: *button = PETSC_BUTTON_RIGHT_SHIFT; break;
528:     }
529:   }
530:   xx = ((PetscReal)px)/w;
531:   yy = 1 - ((PetscReal)py)/h;
532:   if (x_user) *x_user = draw->coor_xl + (xx - draw->port_xl)*(draw->coor_xr - draw->coor_xl)/(draw->port_xr - draw->port_xl);
533:   if (y_user) *y_user = draw->coor_yl + (yy - draw->port_yl)*(draw->coor_yr - draw->coor_yl)/(draw->port_yr - draw->port_yl);
534:   if (x_phys) *x_phys = xx;
535:   if (y_phys) *y_phys = yy;

537: finally:
538:   PetscDrawCollectiveEnd(draw);
539:   PetscDrawCheckResizedWindow_X(draw);
540:   return(0);
541: }

545: static PetscErrorCode PetscDrawPause_X(PetscDraw draw)
546: {
547:   PetscDraw_X    *win = (PetscDraw_X*)draw->data;

551:   if (!win->win) return(0);
552:   if (draw->pause > 0) PetscSleep(draw->pause);
553:   else if (draw->pause == -1) {
554:     PetscDrawButton button = PETSC_BUTTON_NONE;
555:     PetscDrawGetMouseButton(draw,&button,NULL,NULL,NULL,NULL);
556:     if (button == PETSC_BUTTON_CENTER) draw->pause = 0;
557:   }
558:   return(0);
559: }

563: static PetscErrorCode PetscDrawDestroy_X(PetscDraw draw)
564: {
565:   PetscDraw_X    *win = (PetscDraw_X*)draw->data;

569:   PetscDrawDestroy(&draw->popup);
570:   PetscDrawXiClose(win);
571:   PetscFree(draw->data);
572:   return(0);
573: }

575: static       PetscErrorCode PetscDrawGetSingleton_X(PetscDraw,PetscDraw*);
576: static       PetscErrorCode PetscDrawRestoreSingleton_X(PetscDraw,PetscDraw*);
577: PETSC_INTERN PetscErrorCode PetscDrawGetImage_X(PetscDraw,unsigned char[][3],unsigned int*,unsigned int*,unsigned char*[]);

579: static struct _PetscDrawOps DvOps = { PetscDrawSetDoubleBuffer_X,
580:                                       PetscDrawFlush_X,
581:                                       PetscDrawLine_X,
582:                                       0,
583:                                       0,
584:                                       PetscDrawPoint_X,
585:                                       0,
586:                                       PetscDrawString_X,
587:                                       PetscDrawStringVertical_X,
588:                                       PetscDrawStringSetSize_X,
589:                                       PetscDrawStringGetSize_X,
590:                                       PetscDrawSetViewport_X,
591:                                       PetscDrawClear_X,
592:                                       PetscDrawRectangle_X,
593:                                       PetscDrawTriangle_X,
594:                                       PetscDrawEllipse_X,
595:                                       PetscDrawGetMouseButton_X,
596:                                       PetscDrawPause_X,
597:                                       0,
598:                                       0,
599:                                       PetscDrawGetPopup_X,
600:                                       PetscDrawSetTitle_X,
601:                                       PetscDrawCheckResizedWindow_X,
602:                                       PetscDrawResizeWindow_X,
603:                                       PetscDrawDestroy_X,
604:                                       0,
605:                                       PetscDrawGetSingleton_X,
606:                                       PetscDrawRestoreSingleton_X,
607:                                       0,
608:                                       PetscDrawGetImage_X,
609:                                       0,
610:                                       PetscDrawArrow_X,
611:                                       PetscDrawCoordinateToPixel_X,
612:                                       PetscDrawPixelToCoordinate_X,
613:                                       PetscDrawPointPixel_X,
614:                                       0};


619: static PetscErrorCode PetscDrawGetSingleton_X(PetscDraw draw,PetscDraw *sdraw)
620: {
621:   PetscDraw_X    *Xwin = (PetscDraw_X*)draw->data,*sXwin;

625:   PetscDrawCreate(PETSC_COMM_SELF,draw->display,draw->title,draw->x,draw->y,draw->w,draw->h,sdraw);
626:   PetscObjectChangeTypeName((PetscObject)*sdraw,PETSC_DRAW_X);
627:   PetscMemcpy((*sdraw)->ops,&DvOps,sizeof(DvOps));

629:   if (draw->popup) {
630:     PetscDrawGetSingleton(draw->popup,&(*sdraw)->popup);
631:   }
632:   (*sdraw)->pause   = draw->pause;
633:   (*sdraw)->coor_xl = draw->coor_xl;
634:   (*sdraw)->coor_xr = draw->coor_xr;
635:   (*sdraw)->coor_yl = draw->coor_yl;
636:   (*sdraw)->coor_yr = draw->coor_yr;
637:   (*sdraw)->port_xl = draw->port_xl;
638:   (*sdraw)->port_xr = draw->port_xr;
639:   (*sdraw)->port_yl = draw->port_yl;
640:   (*sdraw)->port_yr = draw->port_yr;

642:   /* share drawables (windows and/or pixmap) from the parent draw */
643:   PetscNewLog(*sdraw,&sXwin);
644:   (*sdraw)->data = (void*)sXwin;
645:   PetscDrawXiInit(sXwin,draw->display);
646:   if (Xwin->win) {
647:     PetscDrawXiQuickWindowFromWindow(sXwin,Xwin->win);
648:     sXwin->drw = Xwin->drw; /* XXX If the window is ever resized, this is wrong! */
649:   } else if (Xwin->drw) {
650:     PetscDrawXiColormap(sXwin);
651:     sXwin->drw = Xwin->drw;
652:   }
653:   PetscDrawXiGetGeometry(sXwin,&sXwin->x,&sXwin->y,&sXwin->w,&sXwin->h);
654:   (*sdraw)->x = sXwin->x; (*sdraw)->y = sXwin->y;
655:   (*sdraw)->w = sXwin->w; (*sdraw)->h = sXwin->h;
656:   return(0);
657: }

661: static PetscErrorCode PetscDrawRestoreSingleton_X(PetscDraw draw,PetscDraw *sdraw)
662: {

666:   if (draw->popup && (*sdraw)->popup) {
667:     PetscBool isdrawx;
668:     PetscDraw_X *pXwin = (PetscDraw_X*)draw->popup->data;
669:     PetscDraw_X *sXwin = (PetscDraw_X*)(*sdraw)->popup->data;
670:     PetscObjectTypeCompare((PetscObject)draw->popup,PETSC_DRAW_X,&isdrawx);
671:     if (!isdrawx) goto finally;
672:     PetscObjectTypeCompare((PetscObject)(*sdraw)->popup,PETSC_DRAW_X,&isdrawx);
673:     if (!isdrawx) goto finally;
674:     if (sXwin->win == pXwin->win) {
675:       PetscDrawRestoreSingleton(draw->popup,&(*sdraw)->popup);
676:     }
677:   }
678: finally:
679:   PetscDrawDestroy(sdraw);
680:   return(0);
681: }

685: static PetscErrorCode PetscDrawXGetDisplaySize_Private(const char name[],int *width,int *height)
686: {
687:   Display *display;

690:   display = XOpenDisplay(name);
691:   if (!display) {
692:     *width  = *height = 0;
693:     SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"Unable to open display on %s\n\
694:     Make sure your COMPUTE NODES are authorized to connect\n\
695:     to this X server and either your DISPLAY variable\n\
696:     is set or you use the -display name option\n",name);
697:   }
698:   *width  = (int)DisplayWidth(display,DefaultScreen(display));
699:   *height = (int)DisplayHeight(display,DefaultScreen(display));
700:   XCloseDisplay(display);
701:   return(0);
702: }

704: /*MC
705:      PETSC_DRAW_X  - PETSc graphics device that uses either X windows or its virtual version Xvfb

707:    Options Database Keys:
708: +  -display <display> - sets the display to use
709: .  -x_virtual - forces use of a X virtual display Xvfb that will not display anything but -draw_save will still work.
710:                 Xvfb is automatically started up in PetscSetDisplay() with this option
711: .  -draw_size w,h - percentage of screeen (either 1, .5, .3, .25), or size in pixels
712: .  -geometry x,y,w,h - set location and size in pixels
713: .  -draw_virtual - do not open a window (draw on a pixmap), -draw_save will still work
714: -  -draw_double_buffer - avoid window flickering (draw on pixmap and flush to window)

716:    Level: beginner

718: .seealso:  PetscDrawOpenX(), PetscDrawSetDisplay(), PetscDrawSetFromOptions()

720: M*/

724: PETSC_EXTERN PetscErrorCode PetscDrawCreate_X(PetscDraw draw)
725: {
726:   PetscDraw_X    *Xwin;
728:   PetscMPIInt    rank;
729:   int            x = draw->x,y = draw->y,w = draw->w,h = draw->h;
730:   static int     xavailable = 0,yavailable = 0,ybottom = 0,xmax = 0,ymax = 0;
731:   PetscBool      set,dvirtual = PETSC_FALSE,doublebuffer = PETSC_TRUE;
732:   PetscInt       xywh[4],osize = 4,nsizes=2;
733:   PetscReal      sizes[2] = {.3,.3};

736:   /* get the display variable */
737:   if (!draw->display) {
738:     PetscMalloc1(256,&draw->display);
739:     PetscGetDisplay(draw->display,256);
740:   }

742:   /* initialize the display size */
743:   if (!xmax) {
744:     PetscDrawXGetDisplaySize_Private(draw->display,&xmax,&ymax);
745:     /* if some processors fail on this and others succed then this is a problem ! */
746:     if (ierr) {
747:       (*PetscErrorPrintf)("PETSc unable to use X windows\nproceeding without graphics\n");
748:       PetscDrawSetType(draw,PETSC_DRAW_NULL);
749:       return(0);
750:     }
751:   }

753:   /* allow user to set size of drawable */
754:   PetscOptionsGetRealArray(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-draw_size",sizes,&nsizes,&set);
755:   if (set && nsizes == 1 && sizes[0] > 1.0) sizes[1] = sizes[0];
756:   if (set) {
757:     if (sizes[0] > 1.0)       w = (int)sizes[0];
758:     else if (sizes[0] == 1.0) w = PETSC_DRAW_FULL_SIZE;
759:     else if (sizes[0] == .5)  w = PETSC_DRAW_HALF_SIZE;
760:     else if (sizes[0] == .3)  w = PETSC_DRAW_THIRD_SIZE;
761:     else if (sizes[0] == .25) w = PETSC_DRAW_QUARTER_SIZE;
762:     if (sizes[1] > 1.0)       h = (int)sizes[1];
763:     else if (sizes[1] == 1.0) h = PETSC_DRAW_FULL_SIZE;
764:     else if (sizes[1] == .5)  h = PETSC_DRAW_HALF_SIZE;
765:     else if (sizes[1] == .3)  h = PETSC_DRAW_THIRD_SIZE;
766:     else if (sizes[1] == .25) h = PETSC_DRAW_QUARTER_SIZE;
767:   }
768:   if (w == PETSC_DECIDE || w == PETSC_DEFAULT) w = draw->w = 300;
769:   if (h == PETSC_DECIDE || h == PETSC_DEFAULT) h = draw->h = 300;
770:   switch (w) {
771:   case PETSC_DRAW_FULL_SIZE:    w = draw->w = (xmax - 10);   break;
772:   case PETSC_DRAW_HALF_SIZE:    w = draw->w = (xmax - 20)/2; break;
773:   case PETSC_DRAW_THIRD_SIZE:   w = draw->w = (xmax - 30)/3; break;
774:   case PETSC_DRAW_QUARTER_SIZE: w = draw->w = (xmax - 40)/4; break;
775:   }
776:   switch (h) {
777:   case PETSC_DRAW_FULL_SIZE:    h = draw->h = (ymax - 10);   break;
778:   case PETSC_DRAW_HALF_SIZE:    h = draw->h = (ymax - 20)/2; break;
779:   case PETSC_DRAW_THIRD_SIZE:   h = draw->h = (ymax - 30)/3; break;
780:   case PETSC_DRAW_QUARTER_SIZE: h = draw->h = (ymax - 40)/4; break;
781:   }

783:   PetscOptionsGetBool(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-draw_virtual",&dvirtual,NULL);

785:   if (!dvirtual) {

787:     /* allow user to set location and size of window */
788:     xywh[0] = x; xywh[1] = y; xywh[2] = w; xywh[3] = h;
789:     PetscOptionsGetIntArray(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-geometry",xywh,&osize,NULL);
790:     x = (int)xywh[0]; y = (int)xywh[1]; w = (int)xywh[2]; h = (int)xywh[3];
791:     if (w == PETSC_DECIDE || w == PETSC_DEFAULT) w = 300;
792:     if (h == PETSC_DECIDE || h == PETSC_DEFAULT) h = 300;
793:     draw->x = x; draw->y = y; draw->w = w; draw->h = h;

795:     if (draw->x == PETSC_DECIDE || draw->y == PETSC_DECIDE) {
796:       /*
797:        PETSc tries to place windows starting in the upper left corner
798:         and moving across to the right.

800:        +0,0-------------------------------------------+
801:        |  Region used so far  +xavailable,yavailable  |
802:        |                      |                       |
803:        |                      |                       |
804:        +--------------------- +ybottom                |
805:        |                                              |
806:        |                                              |
807:        +----------------------------------------------+xmax,ymax

809:       */
810:       /*  First: can we add it to the right? */
811:       if (xavailable + w + 10 <= xmax) {
812:         x       = xavailable;
813:         y       = yavailable;
814:         ybottom = PetscMax(ybottom,y + h + 30);
815:       } else {
816:         /* No, so add it below on the left */
817:         xavailable = x = 0;
818:         yavailable = y = ybottom;
819:         ybottom    = ybottom + h + 30;
820:       }
821:     }
822:     /* update available region */
823:     xavailable = PetscMax(xavailable,x + w + 10);
824:     if (xavailable >= xmax) {
825:       xavailable = 0;
826:       yavailable = yavailable + h + 30;
827:       ybottom    = yavailable;
828:     }
829:     if (yavailable >= ymax) {
830:       y          = 0;
831:       yavailable = 0;
832:       ybottom    = 0;
833:     }

835:   } /* endif(!dvirtual) */

837:   MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);
838:   if (!rank && (w <= 0 || h <= 0)) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Negative window width or height");

840:   PetscNewLog(draw,&Xwin);
841:   PetscMemcpy(draw->ops,&DvOps,sizeof(DvOps));
842:   draw->data = (void*)Xwin;

844:   PetscDrawXiInit(Xwin,draw->display);
845:   if (!dvirtual) {
846:     Xwin->x = x; Xwin->y = y;
847:     Xwin->w = w; Xwin->h = h;
848:     if (!rank) {PetscDrawXiQuickWindow(Xwin,draw->title,x,y,w,h);}
849:     MPI_Bcast(&Xwin->win,1,MPI_UNSIGNED_LONG,0,PetscObjectComm((PetscObject)draw));
850:     if (rank) {PetscDrawXiQuickWindowFromWindow(Xwin,Xwin->win);}
851:   } else {
852:     Xwin->x = 0; Xwin->y = 0;
853:     Xwin->w = w; Xwin->h = h;
854:     PetscDrawXiColormap(Xwin);
855:     if (!rank) {PetscDrawXiQuickPixmap(Xwin);}
856:     MPI_Bcast(&Xwin->drw,1,MPI_UNSIGNED_LONG,0,PetscObjectComm((PetscObject)draw));
857:   }
858:   PetscDrawXiGetGeometry(Xwin,&Xwin->x,&Xwin->y,&Xwin->w,&Xwin->h);
859:   draw->x = Xwin->x; draw->y = Xwin->y;
860:   draw->w = Xwin->w; draw->h = Xwin->h;

862:   PetscOptionsGetBool(((PetscObject)draw)->options,((PetscObject)draw)->prefix,"-draw_double_buffer",&doublebuffer,NULL);
863:   if (doublebuffer) {PetscDrawSetDoubleBuffer(draw);}
864:   return(0);
865: }