graphic.c

YBasic编程语言的移植和开发 YBasic编程语言的移植和开发 YBasic编程语言的移植和开发

static void startdraw(int clear) /* prepare for drawing */
{
  RECT interior;
  int fault=FALSE;
  HANDLE r;
		
  devcon=GetDC(window);
  if (clear) {
    r=SelectObject(devcon,backpen);
    r=SelectObject(bitcon,backpen);
  } else {
    r=SelectObject(devcon,GetStockObject(BLACK_PEN));
    r=SelectObject(bitcon,GetStockObject(BLACK_PEN));
  }
  if (clear) {
    r=SelectObject(devcon,backbrush);
    r=SelectObject(bitcon,backbrush);
  } else {
    r=SelectObject(devcon,GetStockObject(BLACK_BRUSH));
    r=SelectObject(bitcon,GetStockObject(BLACK_BRUSH));
  }
  GetClientRect(window,&interior);
  SelectClipRgn(devcon,NULL);
  IntersectClipRect(devcon,interior.left,interior.top,
		    interior.right,interior.bottom);
  if (printer) {
    fault=fault || !SelectObject(printer,printerfont);
    if (clear)
      fault=fault || !SelectObject(printer,GetStockObject(WHITE_BRUSH));
    else
      fault=fault || !SelectObject(printer,GetStockObject(BLACK_BRUSH));
    if (clear)
      fault=fault || (SelectObject(printer,revprinterpen)==NULL);
    else
      fault=fault || (SelectObject(printer,printerpen)==NULL);
    if (fault) error(ERROR,"could not prepare printer");
    return;
  }
}


char *getreg(char *name) /* get defaults from Registry */
{
  char *keyname="SOFTWARE\\yabasic";
  HKEY key;
  char reg[80];
  DWORD n;
		
  RegOpenKeyEx(HKEY_LOCAL_MACHINE,keyname,0,KEY_ALL_ACCESS,&key);
  n=80;
  reg[0]='\0';
  RegQueryValueEx(key,name,NULL,NULL,reg,&n);
  if (reg[0]=='\0') return NULL;
  return my_strdup(reg);
}
#endif


