Actual source code: draw.c

      2: /*
      3:        Provides the calling sequences for all the basic PetscDraw routines.
      4: */
      5: #include <petsc/private/drawimpl.h>
      6: #include <petscviewer.h>

      8: PetscClassId PETSC_DRAW_CLASSID;

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

     15:   Level: developer

     17: .seealso: PetscFinalize()
     18: @*/
     19: PetscErrorCode  PetscDrawFinalizePackage(void)
     20: {
     21:   PetscFunctionListDestroy(&PetscDrawList);
     22:   PetscDrawPackageInitialized = PETSC_FALSE;
     23:   PetscDrawRegisterAllCalled  = PETSC_FALSE;
     24:   return 0;
     25: }

     27: /*@C
     28:   PetscInitializeDrawPackage - This function initializes everything in the PetscDraw package. It is called
     29:   from PetscDLLibraryRegister_petsc() when using dynamic libraries, and on the call to PetscInitialize()
     30:   when using shared or static libraries.

     32:   Level: developer

     34: .seealso: PetscInitialize()
     35: @*/
     36: PetscErrorCode  PetscDrawInitializePackage(void)
     37: {
     38:   char           logList[256];
     39:   PetscBool      opt,pkg;

     41:   if (PetscDrawPackageInitialized) return 0;
     42:   PetscDrawPackageInitialized = PETSC_TRUE;
     43:   /* Register Classes */
     44:   PetscClassIdRegister("Draw",&PETSC_DRAW_CLASSID);
     45:   PetscClassIdRegister("Draw Axis",&PETSC_DRAWAXIS_CLASSID);
     46:   PetscClassIdRegister("Line Graph",&PETSC_DRAWLG_CLASSID);
     47:   PetscClassIdRegister("Histogram",&PETSC_DRAWHG_CLASSID);
     48:   PetscClassIdRegister("Bar Graph",&PETSC_DRAWBAR_CLASSID);
     49:   PetscClassIdRegister("Scatter Plot",&PETSC_DRAWSP_CLASSID);
     50:   /* Register Constructors */
     51:   PetscDrawRegisterAll();
     52:   /* Process Info */
     53:   {
     54:     PetscClassId  classids[6];

     56:     classids[0] = PETSC_DRAW_CLASSID;
     57:     classids[1] = PETSC_DRAWAXIS_CLASSID;
     58:     classids[2] = PETSC_DRAWLG_CLASSID;
     59:     classids[3] = PETSC_DRAWHG_CLASSID;
     60:     classids[4] = PETSC_DRAWBAR_CLASSID;
     61:     classids[5] = PETSC_DRAWSP_CLASSID;
     62:     PetscInfoProcessClass("draw", 6, classids);
     63:   }
     64:   /* Process summary exclusions */
     65:   PetscOptionsGetString(NULL,NULL,"-log_exclude",logList,sizeof(logList),&opt);
     66:   if (opt) {
     67:     PetscStrInList("draw",logList,',',&pkg);
     68:     if (pkg) {
     69:       PetscLogEventExcludeClass(PETSC_DRAW_CLASSID);
     70:       PetscLogEventExcludeClass(PETSC_DRAWAXIS_CLASSID);
     71:       PetscLogEventExcludeClass(PETSC_DRAWLG_CLASSID);
     72:       PetscLogEventExcludeClass(PETSC_DRAWHG_CLASSID);
     73:       PetscLogEventExcludeClass(PETSC_DRAWBAR_CLASSID);
     74:       PetscLogEventExcludeClass(PETSC_DRAWSP_CLASSID);
     75:     }
     76:   }
     77:   /* Register package finalizer */
     78:   PetscRegisterFinalize(PetscDrawFinalizePackage);
     79:   return 0;
     80: }

     82: /*@
     83:    PetscDrawResizeWindow - Allows one to resize a window from a program.

     85:    Collective on PetscDraw

     87:    Input Parameters:
     88: +  draw - the window
     89: -  w,h - the new width and height of the window

     91:    Level: intermediate

     93: .seealso: PetscDrawCheckResizedWindow()
     94: @*/
     95: PetscErrorCode  PetscDrawResizeWindow(PetscDraw draw,int w,int h)
     96: {
    100:   if (draw->ops->resizewindow) {
    101:     (*draw->ops->resizewindow)(draw,w,h);
    102:   }
    103:   return 0;
    104: }

    106: /*@
    107:    PetscDrawGetWindowSize - Gets the size of the window.

    109:    Not collective

    111:    Input Parameter:
    112: .  draw - the window

    114:    Output Parameters:
    115: .  w,h - the window width and height

    117:    Level: intermediate

    119: .seealso: PetscDrawResizeWindow(), PetscDrawCheckResizedWindow()
    120: @*/
    121: PetscErrorCode  PetscDrawGetWindowSize(PetscDraw draw,int *w,int *h)
    122: {
    126:   if (w) *w = draw->w;
    127:   if (h) *h = draw->h;
    128:   return 0;
    129: }

    131: /*@
    132:    PetscDrawCheckResizedWindow - Checks if the user has resized the window.

    134:    Collective on PetscDraw

    136:    Input Parameter:
    137: .  draw - the window

    139:    Level: advanced

    141: .seealso: PetscDrawResizeWindow()

    143: @*/
    144: PetscErrorCode  PetscDrawCheckResizedWindow(PetscDraw draw)
    145: {
    147:   if (draw->ops->checkresizedwindow) {
    148:     (*draw->ops->checkresizedwindow)(draw);
    149:   }
    150:   return 0;
    151: }

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

    156:    Not collective

    158:    Input Parameter:
    159: .  draw - the graphics context

    161:    Output Parameter:
    162: .  title - the title

    164:    Level: intermediate

    166: .seealso: PetscDrawSetTitle()
    167: @*/
    168: PetscErrorCode  PetscDrawGetTitle(PetscDraw draw,const char *title[])
    169: {
    172:   *title = draw->title;
    173:   return 0;
    174: }

    176: /*@C
    177:    PetscDrawSetTitle - Sets the title of a PetscDraw context.

    179:    Collective on PetscDraw

    181:    Input Parameters:
    182: +  draw - the graphics context
    183: -  title - the title

    185:    Level: intermediate

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

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

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

    195: .seealso: PetscDrawGetTitle(), PetscDrawAppendTitle()
    196: @*/
    197: PetscErrorCode  PetscDrawSetTitle(PetscDraw draw,const char title[])
    198: {
    201:   PetscFree(draw->title);
    202:   PetscStrallocpy(title,&draw->title);
    203:   if (draw->ops->settitle) {
    204:     (*draw->ops->settitle)(draw,draw->title);
    205:   }
    206:   return 0;
    207: }

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

    212:    Collective on PetscDraw

    214:    Input Parameters:
    215: +  draw - the graphics context
    216: -  title - the title

    218:    Note:
    219:    A copy of the string is made, so you may destroy the
    220:    title string after calling this routine.

    222:    Level: advanced

    224: .seealso: PetscDrawSetTitle(), PetscDrawGetTitle()
    225: @*/
    226: PetscErrorCode  PetscDrawAppendTitle(PetscDraw draw,const char title[])
    227: {
    230:   if (!title || !title[0]) return 0;

    232:   if (draw->title) {
    233:     size_t len1,len2;
    234:     char   *newtitle;
    235:     PetscStrlen(title,&len1);
    236:     PetscStrlen(draw->title,&len2);
    237:     PetscMalloc1(len1 + len2 + 1,&newtitle);
    238:     PetscStrcpy(newtitle,draw->title);
    239:     PetscStrcat(newtitle,title);
    240:     PetscFree(draw->title);
    241:     draw->title = newtitle;
    242:   } else {
    243:     PetscStrallocpy(title,&draw->title);
    244:   }
    245:   if (draw->ops->settitle) {
    246:     (*draw->ops->settitle)(draw,draw->title);
    247:   }
    248:   return 0;
    249: }

    251: static PetscErrorCode PetscDrawDestroy_Private(PetscDraw draw)
    252: {
    253:   if (!draw->ops->save && !draw->ops->getimage) return 0;
    254:   PetscDrawSaveMovie(draw);
    255:   if (draw->savefinalfilename) {
    256:     draw->savesinglefile = PETSC_TRUE;
    257:     PetscDrawSetSave(draw,draw->savefinalfilename);
    258:     PetscDrawSave(draw);
    259:   }
    260:   PetscBarrier((PetscObject)draw);
    261:   return 0;
    262: }

    264: /*@
    265:    PetscDrawDestroy - Deletes a draw context.

    267:    Collective on PetscDraw

    269:    Input Parameters:
    270: .  draw - the drawing context

    272:    Level: beginner

    274: .seealso: PetscDrawCreate()

    276: @*/
    277: PetscErrorCode  PetscDrawDestroy(PetscDraw *draw)
    278: {
    279:   if (!*draw) return 0;
    281:   if (--((PetscObject)(*draw))->refct > 0) return 0;

    283:   if ((*draw)->pause == -2) {
    284:     (*draw)->pause = -1;
    285:     PetscDrawPause(*draw);
    286:   }

    288:   /* if memory was published then destroy it */
    289:   PetscObjectSAWsViewOff((PetscObject)*draw);

    291:   PetscDrawDestroy_Private(*draw);

    293:   if ((*draw)->ops->destroy) {
    294:     (*(*draw)->ops->destroy)(*draw);
    295:   }
    296:   PetscDrawDestroy(&(*draw)->popup);
    297:   PetscFree((*draw)->title);
    298:   PetscFree((*draw)->display);
    299:   PetscFree((*draw)->savefilename);
    300:   PetscFree((*draw)->saveimageext);
    301:   PetscFree((*draw)->savemovieext);
    302:   PetscFree((*draw)->savefinalfilename);
    303:   PetscHeaderDestroy(draw);
    304:   return 0;
    305: }

    307: /*@
    308:    PetscDrawGetPopup - Creates a popup window associated with a PetscDraw window.

    310:    Collective on PetscDraw

    312:    Input Parameter:
    313: .  draw - the original window

    315:    Output Parameter:
    316: .  popup - the new popup window

    318:    Level: advanced

    320: .seealso: PetscDrawScalePopup(), PetscDrawCreate()

    322: @*/
    323: PetscErrorCode  PetscDrawGetPopup(PetscDraw draw,PetscDraw *popup)
    324: {

    328:   if (draw->popup) *popup = draw->popup;
    329:   else if (draw->ops->getpopup) {
    330:     (*draw->ops->getpopup)(draw,popup);
    331:     if (*popup) {
    332:       PetscObjectSetOptionsPrefix((PetscObject)*popup,"popup_");
    333:       (*popup)->pause = 0.0;
    334:       PetscDrawSetFromOptions(*popup);
    335:     }
    336:   } else *popup = NULL;
    337:   return 0;
    338: }

    340: /*@C
    341:   PetscDrawSetDisplay - Sets the display where a PetscDraw object will be displayed

    343:   Input Parameters:
    344: + draw - the drawing context
    345: - display - the X windows display

    347:   Level: advanced

    349: .seealso: PetscDrawCreate()

    351: @*/
    352: PetscErrorCode  PetscDrawSetDisplay(PetscDraw draw,const char display[])
    353: {
    354:   PetscFree(draw->display);
    355:   PetscStrallocpy(display,&draw->display);
    356:   return 0;
    357: }

    359: /*@
    360:    PetscDrawSetDoubleBuffer - Sets a window to be double buffered.

    362:    Logically Collective on PetscDraw

    364:    Input Parameter:
    365: .  draw - the drawing context

    367:    Level: intermediate

    369: @*/
    370: PetscErrorCode  PetscDrawSetDoubleBuffer(PetscDraw draw)
    371: {
    373:   if (draw->ops->setdoublebuffer) {
    374:     (*draw->ops->setdoublebuffer)(draw);
    375:   }
    376:   return 0;
    377: }

    379: /*@C
    380:    PetscDrawGetSingleton - Gain access to a PetscDraw object as if it were owned
    381:         by the one process.

    383:    Collective on PetscDraw

    385:    Input Parameter:
    386: .  draw - the original window

    388:    Output Parameter:
    389: .  sdraw - the singleton window

    391:    Level: advanced

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

    395: @*/
    396: PetscErrorCode  PetscDrawGetSingleton(PetscDraw draw,PetscDraw *sdraw)
    397: {
    398:   PetscMPIInt    size;

    403:   MPI_Comm_size(PetscObjectComm((PetscObject)draw),&size);
    404:   if (size == 1) {
    405:     PetscObjectReference((PetscObject)draw);
    406:     *sdraw = draw;
    407:   } else {
    408:     if (draw->ops->getsingleton) {
    409:       (*draw->ops->getsingleton)(draw,sdraw);
    410:     } else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Cannot get singleton for this type %s of draw object",((PetscObject)draw)->type_name);
    411:   }
    412:   return 0;
    413: }

    415: /*@C
    416:    PetscDrawRestoreSingleton - Remove access to a PetscDraw object as if it were owned
    417:         by the one process.

    419:    Collective on PetscDraw

    421:    Input Parameters:
    422: +  draw - the original window
    423: -  sdraw - the singleton window

    425:    Level: advanced

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

    429: @*/
    430: PetscErrorCode  PetscDrawRestoreSingleton(PetscDraw draw,PetscDraw *sdraw)
    431: {
    432:   PetscMPIInt    size;

    438:   MPI_Comm_size(PetscObjectComm((PetscObject)draw),&size);
    439:   if (size == 1) {
    440:     if (draw == *sdraw) {
    441:       PetscObjectDereference((PetscObject)draw);
    442:       *sdraw = NULL;
    443:     } else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Cannot restore singleton, it is not the parent draw");
    444:   } else {
    445:     if (draw->ops->restoresingleton) {
    446:       (*draw->ops->restoresingleton)(draw,sdraw);
    447:     } else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Cannot restore singleton for this type %s of draw object",((PetscObject)draw)->type_name);
    448:   }
    449:   return 0;
    450: }