Actual source code: draw.c

petsc-3.4.4 2014-03-13
  2: /*
  3:        Provides the calling sequences for all the basic PetscDraw routines.
  4: */
  5: #include <petsc-private/drawimpl.h>  /*I "petscdraw.h" I*/
  6: #include <petscviewer.h>

  8: PetscClassId PETSC_DRAW_CLASSID;

 10: static PetscBool PetscDrawPackageInitialized = PETSC_FALSE;
 13: /*@C
 14:   PetscDrawFinalizePackage - This function destroys everything in the Petsc interface to the Draw package. It is
 15:   called from PetscFinalize().

 17:   Level: developer

 19: .keywords: Petsc, destroy, package, mathematica
 20: .seealso: PetscFinalize()
 21: @*/
 22: PetscErrorCode  PetscDrawFinalizePackage(void)
 23: {

 27:   PetscFunctionListDestroy(&PetscDrawList);
 28:   PetscDrawPackageInitialized = PETSC_FALSE;
 29:   return(0);
 30: }

 34: /*@C
 35:   PetscInitializeDrawPackage - This function initializes everything in the PetscDraw package. It is called
 36:   from PetscDLLibraryRegister() when using dynamic libraries, and on the call to PetscInitialize()
 37:   when using static libraries.

 39:   Level: developer

 41: .keywords: Petsc, initialize, package
 42: .seealso: PetscInitialize()
 43: @*/
 44: PetscErrorCode  PetscDrawInitializePackage(void)
 45: {
 46:   char           logList[256];
 47:   char           *className;
 48:   PetscBool      opt;

 52:   if (PetscDrawPackageInitialized) return(0);
 53:   PetscDrawPackageInitialized = PETSC_TRUE;
 54:   /* Register Classes */
 55:   PetscClassIdRegister("Draw",&PETSC_DRAW_CLASSID);
 56:   PetscClassIdRegister("Axis",&PETSC_DRAWAXIS_CLASSID);
 57:   PetscClassIdRegister("Line Graph",&PETSC_DRAWLG_CLASSID);
 58:   PetscClassIdRegister("Histogram",&PETSC_DRAWHG_CLASSID);
 59:   PetscClassIdRegister("Scatter Plot",&PETSC_DRAWSP_CLASSID);
 60:   /* Register Constructors */
 61:   PetscDrawRegisterAll();
 62:   /* Process info exclusions */
 63:   PetscOptionsGetString(NULL, "-info_exclude", logList, 256, &opt);
 64:   if (opt) {
 65:     PetscStrstr(logList, "draw", &className);
 66:     if (className) {
 67:       PetscInfoDeactivateClass(0);
 68:     }
 69:   }
 70:   /* Process summary exclusions */
 71:   PetscOptionsGetString(NULL, "-log_summary_exclude", logList, 256, &opt);
 72:   if (opt) {
 73:     PetscStrstr(logList, "draw", &className);
 74:     if (className) {
 75:       PetscLogEventDeactivateClass(0);
 76:     }
 77:   }
 78:   PetscRegisterFinalize(PetscDrawFinalizePackage);
 79:   return(0);
 80: }

 84: /*@
 85:    PetscDrawResizeWindow - Allows one to resize a window from a program.

 87:    Collective on PetscDraw

 89:    Input Parameter:
 90: +  draw - the window
 91: -  w,h - the new width and height of the window

 93:    Level: intermediate

 95: .seealso: PetscDrawCheckResizedWindow()
 96: @*/
 97: PetscErrorCode  PetscDrawResizeWindow(PetscDraw draw,int w,int h)
 98: {

102:   if (draw->ops->resizewindow) {
103:     (*draw->ops->resizewindow)(draw,w,h);
104:   }
105:   return(0);
106: }

110: /*@
111:    PetscDrawCheckResizedWindow - Checks if the user has resized the window.

113:    Collective on PetscDraw

115:    Input Parameter:
116: .  draw - the window

118:    Level: advanced

120: .seealso: PetscDrawResizeWindow()

122: @*/
123: PetscErrorCode  PetscDrawCheckResizedWindow(PetscDraw draw)
124: {

128:   if (draw->ops->checkresizedwindow) {
129:     (*draw->ops->checkresizedwindow)(draw);
130:   }
131:   return(0);
132: }

