hgraf_win32.c

隐马尔科夫模型工具箱

{
   int i;
   HDC dc;
   HGDIOBJ oldObject;

   if (n>MAX_POINT)
      HError(6815, "HDrawLines: can only specify up to %d points",MAX_POINT);
   for(i=0; i<n; i++) {
      winPoints[i].x=points[i].x;
      winPoints[i].y=points[i].y;
   }
   dc = GetDC(theWindow);
   oldObject = SelectObject(memDC,thePen);
   Polyline(memDC, winPoints, n);
   SelectObject(memDC,oldObject);
     
   oldObject = SelectObject(dc,thePen);
   Polyline(dc, winPoints, n);
   SelectObject(dc,oldObject);
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> HDrawRectangle: draw a rectangle */
void HDrawRectangle(int x0, int y0, int x1, int y1)
{
   POINT points[5];
   HGDIOBJ oldObject = SelectObject(memDC,thePen);
   HDC dc = GetDC(theWindow);
     
   CheckCorners(&x0,&y0,&x1,&y1);
   points[0].x = x0; points[0].y = y0;
   points[1].x = x0; points[1].y = y1;
   points[2].x = x1; points[2].y = y1;
   points[3].x = x1; points[3].y = y0;
   points[4].x = x0; points[4].y = y0;
     
   Polyline(memDC, points, 5);
   SelectObject(memDC,oldObject);
     
   oldObject = SelectObject(dc,thePen);
   Polyline(dc, points, 5);
   SelectObject(dc,oldObject);
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> HFillRectangle: fill a rectangle */
void HFillRectangle(int x0, int y0, int x1, int y1)
{
   HDC dc = GetDC(theWindow);
   HGDIOBJ oldBrush = SelectObject(memDC,theBrush);
   HGDIOBJ oldPen = SelectObject(memDC,thinPen);
     
   CheckCorners(&x0,&y0,&x1,&y1);
     
   Rectangle(memDC,x0,y0,x1,y1);
     
   SelectObject(memDC,oldBrush);
   SelectObject(memDC,oldPen);
     
   oldBrush = SelectObject(dc,theBrush);
   oldPen = SelectObject(dc,thinPen);
   Rectangle(dc,x0,y0,x1,y1);
   SelectObject(dc,oldBrush);
   SelectObject(dc,oldPen);
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> HDrawLine: Draw one line */
void HDrawLine(int x0, int y0, int x1, int y1)
{
   HDC dc = GetDC(theWindow);
   HGDIOBJ oldObject = SelectObject(memDC,thePen);
     
   MoveToEx(memDC,x0,y0,NULL);
   LineTo(memDC,x1,y1);

   SelectObject(memDC,oldObject);
     
   oldObject = SelectObject(dc,thePen);
   MoveToEx(dc,x0,y0,NULL);
   LineTo(dc,x1,y1);
   SelectObject(dc,oldObject);
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> HFillPolygon: fill a convex polygon */
void HFillPolygon(HPoint *points, int n)
{
   int i;
   HDC dc;
   HGDIOBJ oldPen;
   HGDIOBJ oldBrush;

   if (n>MAX_POINT)
      HError(6815, "HFillPolygon: can only specify up to %d points",MAX_POINT);
   for(i=0; i<n; i++) {
      winPoints[i].x=points[i].x;
      winPoints[i].y=points[i].y;
   }
   dc = GetDC(theWindow);
   oldPen = SelectObject(memDC,thinPen);
   oldBrush = SelectObject(memDC,theBrush);
     
   Polygon(memDC,winPoints,n);
     
   SelectObject(memDC,oldBrush);
   SelectObject(memDC,oldPen);
     
   oldBrush = SelectObject(dc,theBrush);
   oldPen = SelectObject(dc,thinPen);
   Polygon(dc,winPoints,n);
   SelectObject(dc,oldBrush);
   SelectObject(dc,oldPen);
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> HDrawArc: Draw arc from stAngle thru arcAngle degrees */
void HDrawArc(int x0, int y0, int x1, int y1, int stAngle, int arcAngle)
{
   int Center_x = (x0+x1)/2;
   int Center_y = (y0+y1)/2;
   int StartArc_x, StartArc_y;
   int EndArc_x, EndArc_y;
   int radius; /* major axis */
   double startAngle, endAngle,convrt = PI/180; /* degrees to radians */
   HGDIOBJ oldObject = SelectObject(memDC,thePen);
   HDC dc = GetDC(theWindow);
     
   CheckCorners(&x0,&y0,&x1,&y1);
     
   startAngle = stAngle *convrt; 
   endAngle=(arcAngle+stAngle)*convrt;
     
   radius = (((x1-x0) > (y1-y0)) ? x1-x0 : y1-y0)/2;
   StartArc_x = Center_x + (int) (radius * cos((double) startAngle));
   StartArc_y = Center_y - (int) (radius * sin((double) startAngle));
   EndArc_x = Center_x + (int) (radius * cos((double) endAngle));
   EndArc_y = Center_y - (int) (radius * sin((double) endAngle));
     
   Arc(memDC,x0,y0,x1,y1,StartArc_x,StartArc_y,EndArc_x,EndArc_y);
   SelectObject(memDC,oldObject);
     
   oldObject = SelectObject(dc,thePen);
   Arc(dc,x0,y0,x1,y1,StartArc_x,StartArc_y,EndArc_x,EndArc_y);
   SelectObject(dc,oldObject);
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> HFillArc: Draw filled arc from stAngle thru arcAngle degrees */
void HFillArc(int x0,int y0,int x1,int y1,int stAngle,int arcAngle)
{
   int radius;
   int Center_x = (x0+x1)/2;
   int Center_y = (y0+y1)/2;
   int StartArc_x,StartArc_y;
   int EndArc_x,EndArc_y;
   HGDIOBJ oldBrush = SelectObject(memDC,theBrush);
   HGDIOBJ oldPen = SelectObject(memDC,thinPen);
   HDC dc = GetDC(theWindow);
   double startAngle, endAngle,convrt = PI/180; /* degrees to radians */
     
   CheckCorners(&x0,&y0,&x1,&y1);
     
   /* calculate point locations */
     
   startAngle = stAngle*convrt; 
   endAngle = (stAngle+arcAngle)*convrt;
     
   radius = (((x1-x0) > (y1-y0)) ? x1-x0 : y1-y0)/2;
   StartArc_x = Center_x + (int) (radius * cos((double) startAngle));
   StartArc_y = Center_y - (int) (radius * sin((double) startAngle));
   EndArc_x = Center_x + (int) (radius * cos((double) endAngle));
   EndArc_y = Center_y - (int) (radius * sin((double) endAngle));
     
   Pie(memDC,x0,y0,x1,y1,StartArc_x,StartArc_y,EndArc_x,EndArc_y);
     
   SelectObject(memDC,oldBrush);
   SelectObject(memDC,oldPen);
     
   oldBrush = SelectObject(dc,theBrush);
   oldPen = SelectObject(dc,thinPen);
   Pie(dc,x0,y0,x1,y1,StartArc_x,StartArc_y,EndArc_x,EndArc_y);
   SelectObject(dc,oldBrush);
   SelectObject(dc,oldPen);
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> HPrintf: works as printf on the graphics window at (x,y) */
void HPrintf(int x, int y, char *format, ...)
{ 
   va_list arg;
   char s[256];
   HGDIOBJ oldObject = SelectObject(memDC,theFont);
   HDC dc = GetDC(theWindow);
     
   SetTextColor(memDC,CurrentColour);   
   va_start(arg, format);
   vsprintf(s, format, arg);
     
   TextOut(memDC,x,y,s,strlen(s)); 
   SelectObject(memDC,oldObject);
     
   oldObject = SelectObject(dc,theFont);
   TextOut(dc,x,y,s,strlen(s)); 
   SelectObject(dc,oldObject);
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> copy rectangular area of the drawable */
void HCopyArea(int srcx, int srcy, int width, int height, int destx, int desty)
{
   HDC dc = GetDC(theWindow);
   BitBlt(memDC,destx,desty,width,height,memDC,srcx,srcy,SRCCOPY);
   BitBlt(dc,destx,desty,width,height,memDC,srcx,srcy,SRCCOPY);
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> HPlotVector: plot vector v in given rectangle */
void HPlotVector(int x0, int y0, int x1, int y1, Vector v, int st, int en, float ymax, float ymin)
{
   float yScale, yOffset, xInc, x;
   int   xOld, yOld, ix, iy, i;
     
   if (st >= en || st < 1 || en > VectorSize(v))
      HError(6815, "HPlotVector: Plot indices %d -> %d out of range", st, en);
   x = (x1 - x0 - 1); xInc = x/(en - st);
   yScale  = (y1 - y0)/(ymin - ymax);
   yOffset = y0 - ymax*yScale;
   x = x0; xOld = x; yOld = v[st]*yScale + yOffset;
   for (i = st+1; i <= en; i++){
      x += xInc; ix = x;
      iy = v[i]*yScale + yOffset;
      HDrawLine(xOld,yOld,ix,iy);
      xOld = ix; yOld = iy;
   } 
}

/* ----------------------------- Global Settings ------------------------------- */

/* EXPORT-> HSetFontSize: Set font size in points, 0 selects the default font */
void HSetFontSize(int size)
{  
   int FontSize = (size > 0) ? size : DEF_FONTSIZE;
     
   if (theFont) DeleteObject(theFont);
   theFont = CreateFont(FontSize,
                        0,0,0,FW_NORMAL,
                        0,0,0,ANSI_CHARSET,
                        OUT_DEFAULT_PRECIS,
                        CLIP_DEFAULT_PRECIS,
                        DEFAULT_QUALITY,
                        DEFAULT_PITCH | FF_SWISS,
                        FONTNAME); 
}

/* EXPORT-> HSetLineWidth: set the line width */
void HSetLineWidth(int w)
{
   LineWidth = w;
     
   if (thePen) DeleteObject(thePen);
   thePen = CreatePen(PS_SOLID,LineWidth,CurrentColour);
}

/* EXPORT-> HSetXMode: Set current transfer mode */
void HSetXMode(XferMode m)
{ 
   HDC dc = GetDC(theWindow);
   switch(m) {
   case GCOPY:
      SetROP2(memDC,R2_COPYPEN);
      SetROP2(dc,R2_COPYPEN);
      break;
   case GOR:
      SetROP2(memDC,R2_MERGEPEN);
      SetROP2(dc,R2_MERGEPEN);
      break;
   case GXOR:
      SetROP2(memDC,R2_XORPEN);
      SetROP2(dc,R2_XORPEN);
      break;
   case GINVERT: 
      SetROP2(memDC,R2_NOT);
      SetROP2(dc,R2_NOT);
      break;
   default: /* GCOPY */
      SetROP2(memDC,R2_COPYPEN);
      SetROP2(dc,R2_COPYPEN);
      break;
   }
   ReleaseDC(theWindow,dc);
}

/* EXPORT-> CentreX: return position at which the the h-center of str will be at x */
int CentreX(int x, char *str)
{
   SIZE size;
     
   GetTextExtentPoint32(memDC,str,strlen(str),&size);
   return  (x-size.cx/2);
}

/* EXPORT-> CentreY: return position at which the the v-center of str will be at y */
int CentreY(int y, char *str)
{
   HDC dc;
   HGDIOBJ obj;
   TEXTMETRIC tm;
   int pos;

   dc = GetDC(theWindow);
   obj = SelectObject(dc,theFont);
   GetTextMetrics(dc,&tm);
   pos = (y - ((tm.tmAscent + tm.tmDescent)/2) + tm.tmAscent);
   SelectObject(dc,obj);
   return pos;
}

/* EXPORT HTextWidth: return the width of s in pixels */
int HTextWidth(char *str)
{
   SIZE size;
     
   GetTextExtentPoint32(memDC,str,strlen(str),&size);
   return  (size.cx);
}

/* EXPORT HTextHeight: return the height of s in pixels */
int HTextHeight(char *str)
{
   SIZE size;
     
   GetTextExtentPoint32(memDC,str,strlen(str),&size);
   return  (size.cy);
}

/* --------------------------- Misc/Button Routines -----------------------------*/

/* EXPORT->HDrawImage: draw grey scale image stored in p */
void HDrawImage(unsigned char *p, int x, int y, int width, int height)
{
   HDC tdc = GetDC(theWindow);
   HDC dc = CreateCompatibleDC(memDC);
   HBITMAP bm = CreateCompatibleBitmap(tdc,width,height);
   HGDIOBJ OldObject;

   char *data = New(&gcheap,sizeof(BITMAPINFOHEADER) + 
                    sizeof(RGBQUAD)*MAX_GREYS);
   BITMAPINFOHEADER *BitmapHeader = (BITMAPINFOHEADER *) data;
   RGBQUAD *ColorTable = (RGBQUAD *) (data + sizeof(BITMAPINFOHEADER));
   BITMAPINFO *Info = (BITMAPINFO *) data;

   int i,j;

   /* if the length of the scan line is not a */
   /* multiple of four, the bitmap must be reshaped. */
   /* SetDIBits() expects scan lines to start on word boundaries. */

   int ScanLineLen = 4*(1+(width-1)/4);  
   unsigned char *reshaped = NULL;       

   BitmapHeader->biSize = sizeof(BITMAPINFOHEADER);
   BitmapHeader->biWidth = width;
   BitmapHeader->biHeight = -height;
   BitmapHeader->biPlanes = 1;
   BitmapHeader->biBitCount = 8;
   BitmapHeader->biCompression = 0;
   BitmapHeader->biSizeImage = 0;
   BitmapHeader->biXPelsPerMeter = 0;
   BitmapHeader->biYPelsPerMeter = 0;
   BitmapHeader->biClrUsed = MAX_GREYS;
   BitmapHeader->biClrImportant = MAX_GREYS;
   for (i=0;i<MAX_GREYS;i++) {
      ColorTable[i].rgbRed =
         ColorTable[i].rgbBlue =
         ColorTable[i].rgbGreen = greys[i];
      ColorTable[i].rgbReserved = 0;
   }

   if (ScanLineLen != width) {
      reshaped = (unsigned char *) New(&gcheap,height*ScanLineLen);
      for (i=0;i<height;i++) {
         for (j=0;j<width;j++) {
            reshaped[i*ScanLineLen+j] = p[i*width+j];
         }
      }
      SetDIBits(memDC,bm,0,height,reshaped,Info,DIB_RGB_COLORS);
      Dispose(&gcheap,reshaped);
   }
   else {
      SetDIBits(memDC,bm,0,height,p,Info,DIB_RGB_COLORS);
   }

   OldObject = SelectObject(dc,bm);
   BitBlt(memDC,x,y,width,height,dc,0,0,SRCCOPY);
   if (WritingToMeta) { /* bitmap source location differs */
      BitBlt(tdc,x,y,width,height,dc,x,y,SRCCOPY);
   }
   else {
      BitBlt(tdc,x,y,width,height,dc,0,0,SRCCOPY);