Scilab [trunk]: scilab/modules/graphics/includes/periX11.h File Reference

void C2F() boundingbox	(	char *	string,
		integer *	x,
		integer *	y,
		integer *	rect,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

To get the bounding rectangle of a string

text mode is supposed to be bottom

Definition at line 2957 of file periWin.c.

References dir, BCG::FontXID, and ScilabXgc.

02961 { 
02962   SIZE size ;
02964   GetTextExtentPoint32(hdc,(LPCTSTR)string,(int)strlen(string),&size);
02965   rect[0]= *x ;
02966   rect[1]= *y - size.cy ;
02967   rect[2]= size.cx;
02968   rect[3]= size.cy;
02969 }

int CheckColormap ( int * m )

Definition at line 2532 of file periWin.c.

References BCG::CmapFlag, BCG::Numcolors, and ScilabXgc.

02534 {
02535   if (  ScilabXgc != (struct BCG *) 0 )
02536     {
02537       *m =  ScilabXgc->Numcolors;
02538       if ( ScilabXgc->CmapFlag  != 1) 
02539         return 1;
02540       else 
02541         return 0;
02542     }
02543   else {
02544     *m=0;
02545     return(0);}
02546 }

void C2F() cleararea	(	char *	str,
		integer *	x,
		integer *	y,
		integer *	w,
		integer *	h,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 977 of file periWin.c.

References BCG::Cdrawable, PixmapClear(), and ScilabXgc.

00989 {
00990   HBRUSH hBrush;
00991   RECT rect;
00992   static COLORREF px;
00993   px = (ScilabXgc->Colors == NULL)? DefaultBackground 
00994     :  ScilabXgc->Colors[ScilabXgc->NumBackground];
00995   SetRect(&rect,(int) *x,(int) *y,(int) *x+*w,(int) *y+*h);
00997   hBrush = CreateSolidBrush(px);
00998   FillRect(hdc, &rect,hBrush );
00999   DeleteObject(hBrush);
01002 }

Here is the call graph for this function:

void C2F() clearwindow	(	char *	v1,
		integer *	v2,
		integer *	v3,
		integer *	v4,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Clear the current graphic window

verifier ce qui se passe si on est en Xor ? XXXXXXXX

Definition at line 589 of file periWin.c.

References BCG::Cdrawable, BCG::CWindow, PI0, ScilabXgc, and xset_pixmapclear().

00593 {
00594   RECT rect;
00595   static COLORREF px;
00596   HBRUSH hBrush;
00597   if ( ScilabXgc->ClipRegionSet == 1) 
00598     SelectClipRgn(hdc,NULL);
00599   if ( sciGetPixmapStatus() == 1) 
00600     {
00601       C2F(pixmapclear)(PI0,PI0,PI0,PI0);
00602       C2F(show)(PI0,PI0,PI0,PI0);      
00603     }
00604   else
00605     {
00606       px = (ScilabXgc->Colors == NULL)? DefaultBackground 
00607         :  ScilabXgc->Colors[ScilabXgc->NumBackground];
00608       SetBkColor(hdc, px );
00609       GetClientRect(ScilabXgc->CWindow, &rect);
00611       hBrush = CreateSolidBrush(px);
00612       /* on met a jour la couleur de fond */
00613       rect.top    = 0;
00614       rect.left   = 0;
00615       rect.right  = ScilabXgc->CWindowWidth;
00616       rect.bottom = ScilabXgc->CWindowHeight;
00617       FillRect(hdc, &rect,hBrush );
00618       DeleteObject(hBrush);
00619     }
00620   /* reset the clip region using current data */
00621   set_current_clip ();
00622 
00623   RefreshGraphToolBar(ScilabXgc);
00624         
00625 }

Here is the call graph for this function:

void clip_line	(	integer	x1,
		integer	yy1,
		integer	x2,
		integer	y2,
		integer *	x1n,
		integer *	yy1n,
		integer *	x2n,
		integer *	y2n,
		integer *	flag
	)

Definition at line 4728 of file periWin.c.

References clip_point(), count, dx, and dy.

04737 {
04738   integer x, y, dx, dy, x_intr[2], y_intr[2], count, pos1, pos2;
04739 
04740   *x1n=x1; *yy1n=yy1; *x2n=x2; *y2n=y2; *flag=4;
04741   pos1 = clip_point(x1, yy1);
04742   pos2 = clip_point(x2, y2);
04743   if (pos1 || pos2) {
04744     if (pos1 & pos2) { *flag=0;return;}   
04745     /* segment is totally out. */
04746 
04747     /* Here part of the segment MAy be inside. test the intersection
04748      * of this segment with the 4 boundaries for hopefully 2 intersections
04749      * in. If non found segment is totaly out.
04750      */
04751     count = 0;
04752     dx = x2 - x1;
04753     dy = y2 - yy1;
04754 
04755     /* Find intersections with the x parallel bbox lines: */
04756     if (dy != 0) {
04757       x = (int) ((ybot - y2)  * ((double) dx / (double) dy) + x2);
04758       /* Test for ybot boundary. */
04759       if (x >= xleft && x <= xright) {
04760         x_intr[count] = x;
04761         y_intr[count++] = ybot;
04762       }
04763       x = (int) ((ytop - y2) * ((double) dx / (double) dy) + x2); 
04764       /* Test for ytop boundary. */
04765       if (x >= xleft && x <= xright) {
04766         x_intr[count] = x;
04767         y_intr[count++] = ytop;
04768       }
04769     }
04770     if ( count < 2 ) 
04771       {
04772         /* Find intersections with the y parallel bbox lines: */
04773         if (dx != 0) {
04774           y = (int) ((xleft - x2) * ((double) dy / (double) dx) + y2);   
04775           /* Test for xleft boundary. */
04776           if (y >= ybot && y <= ytop) {
04777             x_intr[count] = xleft;
04778             y_intr[count++] = y;
04779           }
04780           if ( count < 2 ) 
04781             {
04782               y = (int) ((xright - x2) * ((double) dy / (double) dx) + y2);  
04783               /* Test for xright boundary. */
04784               if (y >= ybot && y <= ytop) {
04785                 x_intr[count] = xright;
04786                 y_intr[count++] = y;
04787               }
04788             }
04789         }
04790       }
04791 
04792     if (count == 2) {
04793       if (pos1 && pos2) {          /* Both were out - update both */
04794         *x1n = x_intr[0];
04795         *yy1n = y_intr[0];
04796         *x2n = x_intr[1];
04797         *y2n = y_intr[1];
04798         *flag=3;return;
04799       }
04800       else if (pos1) {       /* Only x1/yy1 was out - update only it */
04801         if (dx * (x2 - x_intr[0]) + dy * (y2 - y_intr[0]) >= 0) {
04802           *x1n = x_intr[0];
04803           *yy1n = y_intr[0];
04804           *flag=1;return;
04805         }
04806         else {
04807           *x1n = x_intr[1];
04808           *yy1n = y_intr[1];
04809           *flag=1;return;
04810         }
04811       }
04812       else {             /* Only x2/y2 was out - update only it */
04813         if (dx * (x_intr[0] - x1) + dy * (y_intr[0] - yy1) >= 0) {
04814           *x2n = x_intr[0];
04815           *y2n = y_intr[0];
04816           *flag=2;return;
04817         }
04818         else {
04819           *x2n = x_intr[1];
04820           *y2n = y_intr[1];
04821           *flag=2;return;
04822         }
04823       }
04824     }
04825     else 
04826       {
04827         /* count != 0 */
04828         *flag=0;return;
04829       }
04830   }
04831 }

Here is the call graph for this function:

void CPixmapResize1 ( void )

Definition at line 531 of file periWin.c.

References BCG::Cdrawable, CPixmapResize(), BCG::CWindow, and ScilabXgc.

00532 {
00533   if ( sciGetPixmapStatus() == 1 )
00534     sci_pixmap_resize(ScilabXgc,ScilabXgc->CWindowWidth,ScilabXgc->CWindowHeight);
00535 }

Here is the call graph for this function:

void deletePoints ( void )

Definition at line 4653 of file periWin.c.

References FREE, and NULL.

04654 {
04655   if( points != NULL )
04656   {
04657     FREE( points ) ;
04658     points = NULL ;
04659   }
04660 }

void C2F() displaynumbers	(	char *	str,
		integer *	x,
		integer *	y,
		integer *	v1,
		integer *	v2,
		integer *	n,
		integer *	flag,
		double *	z,
		double *	alpha,
		double *	dx3,
		double *	dx4
	)

Definition at line 4249 of file periWin.c.

References buf, C2F, BCG::CurNumberDispFormat, displaystring(), i, PD0, PI0, and ScilabXgc.

04261 { 
04262   char buf[20];
04263   integer i ;
04264   for (i=0 ; i< *n ; i++)
04265     {
04266       sprintf(buf,ScilabXgc->CurNumberDispFormat,z[i]);
04267       C2F(displaystring)(buf,&(x[i]),&(y[i]),PI0,flag,PI0,PI0,&(alpha[i]),PD0,PD0,PD0) ;
04268     }
04269 }

Here is the call graph for this function:

void C2F() displaystring	(	char *	string,
		integer *	x,
		integer *	y,
		integer *	v1,
		integer *	flag,
		integer *	v6,
		integer *	v7,
		double *	angle,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 2744 of file periWin.c.

References Abs, C2F, BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CWindow, dir, DispStringAngle(), drawrectangle(), BCG::FontXID, PD0, PI0, and ScilabXgc.

02748 { 
02749   if ( Abs(*angle) <= 0.1) 
02750     {
02751       if ( ScilabXgc->CurDrawFunction ==  GXxor )
02752         {
02753           SIZE size ;
02754           GetTextExtentPoint32(hdc,string,strlen(string),&size);
02755           XorString(*x,*y,string,size.cx,size.cy);
02756         }
02757       else
02758         {
02759           SetBkMode(hdc, TRANSPARENT); 
02760           TextOut(hdc,(int) *x,(int) *y,string,strlen(string));
02761           SetBkMode(hdc, OPAQUE); 
02762         }
02763       if ( *flag == 1) 
02764         {
02765           integer rect[4];
02766           C2F(boundingbox)(string,x,y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
02767           C2F(drawrectangle)(string,rect,rect+1,rect+2,rect+3,PI0,PI0,PD0,PD0,PD0,PD0);
02768         }
02769     }
02770   else 
02771     {
02772       C2F(DispStringAngle)(x,y,string,angle);
02773     }
02774 }

Here is the call graph for this function:

void C2F() drawarc	(	char *	str,
		integer *	x,
		integer *	y,
		integer *	width,
		integer *	height,
		integer *	angle1,
		integer *	angle2,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Draw a single ellipsis or part of it

Ellipse(hdc,(int) *x,(int) *y,(int) *width + *x ,(int) *height + *y );

180*64

Definition at line 3357 of file periWin.c.

References BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CWindow, and ScilabXgc.

03361 { 
03362   int xmid= *x + *width/2;
03363   int ymid= *y + *height/2;
03364   int lg= Max(*width,*height);
03365   SelectObject(hdc,GetStockObject(NULL_BRUSH));
03367   Arc(hdc,(int) *x,(int) *y,(int) *width + *x ,(int) *height + *y, 
03368       xmid + (int) (lg*cos(*angle1*M_PI/11520.00)),
03369       ymid - (int) (lg*sin(*angle1*M_PI/11520.00)),
03370       xmid + (int)  (lg*cos((*angle1+*angle2)*M_PI/11520.00)),
03371       ymid - (int)(lg*sin((*angle1+*angle2)*M_PI/11520.00))); 
03372   if ( ScilabXgc->hBrush != (HBRUSH) 0) SelectObject(hdc,ScilabXgc->hBrush);
03373 }

void C2F() drawarcs	(	char *	str,
		integer *	vects,
		integer *	style,
		integer *	n,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

caution : angle=degreangle*64

Definition at line 3328 of file periWin.c.

References C2F, drawarc(), i, PD0, PI0, xget_dash_and_color(), xset_dash_and_color(), and xset_line_style().

03340 {
03341   integer verbose=0,Dnarg,Dvalue[10],NDvalue,i;
03342   /* store the current values */
03343   C2F(get_dash_and_color)(&verbose,Dvalue,&Dnarg,vdouble);
03344   for (i=0 ; i< *n ; i++)
03345     {
03346       NDvalue = style[i];
03347       C2F(set_line_style)(&NDvalue,PI0,PI0,PI0);
03348       C2F(drawarc)(str,vects+6*i,vects+6*i+1,
03349                    vects+6*i+2,vects+6*i+3,
03350                    vects+6*i+4,vects+6*i+5,PD0,PD0,PD0,PD0);
03351     }
03352   C2F(set_dash_and_color)( Dvalue,PI0,PI0,PI0);
03353 }

Here is the call graph for this function:

void C2F() drawarrows	(	char *	str,
		integer *	vx,
		integer *	vy,
		integer *	n,
		integer *	as,
		integer *	style,
		integer *	iflag,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

as is 10*arsize (arsize) the size of the arrow head in pixels

Definition at line 3037 of file periWin.c.

References Abs, C2F, BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CWindow, dx, dy, fillpolylines(), i, inint, M_PI, p, PD0, PI0, ScilabXgc, SMDOUBLE, xget_dash_and_color(), xset_dash_and_color(), and xset_line_style().

03049 { 
03050   integer verbose=0,Dnarg,Dvalue[10],NDvalue,i;
03051   double cos20=cos(20.0*M_PI/180.0);
03052   double sin20=sin(20.0*M_PI/180.0);
03053   integer polyx[4],polyy[4];
03054   C2F(get_dash_and_color)(&verbose,Dvalue,&Dnarg,vdouble);
03055   for (i=0 ; i < *n/2 ; i++)
03056     { 
03057       double dx,dy,norm;
03058       if ( (int) *iflag == 1) 
03059         NDvalue = style[i];
03060       else 
03061         NDvalue=(*style < 1) ?  Dvalue[0] : *style;
03062       C2F(set_line_style)(&NDvalue,PI0,PI0,PI0);
03063       
03064       dx=( vx[2*i+1]-vx[2*i]);
03065       dy=( vy[2*i+1]-vy[2*i]);
03066       norm = sqrt(dx*dx+dy*dy);
03067       if ( Abs(norm) >  SMDOUBLE ) 
03068         { integer nn=1,p=3;
03069         dx=(*as/10.0)*dx/norm;dy=(*as/10.0)*dy/norm;
03070         polyx[0]= polyx[3]=vx[2*i+1];/* correction bug 607 (bruno 18 nov 2004) */
03071         polyx[1]= inint(polyx[0]  - cos20*dx -sin20*dy );
03072         polyx[2]= inint(polyx[0]  - cos20*dx + sin20*dy);
03073         polyy[0]= polyy[3]=vy[2*i+1];/* correction bug 607 (bruno 18 nov 2004) */
03074         polyy[1]= inint(polyy[0] + sin20*dx -cos20*dy) ;
03075         polyy[2]= inint(polyy[0] - sin20*dx - cos20*dy) ;
03076         C2F(fillpolylines)("v",polyx,polyy,&NDvalue, &nn,&p,PI0,PD0,PD0,PD0,PD0);
03077         }
03078       MoveToEx(hdc,(int) vx[2*i],(int) vy[2*i],NULL);
03079       LineTo(hdc,(int) (vx[2*i+1]-dx*cos20),(int) (vy[2*i+1]-dy*cos20));
03080       
03081 
03082     }
03083   C2F(set_dash_and_color)( Dvalue,PI0,PI0,PI0);
03084 }

Here is the call graph for this function:

void C2F() drawaxis	(	char *	str,
		integer *	alpha,
		integer *	nsteps,
		integer *	v2,
		integer *	initpoint,
		integer *	v6,
		integer *	v7,
		double *	size,
		double *	dx2,
		double *	dx3,
		double *	dx4
	)

Definition at line 4186 of file periWin.c.

References BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CWindow, i, inint, M_PI, ScilabXgc, xi, and yi.

04198 { integer i;
04199  double xi,yi,xf,yf;
04200  double cosal,sinal;
04201  cosal= cos( (double)M_PI * (*alpha)/180.0);
04202  sinal= sin( (double)M_PI * (*alpha)/180.0);
04203  for (i=0; i <= nsteps[0]*nsteps[1]; i++)
04204    {
04205      if ( ( i % nsteps[0]) != 0) 
04206        {
04207          xi = initpoint[0]+i*size[0]*cosal;
04208          yi = initpoint[1]+i*size[0]*sinal;
04209          xf = xi - ( size[1]*sinal);
04210          yf = yi + ( size[1]*cosal);
04211          MoveToEx(hdc,inint(xi),inint(yi),NULL);
04212          LineTo(hdc,inint(xf),inint(yf));
04213        }
04214    }
04215  for (i=0; i <= nsteps[1]; i++)
04216    { xi = initpoint[0]+i*nsteps[0]*size[0]*cosal;
04217    yi = initpoint[1]+i*nsteps[0]*size[0]*sinal;
04218    xf = xi - ( size[1]*size[2]*sinal);
04219    yf = yi + ( size[1]*size[2]*cosal);
04220    MoveToEx(hdc,inint(xi),inint(yi),NULL);
04221    LineTo(hdc,inint(xf),inint(yf));
04222    }
04230 }

void C2F() drawClippedPolyline	(	char *	str,
		integer *	n,
		integer *	vx,
		integer *	vy,
		integer *	closeflag,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

ths routine also perform clipping to avoid overflow

Definition at line 3506 of file periWin.c.

References analyze_points(), C2F, and n1.

03518 { 
03519   integer n1;
03520   if (*closeflag == 1) n1 = *n+1;else n1= *n;
03521   if (n1 >= 2) 
03522   {
03523     C2F(analyze_points)( *n, vx, vy, *closeflag );
03524   }
03525 }

Here is the call graph for this function:

void C2F() drawpolyline	(	char *	str,
		integer *	n,
		integer *	vx,
		integer *	vy,
		integer *	closeflag,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

n is the number of points of the polyline

Definition at line 3531 of file periWin.c.

References C2F, n1, store_points(), and XDroutine().

03543 { 
03544   integer n1;
03545   if (*closeflag == 1) n1 = *n+1;else n1= *n;
03546   if (n1 >= 2) 
03547   {
03548     if (C2F(store_points)(*n, vx, vy,*closeflag))
03549           {
03550             Polyline(hdc,C2F(ReturnPoints)(),(int) n1);
03551           } 
03552   }
03553 }

Here is the call graph for this function:

void C2F() drawpolylines	(	char *	str,
		integer *	vectsx,
		integer *	vectsy,
		integer *	drawvect,
		integer *	n,
		integer *	p,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

drawvect[i] < 0 use a line style for i

we use the markid : drawvect[i] : with current dash

we use the line-style number abs(drawvect[i])

back to default values

Definition at line 3401 of file periWin.c.

References C2F, close(), drawClippedPolyline(), drawpolymark(), i, PD0, PI0, xget_dash_and_color(), xget_mark(), xset_dash_and_color(), xset_line_style(), xset_mark(), and xset_pattern().

03413 { integer verbose=0 ,symb[2],Mnarg,Dnarg,Dvalue[10],NDvalue,i,close;
03414 /* store the current values */
03415  C2F(xgetmark)(&verbose,symb,&Mnarg,vdouble);
03416  C2F(get_dash_and_color)(&verbose,Dvalue,&Dnarg,vdouble);
03417  for (i=0 ; i< *n ; i++)
03418    {
03419      if (drawvect[i] <= 0)
03420        { 
03421          NDvalue = - drawvect[i] ;
03422          C2F(xsetmark)(&NDvalue,symb+1,PI0,PI0);
03423          C2F(setpattern)(Dvalue+6,PI0,PI0,PI0);
03424           
03425          C2F(drawpolymark)(str,p,vectsx+(*p)*i,vectsy+(*p)*i,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
03426        }
03427      else
03428        {
03429          C2F(set_line_style)(drawvect+i,PI0,PI0,PI0);
03430          close = 0;
03431          C2F(drawpolyline)(str,p,vectsx+(*p)*i,vectsy+(*p)*i,&close,
03432                            PI0,PI0,PD0,PD0,PD0,PD0);
03433        }
03434    }
03436  C2F(set_dash_and_color)( Dvalue,PI0,PI0,PI0);
03437  C2F(xsetmark)(symb,symb+1,PI0,PI0);
03438 }

Here is the call graph for this function:

void C2F() drawpolymark	(	char *	str,
		integer *	n,
		integer *	vx,
		integer *	vy,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

by vx and vy (vx[i],vy[i])

the symbol font

Definition at line 3580 of file periWin.c.

References C2F, BCG::Cdrawable, CoordModeOrigin, BCG::CurHardSymb, BCG::CurHardSymbSize, BCG::CurPixmapStatus, BCG::CWindow, DrawMark(), BCG::FontId, BCG::FontSize, get_xpoints(), i, L, PI0, ScilabXgc, store_points(), XDrawPoints(), and xset_font().

03592 {
03593   if ( ScilabXgc->CurHardSymb == 0 )
03594     {
03595       if (C2F(store_points)(*n, vx, vy,0L))             
03596         {
03597           XDrawPoints (hdc,C2F(ReturnPoints)(), *n);
03598         }
03599     }
03600   else 
03601     { 
03602       integer i,keepid,keepsize,hds;
03603       i=1; 
03604       keepid =  ScilabXgc->FontId;
03605       keepsize= ScilabXgc->FontSize;
03606       hds= ScilabXgc->CurHardSymbSize;
03607       C2F(xsetfont)(&i,&hds,PI0,PI0);
03608       for ( i=0; i< *n ;i++) DrawMark(hdc,vx+i,vy+i);
03609       C2F(xsetfont)(&keepid,&keepsize,PI0,PI0);
03610     }
03611 }

Here is the call graph for this function:

void C2F() drawrectangle	(	char *	str,
		integer *	x,
		integer *	y,
		integer *	width,
		integer *	height,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Draw one rectangle with current line style

Definition at line 3140 of file periWin.c.

References BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CWindow, and ScilabXgc.

03152 { 
03153   SelectObject(hdc,GetStockObject(NULL_BRUSH));
03154   /* +1 added for correct 2d axis necessary !! **/
03155   Rectangle(hdc,(int) *x,(int) *y,(int) *width+*x+1 ,(int) *height+*y+1);
03156   if ( ScilabXgc->hBrush != (HBRUSH) 0) 
03157     SelectObject(hdc,ScilabXgc->hBrush);
03158 }

void C2F() drawrectangles	(	char *	str,
		integer *	vects,
		integer *	fillvect,
		integer *	n,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

if fillvect[i] is < 0 then draw the rectangle with -fillvect[i]

Definition at line 3097 of file periWin.c.

References C2F, drawrectangle(), fillrectangle(), i, PD0, PI0, xget_dash_and_color(), xget_pattern(), xset_dash_and_color(), xset_line_style(), and xset_pattern().

03109 {
03110   integer i,cpat,verbose=0,num,cd[10];
03111   C2F(getpattern)(&verbose,&cpat,&num,vdouble);
03112 
03113   C2F(get_dash_and_color)(&verbose,cd,&num,vdouble);
03114   for (i=0 ; i< *n ; i++)
03115     {
03116       if (fillvect[i] < 0)
03117         {
03118           int dash = - fillvect[i];
03119           C2F(set_line_style)(&dash,PI0,PI0,PI0);
03120           C2F(drawrectangle)(str,vects+4*i,vects+4*i+1,vects+4*i+2,vects+4*i+3
03121                              ,PI0,PI0,PD0,PD0,PD0,PD0);
03122         }
03123       else if (fillvect[i] == 0)
03124         {
03125           /* C2F(set_line_style)(&cd,PI0,PI0,PI0);*/
03126           C2F(drawrectangle)(str,vects+4*i,vects+4*i+1,vects+4*i+2,vects+4*i+3
03127                              ,PI0,PI0,PD0,PD0,PD0,PD0);
03128         }
03129       else
03130         {
03131           C2F(setpattern)(&(fillvect[i]),PI0,PI0,PI0);
03132           C2F(fillrectangle)(str,vects+4*i,vects+4*i+1,vects+4*i+2,vects+4*i+3,PI0,PI0,PD0,PD0,PD0,PD0);
03133         }
03134     }
03135   C2F(set_dash_and_color)(&(cd[0]),PI0,PI0,PI0);
03136 }

Here is the call graph for this function:

void C2F() drawsegments	(	char *	str,
		integer *	vx,
		integer *	vy,
		integer *	n,
		integer *	style,
		integer *	iflag,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

n is the size of vx and vy

Definition at line 2992 of file periWin.c.

References BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CWindow, i, PI0, ScilabXgc, xget_dash_and_color(), xset_dash_and_color(), and xset_line_style().

03004 {
03005   integer verbose=0,Dnarg,Dvalue[10],NDvalue;
03006   integer i ;
03007 
03008   C2F(get_dash_and_color)(&verbose,Dvalue,&Dnarg,vdouble);
03009 
03010 
03011   if ( (int) *iflag == 1) { /* one style per segment */
03012     for (i=0 ; i < *n/2 ; i++) {
03013       NDvalue = style[i];
03014       C2F(set_line_style)(&NDvalue,PI0,PI0,PI0);
03015       MoveToEx(hdc,(int) vx[2*i],(int) vy[2*i],NULL);
03016       LineTo(hdc,(int) vx[2*i+1],(int) vy[2*i+1]);
03017     }
03018   }
03019   else {
03020     if (*style >= 1) /* set color */
03021       C2F(set_line_style)(style,PI0,PI0,PI0);
03022 
03023     for (i=0 ; i < *n/2 ; i++) {
03024       MoveToEx(hdc,(int) vx[2*i],(int) vy[2*i],NULL);
03025       LineTo(hdc,(int) vx[2*i+1],(int) vy[2*i+1]);
03026     }
03027   }
03028   C2F(set_dash_and_color)( Dvalue,PI0,PI0,PI0);
03029 }

Here is the call graph for this function:

void C2F() fillarc	(	char *	str,
		integer *	x,
		integer *	y,
		integer *	width,
		integer *	height,
		integer *	angle1,
		integer *	angle2,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Fill a single elipsis or part of it with current pattern

Ellipse(hdc,(int) *x,(int) *y,(int)*width+*x ,(int)*height+*y );

180*64

Definition at line 3376 of file periWin.c.

References BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CWindow, and ScilabXgc.

03380 {
03381   int xmid= *x + *width/2;
03382   int ymid= *y + *height/2;
03383   int lg= Max(*width,*height);
03385   Pie(hdc,(int) *x,(int) *y,(int) *width + *x ,(int) *height + *y, 
03386       xmid +(int)  (lg*cos(*angle1*M_PI/11520.00)),
03387       ymid - (int) (lg*sin(*angle1*M_PI/11520.00)),
03388       xmid+(int) (lg*cos((*angle1+*angle2)*M_PI/11520.00)),
03389       ymid - (int) (lg*sin((*angle1+*angle2)*M_PI/11520.00))); 
03390 }

void C2F() fillarcs	(	char *	str,
		integer *	vects,
		integer *	fillvect,
		integer *	n,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

The drawing style is the current drawing

Definition at line 3284 of file periWin.c.

References C2F, drawarc(), fillarc(), i, BCG::IDLastPattern, PD0, PI0, ScilabXgc, xget_pattern(), and xset_pattern().

03296 {
03297   integer i,cpat,verb,num;
03298   verb=0;
03299   C2F(getpattern)(&verb,&cpat,&num,vdouble);
03300   for (i=0 ; i< *n ; i++)
03301     {
03302       if (fillvect[i] > ScilabXgc->IDLastPattern + 1)
03303         {
03304           C2F(setpattern)(&(cpat),PI0,PI0,PI0);
03305           C2F(drawarc)(str,vects+6*i,vects+6*i+1,
03306                        vects+6*i+2,vects+6*i+3,
03307                        vects+6*i+4,vects+6*i+5,PD0,PD0,PD0,PD0);
03308         }
03309       else
03310         {
03311           C2F(setpattern)(&(fillvect[i]),PI0,PI0,PI0);
03312           C2F(fillarc)(str,vects+6*i,vects+6*i+1,
03313                        vects+6*i+2,vects+6*i+3,
03314                        vects+6*i+4,vects+6*i+5,PD0,PD0,PD0,PD0);
03315         }
03316     }
03317   C2F(setpattern)(&(cpat),PI0,PI0,PI0);
03318 }

Here is the call graph for this function:

void C2F() fillpolyline	(	char *	str,
		integer *	n,
		integer *	vx,
		integer *	vy,
		integer *	closeflag,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

according to *closeflag : the given vector is a polyline or a polygon

Definition at line 3557 of file periWin.c.

References C2F, BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CurVectorStyle, BCG::CWindow, get_xpoints(), n1, ScilabXgc, and store_points().

03569 {
03570   integer n1;
03571   if (*closeflag == 1) n1 = *n+1;else n1= *n;
03572   if (C2F(store_points)(*n, vx, vy,*closeflag))
03573     {
03574       Polygon(hdc,C2F(ReturnPoints)(), n1);
03575     }
03576 }

Here is the call graph for this function:

void C2F() fillpolylines	(	char *	str,
		integer *	vectsx,
		integer *	vectsy,
		integer *	fillvect,
		integer *	n,
		integer *	p,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

fill a set of polygons each of which is defined by (*p) points (*n) is the number of polygons the polygon is closed by the routine fillvect[*n] : fillvect[*n] : if fillvect[i] == 0 draw the boundaries with current color if fillvect[i] > 0 draw the boundaries with current color then fill with pattern fillvect[i] if fillvect[i] < 0 fill with pattern - fillvect[i]

fill + boundaries

boundaries ONLY

fill ONLY

Definition at line 3451 of file periWin.c.

References C2F, close(), drawClippedPolyline(), fillpolyline(), i, PD0, PI0, xget_dash_and_color(), xget_pattern(), xset_dash_and_color(), xset_line_style(), and xset_pattern().

03463 {
03464   integer Dnarg,Dvalue[10];
03465   integer i,cpat,verbose=0,num,close=1,pattern;
03466   C2F(getpattern)(&verbose,&cpat,&num,vdouble);
03467   C2F(get_dash_and_color)(&verbose,Dvalue,&Dnarg,vdouble);
03468   for (i=0 ; i< *n ; i++)
03469     {
03470       if (fillvect[i] > 0) 
03471         { 
03473           C2F(setpattern)(&fillvect[i],PI0,PI0,PI0);
03474           C2F(fillpolyline)(str,p,vectsx+(*p)*i,vectsy+(*p)*i,(close=1,&close),
03475                             PI0,PI0,PD0,PD0,PD0,PD0);
03476           C2F(set_line_style)(Dvalue,PI0,PI0,PI0);
03477           C2F(setpattern)(&(cpat),PI0,PI0,PI0);
03478           C2F(drawpolyline)(str,p,vectsx+(*p)*i,vectsy+(*p)*i,(close=1,&close)
03479                             ,PI0,PI0,PD0,PD0,PD0,PD0);
03480         }
03481       else  if (fillvect[i] == 0 )
03482         {
03483           C2F(set_line_style)(Dvalue,PI0,PI0,PI0);
03484           C2F(setpattern)(&cpat,PI0,PI0,PI0);
03485           C2F(drawpolyline)(str,p,vectsx+(*p)*i,vectsy+(*p)*i,(close=0,&close)
03486                             ,PI0,PI0,PD0,PD0,PD0,PD0);
03487         }
03488       else 
03489         {
03490           pattern = -fillvect[i] ;
03491           C2F(setpattern)(&pattern,PI0,PI0,PI0);
03492           C2F(fillpolyline)(str,p,vectsx+(*p)*i,vectsy+(*p)*i,(close=0,&close)
03493                             ,PI0,PI0,PD0,PD0,PD0,PD0);
03494         }
03495     }
03496   C2F(set_dash_and_color)(Dvalue,PI0,PI0,PI0); 
03497 }

Here is the call graph for this function:

void C2F() fillrectangle	(	char *	str,
		integer *	x,
		integer *	y,
		integer *	width,
		integer *	height,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

fill one rectangle, with current pattern

Rectangle with current pen and brush

Definition at line 3162 of file periWin.c.

References BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CWindow, and ScilabXgc.

03174 { 
03176   Rectangle(hdc,(int) *x,(int) *y,(int) *width + *x+1 ,(int) *height + *y+1 );
03177 }

void get_b	(	int	i,
		float *	b
	)

Definition at line 2562 of file periWin.c.

References BCG::Blue, and ScilabXgc.

02565 {
02566   *b = ScilabXgc->Blue[i];
02567 }

void get_g	(	int	i,
		float *	g
	)

Definition at line 2555 of file periWin.c.

References BCG::Green, and ScilabXgc.

02558 {
02559   *g = ScilabXgc->Green[i];
02560 }

void get_r	(	int	i,
		float *	r
	)

Definition at line 2548 of file periWin.c.

References BCG::Red, and ScilabXgc.

02551 {
02552   *r = ScilabXgc->Red[i];
02553 }

void getcolordef ( integer * screenc )

Definition at line 4090 of file periWin.c.

04091 {
04092   *screenc= screencolor;
04093 }

void C2F() getFontMaxSize	(	char *	str,
		integer *	sizeMin,
		integer *	sizeMax,
		integer *	v1,
		integer *	v2,
		integer *	v3,
		integer *	v4,
		double *	dx1,
		double *	dx2,
		double *	dx3,
		double *	dx4
	)

get the minimal and maximal font size the driver can display

Definition at line 4235 of file periWin.c.

References FONTMAXSIZE.

04238 {
04239   *sizeMin = 0 ;
04240   *sizeMax = FONTMAXSIZE ;
04241 }

void C2F() getwindowdim	(	integer *	verbose,
		integer *	x,
		integer *	narg,
		double *	dummy
	)

To get the drawbox window size : used by periGif

Definition at line 1037 of file periWin.c.

References xget_windowdim().

01038 {     
01039   *narg = 2;
01040   /* on renvoie la taille de la fenetre virtuelle */
01041   /* windows devrait s'occupper de tout afficher correctement */
01042   x[0]= ScilabXgc->CWindowWidth;
01043   x[1]= ScilabXgc->CWindowHeight;
01044   if (*verbose == 1) 
01045     sciprint("\n CWindow dim :%d,%d\r\n",(int) x[0],(int) x[1]);
01046 }

Here is the call graph for this function:

void C2F() initgraphic	(	char *	string,
		integer *	v2,
		integer *	v3,
		integer *	v4,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

EntryCounter is used to check for first Entry + to now an available number

This is done only at the first entry

Initialize default Scilab Xgc

Default value is without Pixmap

Definition at line 3749 of file periWin.c.

References AddMenu(), AddNewWindowToList(), C2F, BCG::CBGWindow, CreatePatterns(), CreatePopupWindow(), BCG::CurPixmapStatus, BCG::CurResizeStatus, BCG::CurWindow, BCG::CWindow, BCG::CWindowHeight, BCG::CWindowWidth, DisplayInit(), GXcopy, ierr, InitMissileXgc(), LoadFonts(), Max, ne, NULL, PI0, BCG::popup, refreshMenus(), ScilabXgc, sciprint(), TCLinterp, TKmainWindow, and X_error_handler().

03761 { 
03762         static char popupname[sizeof("ScilabGraphic")+4];
03763         static char winname[sizeof("BG")+4];
03764         struct BCG *NewXgc ;
03765         RECT rect,rect1;
03766         static integer EntryCounter = 0;
03767         integer WinNum;
03768         static HMENU sysmenu;
03769         SCROLLINFO vertsi;
03770         SCROLLINFO horzsi;
03771 
03772         if ( v2 != (integer *) NULL && *v2 != -1 )
03773         {
03774                 WinNum= *v2;
03775         }
03776         else
03777         {
03778                 WinNum= EntryCounter;
03779         }
03780 
03781         if (EntryCounter == 0)
03782         {
03784                 screencolor = 1;
03785                 if (C2F(AllocVectorStorage)()==0) return;
03786                 graphwin.xmax = WIN_XMAX;
03787                 graphwin.ymax = WIN_YMAX;
03788                 if (! graphwin.hPrevInstance) 
03789                 {
03790                         CreateGraphClass();
03791                 }
03793         }
03794 
03795         if (( NewXgc = AddNewWindowToList()) == (struct BCG *) 0)
03796         {
03797                 Scistring("initgraphics: unable to alloc\n");
03798                 return;
03799         }
03800         else
03801         {
03802                 ScilabXgc= NewXgc;
03803         }
03808         /* Probleme graphwin peut etre locké par une autre fonction */
03809         /* Faire une copie serait preferable */
03810         ScilabXgc->lpgw = &graphwin;
03811 
03812         sprintf(popupname,"ScilabGraphic%d", (int)WinNum);
03813         if (EntryCounter == 0)
03814         {
03815                 ReadRegistryGraph(ScilabXgc);
03816         }
03817         ScilabXgc->Inside_init=1; 
03819         ScilabXgc->hWndParent = CreateWindow(szParentGraphClass, popupname,
03820                         WS_OVERLAPPEDWINDOW,
03821                         graphwin.Origin.x, graphwin.Origin.y,
03822                         graphwin.Size.x, graphwin.Size.y,
03823                         NULL, NULL, graphwin.hInstance, 
03824                         NewXgc);
03825 
03826         if (ScilabXgc->hWndParent == (HWND)NULL)
03827         {
03828                 MessageBox((HWND)NULL,"Couldn't open parent graph window",(LPSTR)NULL, MB_ICONHAND | MB_SYSTEMMODAL);
03829                 return;
03830         }
03831         ShowWindow(ScilabXgc->hWndParent,  SW_SHOWNORMAL);
03832         ScilabXgc->Statusbar =  InitStatusBar (ScilabXgc->hWndParent);
03833         ShowWindow(ScilabXgc->Statusbar,  SW_SHOWNORMAL);
03834         GetWindowRect (ScilabXgc->Statusbar, &rect1) ;
03835         GetClientRect(ScilabXgc->hWndParent, &rect);
03836 
03837         MoveWindow(ScilabXgc->Statusbar, 0, rect.bottom -( rect1.bottom - rect1.top),
03838         rect.right,  ( rect1.bottom - rect1.top), TRUE) ;
03839 
03840         sprintf((char *)winname,"BG%d", (int)WinNum);
03841 
03842         ScilabXgc->CWindowWidth =  rect.right;
03843         ScilabXgc->CWindowHeight = rect.bottom - ( rect1.bottom - rect1.top);
03844 
03845         ScilabXgc->CWindow = CreateWindow(szGraphClass, winname,
03846                 WS_CHILD | WS_VSCROLL | WS_HSCROLL,
03847                 0, graphwin.ButtonHeight,
03848                 ScilabXgc->CWindowWidth,
03849                 ScilabXgc->CWindowHeight,
03850                 ScilabXgc->hWndParent,
03851                 NULL, graphwin.hInstance,
03852                 NewXgc);
03853 
03854         ScilabXgc->CurResizeStatus = 1;
03855         ScilabXgc->CWindowWidthView  = ScilabXgc->CWindowWidth;
03856         ScilabXgc->CWindowHeightView = ScilabXgc->CWindowHeight;
03857 
03858         /* definition des scroll bars verticalles */
03859         vertsi.cbSize = sizeof(SCROLLINFO);
03860         vertsi.fMask  = SIF_RANGE | SIF_PAGE | SIF_POS;
03861         vertsi.nMin   = 0;
03862         vertsi.nMax   = ScilabXgc->CWindowHeight;
03863         vertsi.nPage  = ScilabXgc->CWindowHeightView;
03864         vertsi.nPos   = 0;
03865         sciSetScrollInfo(ScilabXgc,SB_VERT, &(vertsi), TRUE);
03866         sciGetScrollInfo(ScilabXgc,SB_VERT, &vertsi);
03867 
03868         /* definition des scroll bars horizontalle */
03869         horzsi.cbSize = sizeof(SCROLLINFO);
03870         horzsi.fMask  = SIF_RANGE | SIF_PAGE | SIF_POS;
03871         horzsi.nMin   = 0;
03872         horzsi.nMax   = ScilabXgc->CWindowWidth;
03873         horzsi.nPage  = ScilabXgc->CWindowWidthView;
03874         horzsi.nPos   = 0;
03875         sciSetScrollInfo(ScilabXgc,SB_HORZ, &horzsi, TRUE);       
03876         sciGetScrollInfo(ScilabXgc,SB_HORZ, &horzsi);
03877         
03878         if (ScilabXgc->CWindow == (HWND)NULL) 
03879         {
03880                 MessageBox((HWND)NULL,"Couldn't open graphic window",(LPSTR)NULL, MB_ICONHAND | MB_SYSTEMMODAL);
03881                 return;
03882         }
03883 
03884         ShowWindow(ScilabXgc->CWindow, SW_SHOWNORMAL);
03885         ShowWindow(ScilabXgc->hWndParent,  SW_SHOWNORMAL);
03886         graphwin.resized = FALSE;
03887         /*UpdateFileGraphNameMenu( ScilabXgc);
03888         LoadGraphMacros( ScilabXgc);*/
03890         ScilabXgc->CurPixmapStatus = 0;
03891         ScilabXgc->CurResizeStatus = 1;
03892         ScilabXgc->CurWindow = WinNum;
03893         /* on fait un SetWinhdc car on vient de creer la fenetre */
03894         /* le release est fait par Xcall.c */
03895         SetWinhdc();
03896         SetMapMode(hdc, MM_TEXT);
03897         SetBkMode(hdc,TRANSPARENT);
03898         GetClientRect(ScilabXgc->CWindow, &rect);
03899         SetViewportExtEx(hdc, rect.right, rect.bottom,NULL);
03900         SetTextAlign(hdc, TA_LEFT|TA_BOTTOM);
03901         SetFocus( ScilabXgc->CWindow);
03902         if (EntryCounter == 0)
03903         {
03904                 C2F(CreatePatterns)();
03905                 LoadFonts();
03906         } 
03907         InitMissileXgc(PI0,PI0,PI0,PI0);/* a laisser ici */
03908         /* to be sure that current values are recorded */  
03909         /*StoreXgc(WinNum);*/
03910         EntryCounter=Max(EntryCounter,WinNum);
03911         EntryCounter++;
03912                 
03913         /* see ../wsci/wgmenu.c */
03914         CreateGedMenus(ScilabXgc);        
03915         CreateGraphToolBar(ScilabXgc);    
03916 
03917         ScilabXgc->Inside_init=0;
03918 }

Here is the call graph for this function:

void C2F() loadfamily	(	char *	name,
		integer *	j,
		integer *	v3,
		integer *	v4,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 4377 of file periWin.c.

References C2F, fname, FontInfoTab_, FONTMAXSIZE, fonttab, i, loadfamily_n(), FontAlias::name, NULL, FontInfo::ok, sciprint(), and strchr().

04381 { 
04382   integer i;
04384   i=0;
04385   while ( fonttab[i].alias != (char *) NULL)
04386     {
04387       if (strcmp(fonttab[i].alias,name)==0)
04388         {
04389           C2F(loadfamily_n)(fonttab[i].Winname,j);
04390           return ;
04391         }
04392       i++;
04393     }
04394   C2F(loadfamily_n)(name,j);
04395 }

Here is the call graph for this function:

void C2F() MissileGCget	(	char *	str,
		integer *	verbose,
		integer *	x1,
		integer *	x2,
		integer *	x3,
		integer *	x4,
		integer *	x5,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 2703 of file periWin.c.

References C2F, L, and MissileGCGetorSet().

02708 { 
02709   int x6=0;
02710   C2F(MissileGCGetorSet)(str,1L,verbose,x1,x2,x3,x4,x5,&x6,dv1);
02711 }

Here is the call graph for this function:

void C2F() MissileGCset	(	char *	str,
		integer *	x1,
		integer *	x2,
		integer *	x3,
		integer *	x4,
		integer *	x5,
		integer *	x6,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 2713 of file periWin.c.

References C2F, L, and MissileGCGetorSet().

02725 {
02726   integer verbose=0 ;
02727   C2F(MissileGCGetorSet)(str,0L,&verbose,x1,x2,x3,x4,x5,x6,dv1);
02728 }

Here is the call graph for this function:

void C2F() queryfamily	(	char *	name,
		integer *	j,
		integer *	v3,
		integer *	v4,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 4397 of file periWin.c.

References fname, FontInfoTab_, FONTNUMBER, and fonttab.

04409 { 
04410   integer i ;
04411   name[0]='\0';
04412   // for (i=0;i<FONTNUMBER;i++) { //Pb here: fonttab size is 10 and i goes from 0 to 10 included 
04413   // fonttab[10] is "{(char *) NULL,( char *) NULL}" F.Leray 24.02.04
04414   // Pb fixed by setting FONTNUMBER to 10
04415   
04416   for (i=0;i<FONTNUMBER;i++) {
04417     v3[i]=strlen((*FontTab)[i].fname);
04418     if (v3[i] > 0)
04419       strcat(name,(*FontTab)[i].fname);
04420     else {
04421       v3[i]=strlen(fonttab[i].Winname);
04422       strcat(name,fonttab[i].Winname);
04423     }
04424   }
04425   *j=FONTNUMBER;
04426 }

int C2F() sedeco ( int * flag )

Definition at line 2024 of file periWin.c.

02025 {
02026   set_default_colormap_flag = *flag;
02027   return(0);
02028 }

void set_clip_box	(	integer	xxleft,
		integer	xxright,
		integer	yybot,
		integer	yytop
	)

Definition at line 4711 of file periWin.c.

04715 {
04716   xleft=xxleft;
04717   xright=xxright;
04718   ybot=yybot;
04719   ytop=yytop;
04720 }

void setcolordef ( int screenc )

Definition at line 4636 of file periX11.c.

04637 {
04638   screencolor = screenc;
04639 }

void C2F() SetDriver ( )

void C2F() setpopupname	(	char *	x0,
		integer *	v2,
		integer *	v3,
		integer *	v4,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4,
		integer	lx0
	)

Definition at line 429 of file periX11.c.

References Setpopupname().

00430 {
00431   Setpopupname(x0);
00432 }

Here is the call graph for this function:

int C2F() store_points	(	integer	n,
		integer *	vx,
		integer *	vy,
		integer	onemore
	)

Definition at line 4616 of file periWin.c.

References INT_2_16B, n1, and ReallocVector().

04617 { 
04618   integer i,n1;
04619   if ( onemore == 1) n1=n+1;
04620   else n1=n;
04621   if (ReallocVector(n1) == 1)
04622     {
04623       for (i = 0; i < n; i++){
04624         points[i].x = INT_2_16B( vx[i] ) ;
04625         points[i].y = INT_2_16B( vy[i] ) ;
04626       }
04627       if (onemore == 1) {
04628         points[n].x=(short) points[0].x;
04629         points[n].y=(short) points[0].y;
04630       }
04631       return(1);
04632     }
04633   else return(0);
04634 }

Here is the call graph for this function:

void SwitchWindow ( integer * intnum )

Definition at line 784 of file periX11.c.

00785 {
00787   struct BCG *SXgc;
00788   integer ierr;
00789   SXgc = getWindowXgcNumber(*intnum);
00790   if ( SXgc != (struct BCG *) 0 ) 
00791     {
00793       ScilabXgc = SXgc ;
00794       ResetScilabXgc ();
00795       get_window_scale(*intnum,NULL);
00796     }
00797   else 
00798     {
00800       C2F(initgraphic)("",intnum,&ierr,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
00801     }
00802 }

void C2F() viderbuff ( )

void C2F() xclick	(	char *	str,
		integer *	ibutton,
		integer *	x1,
		integer *	yy1,
		integer *	iflag,
		integer *	istr,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 865 of file periWin.c.

References lstr, and SciClick().

00872 {
00873   integer lstr ;
00874   SciClick(ibutton,x1, yy1,iflag,0,0,*istr,str,&lstr);
00875   if ( *istr == 1) 
00876     {
00877       if (*ibutton == -2) 
00878         {
00879           /*sciprint("Menu activated %s %d",str,lstr);*/
00880           *istr = lstr;
00881         }
00882       else
00883         *istr = 0;
00884     }
00885 }

Here is the call graph for this function:

void C2F() xclick_any	(	char *	str,
		integer *	ibutton,
		integer *	x1,
		integer *	yy1,
		integer *	iwin,
		integer *	iflag,
		integer *	istr,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

returns the graphic window number which owns the event

if we already have something on the queue

first check if an event has been store in the queue while wait_for_click was 0

Check menu activation

Cleanup

Definition at line 708 of file periWin.c.

References C2F, CheckClickQueue(), ClearClickQueue(), getmen(), GetWindowNumber(), getWinsMaxId(), i, ismenu(), lstr, NULL, ok, set_client_message_off(), set_client_message_on(), set_event_select(), and set_wait_click().

00709 {
00710   integer win;
00711   integer wincount;
00712   integer lstr ;
00713   int motion,release,ok;
00714   // reinitialisation à -1
00715   // correction bg
00716   // plot2d();  => fermer la fenêtre du plot avec la croix.
00717   // plot2d();
00718   // [c_i,c_x,c_y,c_w,c_m]=xclick()
00719   // ==> xclick renvoie le code -100 pour le bouton ce qui correspond à une fermeture de fenêtre
00720   deleted_win = -1;
00721 
00722   wincount =  getWinsMaxId() + 1 ;
00723   if (wincount == 0) 
00724     {
00725       *x1=0;
00726       *yy1=0;
00727       *iwin=0;
00728       *ibutton = -100;
00729       *istr = 0;
00730       return;
00731     }
00732   
00733 
00734   if ( *iflag ==0 )  ClearClickQueue(-1); /*clear the queue if required*/
00735  
00737   set_wait_click(1); /*disable event handler if any */
00738   set_event_select(1+4); /* select press and release events*/
00739   while (1) 
00740     {
00741       win=-1;
00742       ok=0;
00743       while (CheckClickQueue(&win,x1,yy1,ibutton,&motion,&release) == 1) {
00744         if ((motion==0) && (release==0)) {
00745           *iwin = win ;
00746           ok=1;
00747           break;
00748         }
00749 
00750         win=-1;
00751       }
00752       if(ok) {*istr = 0;break;};
00753       /* get next event */
00754       C2F(sxevents)();
00755       Sleep(1);
00756 
00757       if ( deleted_win != -1 )
00758         {
00759           /* a graphic window was deleted we quit */
00760           *iwin = deleted_win;
00761           deleted_win = -1;
00762           *x1= 0;
00763           *yy1 = 0;
00764           *ibutton    = -100;
00765           set_wait_click(0);
00766           return ;
00767         }
00768 
00770       if ( *istr==1 && C2F(ismenu)()==1 ) 
00771         {
00772           int entry;
00773           C2F(getmen)(str,&lstr,&entry);
00774           *ibutton = -2;
00775           *istr=lstr;
00776           *x1=0;
00777           *yy1=0;
00778           *iwin=-1;
00779           break;
00780         }
00781 
00782     }
00783   set_wait_click(0);
00784 }

Here is the call graph for this function:

void XDroutine ( int npts )

Definition at line 4428 of file periX11.c.

References BCG::Cdrawable, BCG::CurPixmapStatus, BCG::CurVectorStyle, BCG::CWindow, get_xpoints(), and ScilabXgc.

Referenced by drawpolyline().

04429 {
04430   if (ScilabXgc->Cdrawable != (Drawable) 0)
04431     XDrawLines (dpy, ScilabXgc->Cdrawable, gc, get_xpoints(),(int) npts,
04432                 ScilabXgc->CurVectorStyle);
04433   if (ScilabXgc->CurPixmapStatus != 1) 
04434     XDrawLines (dpy, (Drawable) ScilabXgc->CWindow, gc, get_xpoints(),(int) npts,
04435                 ScilabXgc->CurVectorStyle);
04436 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C2F() xend	(	char *	v1,
		integer *	v2,
		integer *	v3,
		integer *	v4,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 571 of file periWin.c.

00583 {
00585 }

void C2F() xgetmouse	(	char *	str,
		integer *	ibutton,
		integer *	x1,
		integer *	yy1,
		integer *	iflag,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 887 of file periWin.c.

References NULL, and SciClick().

00894 {
00895   SciClick(ibutton,x1, yy1,iflag,v6[0],v6[1],0,(char *) 0,(integer *)0);
00896 }

Here is the call graph for this function:

void C2F() xinfo	(	char *	message,
		integer *	v2,
		integer *	v3,
		integer *	v4,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

Definition at line 3993 of file periWin.c.

References args, BCG::CinfoW, NULL, ScilabXgc, and XtNlabel.

03997 {
03998   if ( ScilabXgc != (struct BCG *) 0 && ScilabXgc->Statusbar != (HWND) 0)
03999     {
04000       (BOOL)SendMessage(ScilabXgc->Statusbar, SB_SETTEXT, (WPARAM) 0, 
04001                         (LPARAM) (LPSTR) message );
04002     }
04003 }

void C2F() xselgraphic	(	char *	v1,
		integer *	v2,
		integer *	v3,
		integer *	v4,
		integer *	v5,
		integer *	v6,
		integer *	v7,
		double *	dv1,
		double *	dv2,
		double *	dv3,
		double *	dv4
	)

If there's no graphic window then select creates one

Test not really usefull: see sciwin in matdes.f

Definition at line 545 of file periWin.c.

References C2F, BCG::CBGWindow, ierr, initgraphic(), NULL, PD0, PI0, and ScilabXgc.

00557 { 
00558   integer ierr;
00559   if (ScilabXgc == (struct BCG *)0 || ScilabXgc->CWindow == (HWND) NULL) 
00560     C2F(initgraphic)("",PI0,&ierr,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
00561   if (IsIconic(ScilabXgc->hWndParent)) 
00562     ShowWindow(ScilabXgc->hWndParent, SW_SHOWNORMAL);
00563   BringWindowToTop(ScilabXgc->hWndParent);
00564 }

Here is the call graph for this function:


Functions
void	XDroutine (int npts)
void C2F()	drawarc (char str, integer x, integer y, integer width, integer height, integer angle1, integer angle2, double dv1, double dv2, double dv3, double *dv4)
void C2F()	fillarcs (char str, integer vects, integer fillvect, integer n, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	drawarcs (char str, integer vects, integer style, integer n, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	fillpolyline (char str, integer n, integer vx, integer vy, integer closeflag, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	drawaxis (char str, integer alpha, integer nsteps, integer v2, integer initpoint, integer v6, integer v7, double size, double dx2, double dx3, double *dx4)
void C2F()	cleararea (char str, integer x, integer y, integer w, integer h, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	clearwindow (char v1, integer v2, integer v3, integer v4, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	xclick (char str, integer ibutton, integer x1, integer yy1, integer iflag, integer istr, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	xclick_any (char str, integer ibutton, integer x1, integer yy1, integer iwin, integer iflag, integer istr, double dv1, double dv2, double dv3, double *dv4)
void C2F()	xgetmouse (char str, integer ibutton, integer x1, integer yy1, integer iflag, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	xend (char v1, integer v2, integer v3, integer v4, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	fillarc (char str, integer x, integer y, integer width, integer height, integer angle1, integer angle2, double dv1, double dv2, double dv3, double *dv4)
void C2F()	viderbuff ()
void C2F()	fillrectangle (char str, integer x, integer y, integer width, integer height, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	MissileGCget (char str, integer verbose, integer x1, integer x2, integer x3, integer x4, integer x5, double dv1, double dv2, double dv3, double *dv4)
void C2F()	initgraphic (char string, integer v2, integer v3, integer v4, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	drawpolyline (char str, integer n, integer vx, integer vy, integer closeflag, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	drawClippedPolyline (char str, integer n, integer vx, integer vy, integer closeflag, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	fillpolylines (char str, integer vectsx, integer vectsy, integer fillvect, integer n, integer p, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	drawpolylines (char str, integer vectsx, integer vectsy, integer drawvect, integer n, integer p, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	drawpolymark (char str, integer n, integer vx, integer vy, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	getFontMaxSize (char str, integer sizeMin, integer sizeMax, integer v1, integer v2, integer v3, integer v4, double dx1, double dx2, double dx3, double *dx4)
void C2F()	displaynumbers (char str, integer x, integer y, integer v1, integer v2, integer n, integer flag, double z, double alpha, double dx3, double *dx4)
void C2F()	drawrectangle (char str, integer x, integer y, integer width, integer height, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	drawrectangles (char str, integer vects, integer fillvect, integer n, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	drawsegments (char str, integer vx, integer vy, integer n, integer style, integer iflag, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	xselgraphic (char v1, integer v2, integer v3, integer v4, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	MissileGCset (char str, integer x1, integer x2, integer x3, integer x4, integer x5, integer x6, double dv1, double dv2, double dv3, double *dv4)
void C2F()	SetDriver ()
void C2F()	displaystring (char string, integer x, integer y, integer v1, integer flag, integer v6, integer v7, double angle, double dv2, double dv3, double *dv4)
void C2F()	boundingbox (char string, integer x, integer y, integer rect, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	drawarrows (char str, integer vx, integer vy, integer n, integer as, integer style, integer iflag, double dv1, double dv2, double dv3, double *dv4)
void C2F()	loadfamily (char name, integer j, integer v3, integer v4, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	queryfamily (char name, integer j, integer v3, integer v4, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	xinfo (char message, integer v2, integer v3, integer v4, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4)
void C2F()	setpopupname (char x0, integer v2, integer v3, integer v4, integer v5, integer v6, integer v7, double dv1, double dv2, double dv3, double *dv4, integer lx0)
void	deletePoints (void)
void	set_clip_box (integer xxleft, integer xxright, integer yybot, integer yytop)
void	clip_line (integer x1, integer yy1, integer x2, integer y2, integer x1n, integer yy1n, integer x2n, integer y2n, integer *flag)
int	CheckColormap (int *m)
void	getcolordef (integer *screenc)
void	setcolordef (int screenc)
void	get_r (int i, float *r)
void	get_g (int i, float *g)
void	get_b (int i, float *b)
void C2F()	getwindowdim (integer verbose, integer x, integer narg, double dummy)
int C2F()	sedeco (int *flag)
void	CPixmapResize1 (void)
void	SwitchWindow (integer *intnum)
int C2F()	store_points (integer n, integer vx, integer vy, integer onemore)

periX11.h File Reference

Functions

Function Documentation