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: }