static int grafinit(void)  /* initialize grafics (either X or Windows) */
{
  
#ifdef UNIX
  static int screen; /* Number of Screen on Display */
  static XColor asked,got; /* color is complex ... */
  static Colormap map; /* my color map */
  static XGCValues xgcvalues; /* Values for Graphics Context */
  static unsigned int w,h; /* width and height of window */
#elif WINDOWS
  int n;
  int f; /* int-value of font */
  char *family; /* font family */
#endif
  
#ifdef UNIX
  
  /* get display */
  display=XOpenDisplay(displayname);
  if (display==NULL) {
    error(ERROR,"Can't open Display");
    return FALSE;
  }
  
  /* get screen */
  screen=DefaultScreen(display);
  root=RootWindow(display,screen);
  
  /* care for colors */
  if (DefaultDepth(display,screen)==1) {  /* BW-Screen ? */
    f_color=BlackPixel(display,screen);
    b_color=WhitePixel(display,screen); }
  else {
    map=DefaultColormap(display,screen);
    if (foreground==NULL) 
      foreground=XGetDefault(display,"yabasic","foreground");
    if (foreground==NULL) foreground="black";
    
    if (!XAllocNamedColor(display,map,foreground,&got,&asked)) {
      sprintf(string,"could not get fg-color '%s', trying 'black' instead",
	      foreground);
      error(WARNING,string);
      if (!XAllocNamedColor(display,map,"black",&got,&asked)) {
        error(ERROR,"could not get it");
        return FALSE;
      }
    }
    f_color=got.pixel;
    
    if (background==NULL) 
      background=XGetDefault(display,"yabasic","background");
    if (background==NULL) background="white";
    if (!XAllocNamedColor(display,map,background,&got,&asked)) {
      sprintf(string,"could not get bg-color '%s', trying 'white' instead",
	      background);
      error(WARNING,string);
      if (!XAllocNamedColor(display,map,"white", &got,&asked)) {
        error(ERROR,"could not get it");
        return FALSE;
      }
    }
    b_color=got.pixel;
  }
  
  /* get size hints */
  if (geometry==NULL) geometry=XGetDefault(display,"yabasic","geometry");
  XParseGeometry(geometry,&winx,&winy,&w,&h);
  sizehints.x=winx;
  sizehints.y=winy;
  sizehints.flags=USPosition;
  
  /* get font height */
  if (!font) font=XGetDefault(display,"yabasic","font");
  if (!font) font="6x10";
  myfont=XLoadQueryFont(display,font);
  if (!myfont) {
    sprintf(string,"could not load font '%s', trying 'fixed' instead",font);
    error(WARNING,string);
    myfont=XLoadQueryFont(display,"fixed");
    if (!myfont) {
      error(ERROR,"could not get it");
      return FALSE;
    }
  }
  xgcvalues.font=myfont->fid;
  fontheight=myfont->ascent;
  
  /* create graphics context, accept defaults ... */
  xgcvalues.foreground=f_color;
  xgcvalues.background=b_color;
  gc=XCreateGC(display,root,GCForeground|GCBackground|GCFont,&xgcvalues);
  /* create graphics context for reverse drawing */
  xgcvalues.foreground=b_color;
  xgcvalues.background=f_color;
  rgc=XCreateGC(display,root,GCForeground|GCBackground,&xgcvalues);
  
#elif WINDOWS
  /* choose font */
  if (!font) font=getreg("font");
  if (!font) font="swiss13";
  f=FF_SWISS;
  fontheight=13;    
  
  family=my_strdup(font);
  for(n=0;*(family+n)!='\0' && !isdigit(*(family+n));n++)
    *(family+n)=tolower((int)*(family+n));
  if (isdigit(*(family+n))) sscanf(family+n,"%d",&fontheight);
  *(family+n)='\0';
  
  if (!strcmp("decorative",family)) f=FF_DECORATIVE;
  else if (!strcmp("dontcare",family)) f=FF_DONTCARE;
  else if (!strcmp("modern",family)) f=FF_MODERN;
  else if (!strcmp("roman",family)) f=FF_ROMAN;
  else if (!strcmp("script",family)) f=FF_SCRIPT;
  else if (!strcmp("swiss",family)) f=FF_SWISS;
  else {
    sprintf(string,"Don't know font '%s' using 'swiss' instead",font);
    error(WARNING,string);
    f=FF_SWISS;
  }
  
  logfont.lfHeight=-fontheight;
  logfont.lfWidth=0;
  logfont.lfEscapement=0;
  logfont.lfOrientation=0;
  logfont.lfWeight=FW_DONTCARE;
  logfont.lfItalic=FALSE;
  logfont.lfUnderline=FALSE;
  logfont.lfStrikeOut=FALSE;
  logfont.lfCharSet=DEFAULT_CHARSET;
  logfont.lfOutPrecision=OUT_DEFAULT_PRECIS;
  logfont.lfClipPrecision=CLIP_DEFAULT_PRECIS;
  logfont.lfQuality=DEFAULT_QUALITY;
  logfont.lfPitchAndFamily=DEFAULT_PITCH | f;
  logfont.lfFaceName[0]='\0';
  myfont=CreateFontIndirect(&logfont);
  
  if (myfont==NULL) {
    sprintf(string,"Could not create font '%s' for screen",font);
    error(ERROR,string);
    return FALSE;
  }
#endif
  return TRUE;
}


#ifdef UNIX
void calc_psscale()  /* calculate scale-factor for postscript */
{
  if ((float)winwidth/winheight>(float)18/25)
    psscale=18*0.39*72/winwidth;
  else
    psscale=25*0.39*72/winheight;
}
#endif


void putindrawmode(int mode) /* store drawmode in previous command */
{
  if (mode)
    lastcmd->tag=mode;
  else
    lastcmd->tag=drawmode;
  drawmode=0;
}


