PLplot  5.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
ntk.c
Go to the documentation of this file.
1 // $Id: ntk.c 11282 2010-10-28 16:26:09Z airwin $
2 //
3 // Experimental tk driver using a plain "wish"
4 //
5 // Copyright (C) 2001 Joao Cardoso
6 // Copyright (C) 2004 Rafael Laboissiere
7 //
8 // This file is part of PLplot.
9 //
10 // PLplot is free software; you can redistribute it and/or modify
11 // it under the terms of the GNU Library General Public License as published
12 // by the Free Software Foundation; either version 2 of the License, or
13 // (at your option) any later version.
14 //
15 // PLplot is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU Library General Public License for more details.
19 //
20 // You should have received a copy of the GNU Library General Public License
21 // along with PLplot; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 //
24 //
25 
26 #include "plDevs.h"
27 
28 #ifdef PLD_ntk
29 
30 #include "plplotP.h"
31 #include "drivers.h"
32 #include "plevent.h"
33 
34 #include <tk.h>
35 
36 // Device info
37 PLDLLIMPEXP_DRIVER const char* plD_DEVICE_INFO_ntk = "ntk:New tk driver:1:ntk:43:ntk\n";
38 
39 
41 
42 void plD_init_ntk( PLStream * );
43 void plD_line_ntk( PLStream *, short, short, short, short );
44 void plD_polyline_ntk( PLStream *, short *, short *, PLINT );
45 void plD_eop_ntk( PLStream * );
46 void plD_bop_ntk( PLStream * );
47 void plD_tidy_ntk( PLStream * );
48 void plD_state_ntk( PLStream *, PLINT );
49 void plD_esc_ntk( PLStream *, PLINT, void * );
50 
52 {
53 #ifndef ENABLE_DYNDRIVERS
54  pdt->pl_MenuStr = "New Tk device";
55  pdt->pl_DevName = "ntk";
56 #endif
58  pdt->pl_seq = 43;
59  pdt->pl_init = (plD_init_fp) plD_init_ntk;
60  pdt->pl_line = (plD_line_fp) plD_line_ntk;
61  pdt->pl_polyline = (plD_polyline_fp) plD_polyline_ntk;
62  pdt->pl_eop = (plD_eop_fp) plD_eop_ntk;
63  pdt->pl_bop = (plD_bop_fp) plD_bop_ntk;
64  pdt->pl_tidy = (plD_tidy_fp) plD_tidy_ntk;
65  pdt->pl_state = (plD_state_fp) plD_state_ntk;
66  pdt->pl_esc = (plD_esc_fp) plD_esc_ntk;
67 }
68 
69 // hardwired window size
70 #define XPIXELS 600
71 #define YPIXELS 400
72 
73 static PLFLT scale = 10.0; // Tk canvas units are in pixels, giving corse curves, fool plplot, and scale down when sending to tk
74 static PLFLT ppm; // device pixels per mm
75 
76 static Tcl_Interp *interp = NULL; // tcl interpreter
77 static Tk_Window mainw; // tk main window
78 
79 static char curcolor[80]; // current color in #rrggbb notation
80 static char cmd[10000]; // buffer to build command to interp
81 static int ccanv = 0; // current canvas number
82 static char base[80]; // name of frame that contains the canvas
83 static char dash[80]; // dash string, as <mark space>*
84 
85 // line buffering
86 #define NPTS 1000
87 static short xold = -1, yold = -1; // last point of last 2 points line
88 static short xb[NPTS], yb[NPTS]; // buffer
89 static int curpts = 0; // current number of points buffered
90 
91 static int local = 1; // "local" or "remote" interpreter
92 static char rem_interp[80]; // name of remote interp
93 
94 // physical devices coordinates
95 static PLINT xmin = 0;
96 static PLINT xmax = XPIXELS;
97 static PLINT ymin = 0;
98 static PLINT ymax = YPIXELS;
99 
100 // locator
101 static PLGraphicsIn gin;
102 
103 static void
104 tk_cmd( char *cmd )
105 {
106  static char scmd[10000];
107 
108  if ( local )
109  Tcl_Eval( interp, cmd );
110  else
111  {
112  // the -async option makes it block, some times! but is *much* faster!
113  // and was working OK till now :(
114  // sprintf(scmd, "send -async %s {%s}", rem_interp, cmd);
115  //
116  sprintf( scmd, "send %s {%s}", rem_interp, cmd ); // mess! make it more efficient
117  if ( Tcl_Eval( interp, scmd ) != TCL_OK )
118  fprintf( stderr, "%s\n", interp->result );
119  }
120 }
121 
122 static void
123 create_canvas( PLStream *pls )
124 {
125  ccanv++;
126 
127  // create new canvas
128  sprintf( cmd, "set ccanv %d; canvas $plf.f2.c$ccanv -width $xmax -height $ymax -background #%02x%02x%02x -xscrollcommand \"$hs set\" -yscrollcommand \"$vs set\" -scrollregion \"0 0 $xmax $ymax\"", ccanv, pls->cmap0[0].r, pls->cmap0[0].g, pls->cmap0[0].b );
129  tk_cmd( cmd );
130 
131  // add new canvas to option menu
132  sprintf( cmd, "$plf.f1.mb.menu add command -label \"Page $ccanv\" -command {\n"
133  "set w $plf.f2.c%d;\n"
134  "$hs configure -command \"$w xview\";\n"
135  "$vs configure -command \"$w yview\";\n"
136  "set dname \"Page %d\";\n"
137  "pack forget $ocanvas;\n"
138  "set ocanvas $plf.f2.c%d;\n"
139  "pack $ocanvas -fill both -expand 1;\n"
140  "scan [$w xview] \"%%f %%f\" i j;\n"
141  "$hs set $i $j;\n"
142  "scan [$w yview] \"%%f %%f\" i j;\n"
143  "$vs set $i $j;}",
144  ccanv, ccanv, ccanv );
145  tk_cmd( cmd );
146 
147  sprintf( cmd, "set item(%d) 0", ccanv );
148  tk_cmd( cmd );
149 
150  // Shif-B1, zooms in
151  // FIXME inform the core lib of the zoom, see plframe.c around line 2818
152 
153  sprintf( cmd, "bind $plf.f2.c$ccanv <Shift-Button-1> {\n"
154  "set cc %d;\n"
155  "incr item($cc); set tt $item($cc);\n"
156  "if {$tt == 1} {\n"
157  "incr scroll_use;\n"
158  "pack $hs -side bottom -fill x;\n"
159  "pack $vs -side right -fill y;\n"
160  "pack forget %%W; pack %%W -fill both -expand 1}\n"
161  "set zx($cc,$tt) %%x;\n"
162  "set zy($cc,$tt) %%y;\n"
163  "%%W scale all %%x %%y 1.6 1.6;\n"
164  "%%W configure -scrollregion [%%W bbox all];\n"
165  "}", ccanv );
166 
167  tk_cmd( cmd );
168 
169  // Shif-B3, zooms out
170  sprintf( cmd, "bind $plf.f2.c$ccanv <Shift-Button-3> {\n"
171  "set cc %d; set tt $item($cc);\n"
172  "if {$tt != 0} {\n"
173  "%%W scale all $zx($cc,$tt) $zy($cc,$tt) 0.625 0.625\n"
174  "%%W configure -scrollregion [%%W bbox all];\n"
175  "set item($cc) [expr $tt - 1]}\n"
176  "if { $item($cc) == 0} {\n"
177  "set scroll_use [expr $scroll_use - 1];\n"
178  "if {$scroll_use == 0} {\n"
179  "pack forget $plf.f2.hscroll $plf.f2.vscroll}\n"
180  "%%W configure -scrollregion \"0 0 $xmax $ymax\"}}", ccanv );
181  tk_cmd( cmd );
182 
183  // Shift-B2, resets
184  sprintf( cmd, "bind $plf.f2.c$ccanv <Shift-Button-2> {\n"
185  "set cc %d; set tt $item($cc); \n"
186  "while {$tt != 0} {\n"
187  "%%W scale all $zx($cc,$tt) $zy($cc,$tt) 0.625 0.625\n"
188  "set tt [expr $tt - 1]};\n"
189  "set item($cc) 0;\n"
190  "%%W configure -scrollregion \"0 0 $xmax $ymax\";\n"
191  "set scroll_use [expr $scroll_use - 1];\n"
192  "if {$scroll_use == 0} {\n"
193  "pack forget $plf.f2.hscroll $plf.f2.vscroll}}", ccanv );
194  tk_cmd( cmd );
195 
196  // Control-B1-Motion, pan
197  sprintf( cmd, "bind $plf.f2.c$ccanv <Control-Button-1> \"$plf.f2.c%d scan mark %%x %%y\"", ccanv );
198  tk_cmd( cmd );
199 
200  sprintf( cmd, "bind $plf.f2.c$ccanv <Control-Button1-Motion> \"$plf.f2.c%d scan dragto %%x %%y\"", ccanv );
201  tk_cmd( cmd );
202 
203  // Control-B2, identify and (in the far future) edit object
204  tk_cmd( "bind $plf.f2.c$ccanv <Control-Button-2> {\n"
205  "set xx [ expr [winfo pointerx .] - [winfo rootx %W]];\n"
206  "set yy [ expr [winfo pointery .] - [winfo rooty %W]];\n"
207  "set near [%W find closest $xx $yy];\n"
208  "%W move $near 20 20;\n"
209  "after 500 \"%W move $near -20 -20\"}" );
210 
211  // change view to the new canvas by invoking the menu buttom
212  sprintf( cmd, "$plf.f1.mb.menu invoke %d", ccanv - 1 );
213  tk_cmd( cmd );
214 }
215 
216 //--------------------------------------------------------------------------
217 // plD_init_ntk()
218 //
219 // Initialize device (terminal).
220 //--------------------------------------------------------------------------
221 
222 void
223 plD_init_ntk( PLStream *pls )
224 {
225  pls->dev_fill0 = 1; // Handle solid fills
226  pls->dev_fill1 = 1; // Driver handles pattern fills
227  pls->color = 1; // Is a color device
228  pls->dev_dash = 1; // Handle dashed lines
229  pls->plbuf_write = 1; // Use plot buffer
230 
231  strcpy( curcolor, "black" ); // default color by name, not #rrggbb
232 
233  if ( pls->server_name != NULL )
234  {
235  local = 0;
236  strcpy( rem_interp, pls->server_name );
237  }
238 
239  if ( pls->geometry != NULL )
240  sscanf( pls->geometry, "%dx%d", &xmax, &ymax );
241 
242  if ( pls->plwindow != NULL )
243  strcpy( base, pls->plwindow );
244  else
245  strcpy( base, ".plf" ); // default frame containing the canvas
246 
247  interp = Tcl_CreateInterp();
248 
249  if ( Tcl_Init( interp ) != TCL_OK )
250  plexit( "Unable to initialize Tcl." );
251 
252  if ( Tk_Init( interp ) )
253  plexit( "Unable to initialize Tk." );
254 
255  mainw = Tk_MainWindow( interp );
256  Tcl_Eval( interp, "rename exec {}" );
257 
258  Tcl_Eval( interp, "tk appname PLplot_ntk" ); // give interpreter a name
259 
260  if ( !local )
261  {
262  Tcl_Eval( interp, "wm withdraw ." );
263 
264  sprintf( cmd, "send %s \"set client [tk appname]; wm deiconify .\"", rem_interp );
265  if ( Tcl_Eval( interp, cmd ) != TCL_OK )
266  {
267  fprintf( stderr, "%s\n", interp->result );
268  plexit( "No such tk server." );
269  }
270  }
271 
272  sprintf( cmd, "set scroll_use 0; set plf %s; set vs $plf.f2.vscroll; set hs $plf.f2.hscroll; set xmax %d; set ymax %d; set ocanvas .;", base, xmax, ymax );
273  tk_cmd( cmd );
274 
275  tk_cmd( "catch \"frame $plf\"; pack $plf -fill both -expand 1" );
276 
277  sprintf( cmd, "frame $plf.f1;\n"
278  "frame $plf.f2 -width %d -height %d;\n"
279  "pack $plf.f1 -fill x;\n"
280  "pack $plf.f2 -fill both -expand 1", xmax, ymax );
281  tk_cmd( cmd );
282 
283  tk_cmd( "scrollbar $plf.f2.hscroll -orient horiz;\n"
284  "scrollbar $plf.f2.vscroll" );
285 
286  tk_cmd( "menubutton $plf.f1.mb -text \"Page 1\" -textvariable dname -relief raised -indicatoron 1 -menu $plf.f1.mb.menu;\n"
287  "menu $plf.f1.mb.menu -tearoff 0;\n"
288  "pack $plf.f1.mb -side left" );
289 
290  if ( local )
291  tk_cmd( "button $plf.f1.quit -text Quit -command exit;\n"
292  "pack $plf.f1.quit -side right" );
293  else
294  tk_cmd( "button $plf.f1.quit -text Quit -command {send -async $client exit;\n"
295  "destroy $plf;\n"
296  "wm withdraw .};\n"
297  "pack $plf.f1.quit -side right" );
298 
299  // FIXME: I just discovered that Tcl_Eval is slower than Tcl_EvalObj. Fix it global-wide, `man Tcl_Eval'
300 
301  // Set up device parameters
302 
303  Tcl_Eval( interp, "tk scaling" ); // pixels per mm
304  ppm = (PLFLT) atof( interp->result ) / ( 25.4 / 72. );
305  plP_setpxl( ppm, ppm );
306  plP_setphy( xmin, xmax * scale, ymin, ymax * scale );
307 }
308 
309 static void
310 flushbuffer( PLStream *pls )
311 {
312  if ( curpts )
313  {
314  plD_polyline_ntk( pls, xb, yb, curpts );
315 // if (curpts != 2) fprintf(stderr,"%d ", curpts);
316  xold = yold = -1; curpts = 0;
317  }
318 }
319 
320 void
321 plD_line_ntk( PLStream *pls, short x1a, short y1a, short x2a, short y2a )
322 {
323  if ( xold == x1a && yold == y1a )
324  {
325  xold = xb[curpts] = x2a; yold = yb[curpts] = y2a; curpts++;
326  }
327  else
328  {
329  flushbuffer( pls );
330  xb[curpts] = x1a; yb[curpts] = y1a; curpts++;
331  xold = xb[curpts] = x2a; yold = yb[curpts] = y2a; curpts++;
332  }
333 
334  if ( curpts == NPTS )
335  {
336  fprintf( stderr, "\nflush: %d ", curpts );
337  flushbuffer( pls );
338  }
339 }
340 
341 void
342 plD_polyline_ntk( PLStream *pls, short *xa, short *ya, PLINT npts )
343 {
344  PLINT i, j;
345 
346  // there must exist a way to code this using the tk C API
347  j = sprintf( cmd, "$plf.f2.c%d create line ", ccanv );
348  for ( i = 0; i < npts; i++ )
349  j += sprintf( &cmd[j], "%.1f %.1f ", xa[i] / scale, ymax - ya[i] / scale );
350 
351  j += sprintf( &cmd[j], " -fill %s", curcolor );
352  if ( dash[0] == '-' )
353  j += sprintf( &cmd[j], " %s", dash );
354 
355  tk_cmd( cmd );
356 }
357 
358 // an event loop has to be designed, getcursor() and waitforpage() are just experimental
359 
360 static void
361 waitforpage( PLStream *pls )
362 {
363  int key = 0, st = 0;
364  // why can't I bind to the canvas? or even any frame?
365 //tk_cmd("bind . <KeyPress> {set keypress %N; puts \"\n%k-%A-%K-%N\"}");
366  tk_cmd( "bind . <KeyPress> {set keypress %N}" );
367 
368  while ( ( key & 0xff ) != PLK_Return && ( key & 0xff ) != PLK_Linefeed && key != PLK_Next && key != 'Q' )
369  {
370  while ( st != 1 )
371  {
372  tk_cmd( "update" );
373  tk_cmd( "info exists keypress" );
374  sscanf( interp->result, "%d", &st );
375  }
376 
377  tk_cmd( "set keypress" );
378  sscanf( interp->result, "%d", &key );
379 //fprintf(stderr,"\n%d\n", key);fflush(stderr);
380  tk_cmd( "unset keypress" );
381  st = 0;
382  }
383 
384  tk_cmd( "bind . <Key> {};" );
385 }
386 
387 void
388 plD_eop_ntk( PLStream *pls )
389 {
390  flushbuffer( pls );
391  tk_cmd( "update" );
392 }
393 
394 void
395 plD_bop_ntk( PLStream *pls )
396 {
397  create_canvas( pls );
398 }
399 
400 void
401 plD_tidy_ntk( PLStream *pls )
402 {
403  if ( !pls->nopause )
404  waitforpage( pls );
405 
406  tk_cmd( "destroy $plf; wm withdraw ." );
407 }
408 
409 void
410 plD_state_ntk( PLStream *pls, PLINT op )
411 {
412  switch ( op )
413  {
414  case PLSTATE_COLOR0:
415  case PLSTATE_COLOR1:
416  flushbuffer( pls );
417  sprintf( curcolor, "#%02x%02x%02x",
418  pls->curcolor.r, pls->curcolor.g, pls->curcolor.b );
419  break;
420  }
421 }
422 
423 static void
424 getcursor( PLStream *pls, PLGraphicsIn *ptr )
425 {
426  int st = 0;
427 
428  plGinInit( &gin );
429 
430  if ( 0 )
431  {
432  while ( st != 1 )
433  {
434  tk_cmd( "update" );
435  tk_cmd( "winfo exists $plf.f2.c$ccanv" );
436  sscanf( interp->result, "%d", &st );
437  }
438  st = 0;
439  // this give a "Segmentation fault", even after checking for the canvas!
440  tk_cmd( "set ocursor [lindex [$plf.f2.c$ccanv configure -cursor] 4]" );
441  }
442 
443  tk_cmd( "$plf.f2.c$ccanv configure -cursor cross;\n"
444  "bind $plf.f2.c$ccanv <Button> {set xloc %x; set yloc %y; set bloc %b; set sloc %s};\n"
445  "bind $plf.f2.c$ccanv <B1-Motion> {set xloc %x; set yloc %y; set bloc %b; set sloc %s};\n"
446  "bind $plf.f2.c$ccanv <B2-Motion> {set xloc %x; set yloc %y; set bloc %b; set sloc %s};\n"
447  "bind $plf.f2.c$ccanv <B3-Motion> {set xloc %x; set yloc %y; set bloc %b; set sloc %s};" );
448 
449  while ( st != 1 )
450  {
451  tk_cmd( "update" );
452  tk_cmd( "info exists xloc" );
453  sscanf( interp->result, "%d", &st );
454  }
455  tk_cmd( "set xloc" );
456  sscanf( interp->result, "%d", &gin.pX );
457  tk_cmd( "set yloc" );
458  sscanf( interp->result, "%d", &gin.pY );
459  tk_cmd( "set bloc" );
460  sscanf( interp->result, "%d", &gin.button );
461  tk_cmd( "set sloc" );
462  sscanf( interp->result, "%d", &gin.state );
463 
464  gin.dX = (PLFLT) gin.pX / xmax;
465  gin.dY = 1. - (PLFLT) gin.pY / ymax;
466 
467  tk_cmd( "bind $plf.f2.c$ccanv <ButtonPress> {};\n"
468  "bind $plf.f2.c$ccanv <ButtonMotion> {};\n"
469  "bind $plf.f2.c$ccanv <B2-Motion> {};\n"
470  "bind $plf.f2.c$ccanv <B3-Motion> {};\n"
471  "unset xloc" );
472 
473  // seg fault, see above. tk_cmd("$plf.f2.c$ccanv configure -cursor $ocursor");
474  tk_cmd( "$plf.f2.c$ccanv configure -cursor {}" );
475 
476  *ptr = gin;
477 }
478 
479 void
480 plD_esc_ntk( PLStream *pls, PLINT op, void *ptr )
481 {
482  PLINT i, j;
483  short *xa, *ya;
484  Pixmap bitmap;
485  static unsigned char bit_pat[] = {
486  0x24, 0x01, 0x92, 0x00, 0x49, 0x00, 0x24, 0x00, 0x12, 0x00, 0x09, 0x00,
487  0x04, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
488  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff
489  };
490 
491  switch ( op )
492  {
493  case PLESC_DASH:
494  xa = (short *) malloc( sizeof ( short ) * pls->dev_npts );
495  ya = (short *) malloc( sizeof ( short ) * pls->dev_npts );
496  for ( i = 0; i < pls->dev_npts; i++ )
497  {
498  xa[i] = pls->dev_x[i];
499  ya[i] = pls->dev_y[i];
500  }
501 
502  j = sprintf( dash, "-dash {" );
503  for ( i = 0; i < pls->nms; i++ )
504  j += sprintf( &dash[j], " %d %d",
505  (int) ceil( pls->mark[i] / 1e3 * ppm ),
506  (int) ceil( pls->space[i] / 1e3 * ppm ) );
507  sprintf( &dash[j], "}" );
508  plD_polyline_ntk( pls, xa, ya, pls->dev_npts );
509  free( xa ); free( ya );
510  dash[0] = 0;
511  break;
512 
513  case PLESC_FLUSH:
514  tk_cmd( "update" );
515  break;
516 
517  case PLESC_GETC:
518  getcursor( pls, (PLGraphicsIn *) ptr );
519  break;
520 
521  case PLESC_FILL:
522  if ( pls->patt != 0 )
523  {
524  // this is a hack! The real solution is in the if(0) bellow
525  pls->xpmm *= scale;
526  pls->ypmm *= scale;
527  plfill_soft( pls->dev_x, pls->dev_y, pls->dev_npts );
528  pls->xpmm /= scale;
529  pls->ypmm /= scale;
530  }
531  else
532  {
533  j = sprintf( cmd, "$plf.f2.c%d create polygon ", ccanv );
534  for ( i = 0; i < pls->dev_npts; i++ )
535  j += sprintf( &cmd[j], "%.1f %.1f ", pls->dev_x[i] / scale,
536  ymax - pls->dev_y[i] / scale );
537  j += sprintf( &cmd[j], " -fill %s", curcolor );
538  tk_cmd( cmd );
539  }
540 
541  if ( 0 )
542  {
543  if ( pls->patt != 0 )
544  {
545  Tk_DefineBitmap( interp, Tk_GetUid( "foo" ), bit_pat, 16, 16 );
546  bitmap = Tk_GetBitmap( interp, mainw, Tk_GetUid( "patt" ) );
547  }
548  j = sprintf( cmd, "$plf.f2.c%d create polygon ", ccanv );
549  for ( i = 0; i < pls->dev_npts; i++ )
550  j += sprintf( &cmd[j], "%.1f %.1f ", pls->dev_x[i] / scale,
551  ymax - pls->dev_y[i] / scale );
552  j += sprintf( &cmd[j], " -fill %s", curcolor );
553  if ( pls->patt != 0 )
554  sprintf( &cmd[j], " -stipple patt -outline black" );
555 
556  tk_cmd( cmd );
557  //Tk_FreeBitmap(display, bitmap)
558  }
559  break;
560  }
561 }
562 
563 #else
564 int
566 {
567  return 0;
568 }
569 
570 #endif // PLD_ntkdev
char * plwindow
Definition: plstrm.h:643
void(* plD_line_fp)(struct PLStream_struct *, short, short, short, short)
Definition: disptab.h:70
def cmd
Now do the PLplot API.
Definition: Plframe.py:1076
void(* plD_eop_fp)(struct PLStream_struct *)
Definition: disptab.h:72
PLFLT ypmm
Definition: plstrm.h:714
unsigned char b
Definition: plplot.h:455
PLINT dev_fill1
Definition: plstrm.h:576
void(* plD_state_fp)(struct PLStream_struct *, PLINT)
Definition: disptab.h:75
PLFLT dX
Definition: plplot.h:362
#define PLESC_FILL
Definition: plplot.h:219
void(* plD_tidy_fp)(struct PLStream_struct *)
Definition: disptab.h:74
plD_esc_fp pl_esc
Definition: disptab.h:91
#define NPTS
PLINT nms
Definition: plstrm.h:683
void plGinInit(PLGraphicsIn *gin)
Definition: plctrl.c:2860
PLINT dev_npts
Definition: plstrm.h:586
const char * pl_MenuStr
Definition: disptab.h:80
PLINT color
Definition: plstrm.h:574
plD_tidy_fp pl_tidy
Definition: disptab.h:89
PLINT plbuf_write
Definition: plstrm.h:572
tuple xmin
Definition: Plframe.py:907
const char * pl_DevName
Definition: disptab.h:81
#define PLSTATE_COLOR0
Definition: plplotP.h:330
plD_init_fp pl_init
Definition: disptab.h:84
#define PLSTATE_COLOR1
Definition: plplotP.h:331
tuple ymin
Definition: Plframe.py:908
#define PLK_Linefeed
Definition: plevent.h:51
short * dev_x
Definition: plstrm.h:587
void(* plD_polyline_fp)(struct PLStream_struct *, short *, short *, PLINT)
Definition: disptab.h:71
int PLINT
Definition: plplot.h:175
void(* plD_esc_fp)(struct PLStream_struct *, PLINT, void *)
Definition: disptab.h:76
void(* plD_bop_fp)(struct PLStream_struct *)
Definition: disptab.h:73
unsigned char g
Definition: plplot.h:454
PLStream * pls[]
plD_bop_fp pl_bop
Definition: disptab.h:88
plD_line_fp pl_line
Definition: disptab.h:85
PLINT mark[10]
Definition: plstrm.h:683
void plP_setpxl(PLFLT xpmm, PLFLT ypmm)
Definition: plcore.c:4072
PLColor * cmap0
Definition: plstrm.h:550
PLDLLIMPEXP_DRIVER void plD_dispatch_init_ntk(PLDispatchTable *pdt)
char * server_name
Definition: plstrm.h:642
#define PLDLLIMPEXP_DRIVER
Definition: pldll.h:66
void plP_setphy(PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax)
Definition: plcore.c:4083
tuple xmax
Definition: Plframe.py:909
PLFLT xpmm
Definition: plstrm.h:714
short * dev_y
Definition: plstrm.h:587
void plfill_soft(short *x, short *y, PLINT n)
Definition: plfill.c:309
int pldummy_ntk()
Definition: ntk.c:565
float PLFLT
Definition: plplot.h:159
#define PLK_Return
Definition: plevent.h:52
#define PLK_Next
Definition: plevent.h:70
PLINT patt
Definition: plstrm.h:676
tuple ymax
Definition: Plframe.py:910
unsigned int state
Definition: plplot.h:356
unsigned char r
Definition: plplot.h:453
PLINT nopause
Definition: plstrm.h:573
PLINT dev_dash
Definition: plstrm.h:576
unsigned int button
Definition: plplot.h:358
static Tcl_Interp * interp
Definition: tkMain.c:116
PLColor curcolor
Definition: plstrm.h:549
plD_state_fp pl_state
Definition: disptab.h:90
#define PLESC_DASH
Definition: plplot.h:229
PLFLT dY
Definition: plplot.h:362
plD_eop_fp pl_eop
Definition: disptab.h:87
#define PLESC_GETC
Definition: plplot.h:223
plD_polyline_fp pl_polyline
Definition: disptab.h:86
char * geometry
Definition: plstrm.h:636
PLINT dev_fill0
Definition: plstrm.h:576
void(* plD_init_fp)(struct PLStream_struct *)
Definition: disptab.h:69
#define PLESC_FLUSH
Definition: plplot.h:221
void plexit(const char *errormsg)
Definition: plctrl.c:1941
PLINT space[10]
Definition: plstrm.h:683