Actual source code: draw.c

      1: #define PETSC_DLL
      2: /*
      3:        Provides the calling sequences for all the basic PetscDraw routines.
      4: */
     5:  #include src/sys/src/draw/drawimpl.h

      7: PetscCookie PETSC_DRAW_COOKIE = 0;

     11: /*@
     12:    PetscDrawResizeWindow - Allows one to resize a window from a program.

     14:    Collective on PetscDraw

     16:    Input Parameter:
     17: +  draw - the window
     18: -  w,h - the new width and height of the window

     20:    Level: intermediate

     22: .seealso: PetscDrawCheckResizedWindow()
     23: @*/
     24: PetscErrorCode PETSC_DLLEXPORT PetscDrawResizeWindow(PetscDraw draw,int w,int h)
     25: {
     28:   if (draw->ops->resizewindow) {
     29:     (*draw->ops->resizewindow)(draw,w,h);
     30:   }
     31:   return(0);
     32: }

     36: /*@
     37:    PetscDrawCheckResizedWindow - Checks if the user has resized the window.

     39:    Collective on PetscDraw

     41:    Input Parameter:
     42: .  draw - the window

     44:    Level: advanced

     46: .seealso: PetscDrawResizeWindow()

     48: @*/
     49: PetscErrorCode PETSC_DLLEXPORT PetscDrawCheckResizedWindow(PetscDraw draw)
     50: {
     53:   if (draw->ops->checkresizedwindow) {
     54:     (*draw->ops->checkresizedwindow)(draw);
     55:   }
     56:   return(0);
     57: }

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

     64:    Not collective

     66:    Input Parameter:
     67: .  draw - the graphics context

     69:    Output Parameter:
     70: .  title - the title

     72:    Level: intermediate

     74: .seealso: PetscDrawSetTitle()
     75: @*/
     76: PetscErrorCode PETSC_DLLEXPORT PetscDrawGetTitle(PetscDraw draw,char **title)
     77: {
     81:   *title = draw->title;
     82:   return(0);
     83: }

     87: /*@C
     88:    PetscDrawSetTitle - Sets the title of a PetscDraw context.

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

     92:    Input Parameters:
     93: +  draw - the graphics context
     94: -  title - the title

     96:    Level: intermediate

     98:    Note:
     99:    A copy of the string is made, so you may destroy the
    100:    title string after calling this routine.

    102: .seealso: PetscDrawGetTitle(), PetscDrawAppendTitle()
    103: @*/
    104: PetscErrorCode PETSC_DLLEXPORT PetscDrawSetTitle(PetscDraw draw,const char title[])
    105: {
    110:   PetscStrfree(draw->title);
    111:   PetscStrallocpy(title,&draw->title);
    112:   if (draw->ops->settitle) {
    113:     (*draw->ops->settitle)(draw,title);
    114:   }
    115:   return(0);
    116: }

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

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

    125:    Input Parameters:
    126: +  draw - the graphics context
    127: -  title - the title

    129:    Note:
    130:    A copy of the string is made, so you may destroy the
    131:    title string after calling this routine.

    133:    Level: advanced

    135: .seealso: PetscDrawSetTitle(), PetscDrawGetTitle()
    136: @*/
    137: PetscErrorCode PETSC_DLLEXPORT PetscDrawAppendTitle(PetscDraw draw,const char title[])
    138: {
    140:   size_t len1,len2,len;
    141:   char   *newtitle;

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

    147:   if (draw->title) {
    148:     PetscStrlen(title,&len1);
    149:     PetscStrlen(draw->title,&len2);
    150:     len  = len1 + len2;
    151:     PetscMalloc((len + 1)*sizeof(char*),&newtitle);
    152:     PetscStrcpy(newtitle,draw->title);
    153:     PetscStrcat(newtitle,title);
    154:     PetscFree(draw->title);
    155:     draw->title = newtitle;
    156:   } else {
    157:     PetscStrallocpy(title,&draw->title);
    158:   }
    159:   if (draw->ops->settitle) {
    160:     (*draw->ops->settitle)(draw,draw->title);
    161:   }
    162:   return(0);
    163: }

    167: /*@C
    168:    PetscDrawDestroy - Deletes a draw context.

    170:    Collective on PetscDraw

    172:    Input Parameters:
    173: .  draw - the drawing context

    175:    Level: beginner

    177: .seealso: PetscDrawCreate()

    179: @*/
    180: PetscErrorCode PETSC_DLLEXPORT PetscDrawDestroy(PetscDraw draw)
    181: {
    185:   if (--draw->refct > 0) return(0);

    187:   /* if memory was published then destroy it */
    188:   PetscObjectDepublish(draw);

    190:   if (draw->ops->destroy) {
    191:     (*draw->ops->destroy)(draw);
    192:   }
    193:   PetscStrfree(draw->title);
    194:   PetscStrfree(draw->display);
    195:   PetscHeaderDestroy(draw);
    196:   return(0);
    197: }

    201: /*@C
    202:    PetscDrawGetPopup - Creates a popup window associated with a PetscDraw window.

    204:    Collective on PetscDraw

    206:    Input Parameter:
    207: .  draw - the original window

    209:    Output Parameter:
    210: .  popup - the new popup window

    212:    Level: advanced

    214: @*/
    215: PetscErrorCode PETSC_DLLEXPORT PetscDrawGetPopup(PetscDraw draw,PetscDraw *popup)
    216: {

    222:   if (draw->popup) {
    223:     *popup = draw->popup;
    224:   } else if (draw->ops->getpopup) {
    225:       (*draw->ops->getpopup)(draw,popup);
    226:   } else {
    227:     *popup = PETSC_NULL;
    228:   }
    229:   return(0);
    230: }

    234: PetscErrorCode PetscDrawDestroy_Null(PetscDraw draw)
    235: {
    237:   return(0);
    238: }

    242: /*
    243:   PetscDrawOpenNull - Opens a null drawing context. All draw commands to
    244:   it are ignored.

    246:   Output Parameter:
    247: . win - the drawing context

    249:    Level: advanced

    251: */
    252: PetscErrorCode PETSC_DLLEXPORT PetscDrawOpenNull(MPI_Comm comm,PetscDraw *win)
    253: {

    257:   PetscDrawCreate(comm,PETSC_NULL,PETSC_NULL,0,0,1,1,win);
    258:   PetscDrawSetType(*win,PETSC_DRAW_NULL);
    259:   return(0);
    260: }

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

    267:   Input Parameter:
    268: + draw - the drawing context
    269: - display - the X windows display

    271:   Level: advanced

    273: @*/
    274: PetscErrorCode PETSC_DLLEXPORT PetscDrawSetDisplay(PetscDraw draw,char *display)
    275: {

    279:   PetscStrfree(draw->display);
    280:   PetscStrallocpy(display,&draw->display);
    281:   return(0);
    282: }

    287: /*
    288:   PetscDrawCreate_Null - Opens a null drawing context. All draw commands to
    289:   it are ignored.

    291:   Input Parameter:
    292: . win - the drawing context
    293: */
    294: PetscErrorCode PetscDrawCreate_Null(PetscDraw draw)
    295: {

    299:   PetscMemzero(draw->ops,sizeof(struct _PetscDrawOps));
    300:   draw->ops->destroy = PetscDrawDestroy_Null;
    301:   draw->ops->view    = 0;
    302:   draw->pause   = 0;
    303:   draw->coor_xl = 0.0;  draw->coor_xr = 1.0;
    304:   draw->coor_yl = 0.0;  draw->coor_yr = 1.0;
    305:   draw->port_xl = 0.0;  draw->port_xr = 1.0;
    306:   draw->port_yl = 0.0;  draw->port_yr = 1.0;
    307:   draw->popup   = 0;

    309:   return(0);
    310: }

    315: /*@C
    316:    PetscDrawGetSingleton - Gain access to a PetscDraw object as if it were owned
    317:         by the one process.

    319:    Collective on PetscDraw

    321:    Input Parameter:
    322: .  draw - the original window

    324:    Output Parameter:
    325: .  sdraw - the singleton window

    327:    Level: advanced

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

    331: @*/
    332: PetscErrorCode PETSC_DLLEXPORT PetscDrawGetSingleton(PetscDraw draw,PetscDraw *sdraw)
    333: {
    335:   PetscMPIInt    size;

    341:   MPI_Comm_size(draw->comm,&size);
    342:   if (size == 1) {
    343:     *sdraw = draw;
    344:   } else {
    345:     if (draw->ops->getsingleton) {
    346:       (*draw->ops->getsingleton)(draw,sdraw);
    347:     } else {
    348:       SETERRQ1(PETSC_ERR_SUP,"Cannot get singleton for this type %s of draw object",draw->type_name);
    349:     }
    350:   }
    351:   return(0);
    352: }

    356: /*@C
    357:    PetscDrawRestoreSingleton - Remove access to a PetscDraw object as if it were owned
    358:         by the one process.

    360:    Collective on PetscDraw

    362:    Input Parameters:
    363: +  draw - the original window
    364: -  sdraw - the singleton window

    366:    Level: advanced

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

    370: @*/
    371: PetscErrorCode PETSC_DLLEXPORT PetscDrawRestoreSingleton(PetscDraw draw,PetscDraw *sdraw)
    372: {
    374:   PetscMPIInt    size;

    381:   MPI_Comm_size(draw->comm,&size);
    382:   if (size != 1) {
    383:     if (draw->ops->restoresingleton) {
    384:       (*draw->ops->restoresingleton)(draw,sdraw);
    385:     } else {
    386:       SETERRQ1(PETSC_ERR_SUP,"Cannot restore singleton for this type %s of draw object",draw->type_name);
    387:     }
    388:   }
    389:   return(0);
    390: }