void dot(struct command *cmd) /* draw a dot */
{
  double x,y;
  int clear;
   
  y=pop(stNUMBER)->value;
  x=pop(stNUMBER)->value;
  transform(&x,&y);
  clear=cmd->tag & dmCLEAR;
  if (!winopened) {
    error(ERROR,"Got no window to draw");
    return;
  }
#ifdef UNIX
  if (clear) {
    XDrawPoint(display,window,rgc,x,y);
    XDrawPoint(display,backbit,rgc,x,y);
  } else {
    XDrawPoint(display,window,gc,x,y);
    XDrawPoint(display,backbit,gc,x,y);
  }
  XFlush(display);
  if (printerfile) {
    fprintf(printerfile,"%g %g (%c) DO\n",
	    (x-0.5)*psscale,(winheight-y+0.5)*psscale,clear?'y':'n');
  }
#elif WINDOWS
  startdraw(clear);
  if (clear) {
    SetPixelV(devcon,(int)x,(int)y,backpixel);
    SetPixelV(bitcon,(int)x,(int)y,backpixel);
    if (printer) {
      MoveToEx(printer,(int)(x*prnscale+prnoffx),(int)(y*prnscale+prnoffy),NULL);
      LineTo(printer,(int)(x*prnscale+prnoffx),(int)(y*prnscale+prnoffy));
    }
  } else {
    SetPixelV(devcon,(int)x,(int)y,RGB(0,0,0));
    SetPixelV(bitcon,(int)x,(int)y,RGB(0,0,0));
    if (printer) {
      MoveToEx(printer,(int)(x*prnscale+prnoffx),(int)(y*prnscale+prnoffy),NULL);
      LineTo(printer,(int)(x*prnscale+prnoffx),(int)(y*prnscale+prnoffy));
    }
  }
  ReleaseDC(window,devcon);
#endif
}


void create_line(int numpoints) /* create Command 'line' */
{
  struct command *cmd;
  
  cmd=add_command(cLINE,FALSE);
  cmd->args=numpoints;
  cmd->tag=dmNORMAL;
}


void line(struct command *cmd) /* draw a line */
{
  double x1,y1,x2,y2;
  static double lastx,lasty;
  static int lastvalid=FALSE;
  static double initialx,initialy;
  static int initialvalid=FALSE;  
  int numpoints;
  int clear;
  
  if (!winopened) {
    error(ERROR,"Got no window to draw");
    return;
  }
  
  clear=cmd->tag & dmCLEAR;
  numpoints=cmd->args;
  if (numpoints==-1) { /* new curve */
    lastvalid=FALSE;
    initialvalid=FALSE;
    return;
  } else if (numpoints==0) { /* close curve */
    if (!lastvalid || !initialvalid) return;
    lastvalid=FALSE;
    initialvalid=FALSE;
    x1=lastx;
    y1=lasty;
    x2=initialx;
    y2=initialy;
  } else { /* line to x2,y2 */
    y2=pop(stNUMBER)->value;
    x2=pop(stNUMBER)->value;
    if (numpoints==1) {
      if (!lastvalid) {
	initialx=lastx=x2;
	initialy=lasty=y2;
	initialvalid=lastvalid=TRUE;
	return;
      }
      y1=lasty;
      x1=lastx;
    } else { /* line x1,y1 to x2,y2 */
      y1=pop(stNUMBER)->value;
      x1=pop(stNUMBER)->value;
    }
  }
  lastx=x2;
  lasty=y2;
  if (!initialvalid) {
    initialx=x1;
    initialy=y2;
    initialvalid=TRUE;
  }
  transform(&x1,&y1);
  transform(&x2,&y2);
  
#ifdef UNIX
  if (clear) {
    XDrawLine(display,window,rgc,x1,y1,x2,y2);
    XDrawLine(display,backbit,rgc,x1,y1,x2,y2);
  } else {
    XDrawLine(display,window,gc,x1,y1,x2,y2);
    XDrawLine(display,backbit,gc,x1,y1,x2,y2);
  }
  XFlush(display);
  if(printerfile) {
    fprintf(printerfile,"%g %g %g %g (%c) LI\n",
	    x1*psscale,(winheight-y1)*psscale,
	    x2*psscale,(winheight-y2)*psscale,clear?'y':'n');
  }
  fflush(printerfile);
#elif WINDOWS
  startdraw(clear);
  MoveToEx(devcon,(int)x1,(int)y1,NULL);
  LineTo(devcon,(int)x2,(int)y2);
  if (clear)
    SetPixelV(devcon,(int)x2,(int)y2,backpixel);
  else
    SetPixelV(devcon,(int)x2,(int)y2,RGB(0,0,0));
  MoveToEx(bitcon,(int)x1,(int)y1,NULL);
  LineTo(bitcon,(int)x2,(int)y2);
  if (clear)
    SetPixelV(bitcon,(int)x2,(int)y2,backpixel);
  else
    SetPixelV(bitcon,(int)x2,(int)y2,RGB(0,0,0));
  
  if (printer) {
    MoveToEx(printer,(int)(x1*prnscale+prnoffx),(int)(y1*prnscale+prnoffy),NULL);
    LineTo(printer,(int)(x2*prnscale+prnoffx),(int)(y2*prnscale+prnoffy));
  }
  ReleaseDC(window,devcon);
#endif
}