136: /*@C
137:    PetscDrawGetTitle - Gets pointer to title of a PetscDraw context.

139:    Not collective

141:    Input Parameter:
142: .  draw - the graphics context

144:    Output Parameter:
145: .  title - the title

147:    Level: intermediate

149: .seealso: PetscDrawSetTitle()
150: @*/
151: PetscErrorCode  PetscDrawGetTitle(PetscDraw draw,char **title)
152: {
156:   *title = draw->title;
157:   return(0);
158: }

162: /*@C
163:    PetscDrawSetTitle - Sets the title of a PetscDraw context.

165:    Not collective (any processor or all may call this)

167:    Input Parameters:
168: +  draw - the graphics context
169: -  title - the title

171:    Level: intermediate

173:    Note: The title is positioned in the windowing system title bar for the window. Hence it will not be saved with -draw_save 
174:    in the image.

176:    A copy of the string is made, so you may destroy the
177:    title string after calling this routine.

179:    You can use PetscDrawAxisSetLabels() to indicate a title within the window 

181: .seealso: PetscDrawGetTitle(), PetscDrawAppendTitle()
182: @*/
183: PetscErrorCode  PetscDrawSetTitle(PetscDraw draw,const char title[])
184: {

190:   PetscFree(draw->title);
191:   PetscStrallocpy(title,&draw->title);
192:   if (draw->ops->settitle) {
193:     (*draw->ops->settitle)(draw,title);
194:   }
195:   return(0);
196: }

200: /*@C
201:    PetscDrawAppendTitle - Appends to the title of a PetscDraw context.

203:    Not collective (any processor or all can call this)

205:    Input Parameters:
206: +  draw - the graphics context
207: -  title - the title

209:    Note:
210:    A copy of the string is made, so you may destroy the
211:    title string after calling this routine.

213:    Level: advanced

215: .seealso: PetscDrawSetTitle(), PetscDrawGetTitle()
216: @*/
217: PetscErrorCode  PetscDrawAppendTitle(PetscDraw draw,const char title[])
218: {
220:   size_t         len1,len2,len;
221:   char           *newtitle;

225:   if (!title) return(0);

227:   if (draw->title) {
228:     PetscStrlen(title,&len1);
229:     PetscStrlen(draw->title,&len2);
230:     len  = len1 + len2;
231:     PetscMalloc((len + 1)*sizeof(char*),&newtitle);
232:     PetscStrcpy(newtitle,draw->title);
233:     PetscStrcat(newtitle,title);
234:     PetscFree(draw->title);

236:     draw->title = newtitle;
237:   } else {
238:     PetscStrallocpy(title,&draw->title);
239:   }
240:   if (draw->ops->settitle) {
241:     (*draw->ops->settitle)(draw,draw->title);
242:   }
243:   return(0);
244: }

248: /*@
249:    PetscDrawDestroy - Deletes a draw context.

251:    Collective on PetscDraw

253:    Input Parameters:
254: .  draw - the drawing context

256:    Level: beginner

258: .seealso: PetscDrawCreate()

260: @*/
261: PetscErrorCode  PetscDrawDestroy(PetscDraw *draw)
262: {

266:   if (!*draw) return(0);
268:   if (--((PetscObject)(*draw))->refct > 0) return(0);

270:   if ((*draw)->pause == -2) {
271:     (*draw)->pause = -1;

273:     PetscDrawPause(*draw);
274:   }

276:   /* if memory was published then destroy it */
277:   PetscObjectAMSViewOff((PetscObject)*draw);

279:   if ((*draw)->ops->destroy) {
280:     (*(*draw)->ops->destroy)(*draw);
281:   }
282:   PetscFree((*draw)->title);
283:   PetscFree((*draw)->display);
284:   PetscFree((*draw)->savefilename);
285:   PetscHeaderDestroy(draw);
286:   return(0);
287: }

291: /*@
292:    PetscDrawGetPopup - Creates a popup window associated with a PetscDraw window.

294:    Collective on PetscDraw

296:    Input Parameter:
297: .  draw - the original window

299:    Output Parameter:
300: .  popup - the new popup window

302:    Level: advanced

304: @*/
305: PetscErrorCode  PetscDrawGetPopup(PetscDraw draw,PetscDraw *popup)
306: {


313:   if (draw->popup) *popup = draw->popup;
314:   else if (draw->ops->getpopup) {
315:     (*draw->ops->getpopup)(draw,popup);
316:   } else *popup = NULL;
317:   return(0);
318: }