void circle(struct command *cmd) /* draw a circle */
{
  double x,y,r;
  int fill,clear;
  
  fill=cmd->tag & dmFILL;
  clear=cmd->tag & dmCLEAR;
  r=pop(stNUMBER)->value;
  y=pop(stNUMBER)->value;
  x=pop(stNUMBER)->value;
  transform(&x,&y);
  if (!winopened) {
    error(ERROR,"Got no window to draw");
    return;
  }
#ifdef UNIX
  if (clear) {
    if (fill) {
      XFillArc(display,window,rgc,x-r,y-r,2*r,2*r,0*64,360*64);
      XFillArc(display,backbit,rgc,x-r,y-r,2*r,2*r,0*64,360*64);
    } else {
      XDrawArc(display,window,rgc,x-r,y-r,2*r,2*r,0*64,360*64);
      XDrawArc(display,backbit,rgc,x-r,y-r,2*r,2*r,0*64,360*64);
    }
  } else {
    if (fill) {
      XFillArc(display,window,gc,x-r,y-r,2*r,2*r,0*64,360*64);
      XFillArc(display,backbit,gc,x-r,y-r,2*r,2*r,0*64,360*64);
    } else {
      XDrawArc(display,window,gc,x-r,y-r,2*r,2*r,0*64,360*64);
      XDrawArc(display,backbit,gc,x-r,y-r,2*r,2*r,0*64,360*64);
    }
  }
    
  XFlush(display);
  if(printerfile) {
    fprintf(printerfile,"N\n");
    fprintf(printerfile,"%g %g %g (%c) (%c) CI\n",
	    (winheight-y)*psscale,x*psscale,r*psscale,
	    clear?'y':'n',fill?'y':'n');
    fflush(printerfile);
  }
#else /* WINDOWS */
  startdraw(clear);
  if (fill) {
    Ellipse(devcon,(int)(x-r),(int)(y-r),(int)(x+r),(int)(y+r));
    Ellipse(bitcon,(int)(x-r),(int)(y-r),(int)(x+r),(int)(y+r));
    if (printer) {
      Ellipse(printer,(int)((x-r)*prnscale+prnoffx),(int)((y-r)*prnscale+prnoffy),
	      (int)((x+r)*prnscale+prnoffx),(int)((y+r)*prnscale+prnoffy)); 
    }
  } else {
    Arc(devcon,(int)(x-r),(int)(y-r),(int)(x+r),(int)(y+r),0,0,0,0);
    Arc(bitcon,(int)(x-r),(int)(y-r),(int)(x+r),(int)(y+r),0,0,0,0);
    if (printer) {
      Arc(printer,(int)((x-r)*prnscale+prnoffx),(int)((y-r)*prnscale+prnoffy),
	  (int)((x+r)*prnscale+prnoffx),(int)((y+r)*prnscale+prnoffy),0,0,0,0); 
    }
  }
  ReleaseDC(window,devcon);
#endif
}


void create_text(int has_alignement) /* create Command 'text' */
{
  struct command *cmd;
  
  cmd=add_command(cTEXT,FALSE);
  cmd->args=has_alignement;
}


void text(struct command *cmd) /* write a text */
{
  double x,y;
  char *text,*align;
  int xoff,yoff,len;
#ifdef UNIX
  int i,d1,d2,d3; /* dummies */
  XCharStruct size;
  static char *sample="The Quick Brown Fox Jumped Over The Lazy Dog 0123456789";
#else
  UINT algn;
#endif
  
  
  if (cmd->args) {
    align=pop(stSTRING)->pointer;
    if (!check_alignement(align)) return;
  }    
  else {
    align=text_align;
  }