322: PetscErrorCode PetscDrawDestroy_Null(PetscDraw draw)
323: {
325:   return(0);
326: }

330: /*
331:   PetscDrawOpenNull - Opens a null drawing context. All draw commands to
332:   it are ignored.

334:   Output Parameter:
335: . win - the drawing context

337:    Level: advanced

339: */
340: PetscErrorCode  PetscDrawOpenNull(MPI_Comm comm,PetscDraw *win)
341: {

345:   PetscDrawCreate(comm,NULL,NULL,0,0,1,1,win);
346:   PetscDrawSetType(*win,PETSC_DRAW_NULL);
347:   return(0);
348: }

352: /*@
353:   PetscDrawSetDisplay - Sets the display where a PetscDraw object will be displayed

355:   Input Parameter:
356: + draw - the drawing context
357: - display - the X windows display

359:   Level: advanced

361: @*/
362: PetscErrorCode  PetscDrawSetDisplay(PetscDraw draw,const char display[])
363: {

367:   PetscFree(draw->display);
368:   PetscStrallocpy(display,&draw->display);
369:   return(0);
370: }

374: /*
375:   PetscDrawCreate_Null - Opens a null drawing context. All draw commands to
376:   it are ignored.

378:   Input Parameter:
379: . win - the drawing context
380: */
381: PETSC_EXTERN PetscErrorCode PetscDrawCreate_Null(PetscDraw draw)
382: {

386:   PetscMemzero(draw->ops,sizeof(struct _PetscDrawOps));

388:   draw->ops->destroy = PetscDrawDestroy_Null;
389:   draw->ops->view    = 0;
390:   draw->pause        = 0.0;
391:   draw->coor_xl      = 0.0;  draw->coor_xr = 1.0;
392:   draw->coor_yl      = 0.0;  draw->coor_yr = 1.0;
393:   draw->port_xl      = 0.0;  draw->port_xr = 1.0;
394:   draw->port_yl      = 0.0;  draw->port_yr = 1.0;
395:   draw->popup        = 0;
396:   return(0);
397: }

401: /*@C
402:    PetscDrawGetSingleton - Gain access to a PetscDraw object as if it were owned
403:         by the one process.

405:    Collective on PetscDraw

407:    Input Parameter:
408: .  draw - the original window

410:    Output Parameter:
411: .  sdraw - the singleton window

413:    Level: advanced

415: .seealso: PetscDrawRestoreSingleton(), PetscViewerGetSingleton(), PetscViewerRestoreSingleton()

417: @*/
418: PetscErrorCode  PetscDrawGetSingleton(PetscDraw draw,PetscDraw *sdraw)
419: {
421:   PetscMPIInt    size;


427:   MPI_Comm_size(PetscObjectComm((PetscObject)draw),&size);
428:   if (size == 1) *sdraw = draw;
429:   else {
430:     if (draw->ops->getsingleton) {
431:       (*draw->ops->getsingleton)(draw,sdraw);
432:     } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Cannot get singleton for this type %s of draw object",((PetscObject)draw)->type_name);
433:   }
434:   return(0);
435: }

439: /*@C
440:    PetscDrawRestoreSingleton - Remove access to a PetscDraw object as if it were owned
441:         by the one process.

443:    Collective on PetscDraw

445:    Input Parameters:
446: +  draw - the original window
447: -  sdraw - the singleton window

449:    Level: advanced

451: .seealso: PetscDrawGetSingleton(), PetscViewerGetSingleton(), PetscViewerRestoreSingleton()

453: @*/
454: PetscErrorCode  PetscDrawRestoreSingleton(PetscDraw draw,PetscDraw *sdraw)
455: {
457:   PetscMPIInt    size;


464:   MPI_Comm_size(PetscObjectComm((PetscObject)draw),&size);
465:   if (size != 1) {
466:     if (draw->ops->restoresingleton) {
467:       (*draw->ops->restoresingleton)(draw,sdraw);
468:     } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Cannot restore singleton for this type %s of draw object",((PetscObject)draw)->type_name);
469:   }
470:   return(0);
471: }