home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / bench / bench.c next >
Encoding:
C/C++ Source or Header  |  1990-12-02  |  37.1 KB  |  1,428 lines
  1. /*    Bench.c (c) Axel Salomon, 1990, Public Domain   */
  2.  
  3. #define INCL_DOS
  4. #define INCL_WIN
  5. #define INCL_GPI
  6.  
  7. #include <os2.h>
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <time.h>
  12. #include "bench.h"
  13.  
  14. #define FLOAT float
  15. #define MIN(a,b)     ( a<b ? a : b )
  16.  
  17. MRESULT EXPENTRY BenchProc (HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2);
  18.  
  19. VOID cdecl main (VOID);
  20. VOID do_paint   (HWND hwnd);
  21. VOID do_size    (MPARAM mp2);
  22. VOID do_command (HWND hwnd, MPARAM mp1);
  23. VOID do_clear_screen( HWND hwnd );
  24. INT  do_init    (VOID);
  25.  
  26. VOID Display_Time( HWND hwnd);
  27. LONG Calc_MSec( PDATETIME dt );
  28. LONG Calc_Fraction( LONG value );
  29.  
  30. VOID do_gpi_fonts_box     (HWND hwnd);
  31. VOID do_gpi_fonts_chars   (HWND hwnd);
  32. VOID do_gpi_fonts_direct  (HWND hwnd);
  33. VOID do_gpi_fonts_angle   (HWND hwnd);
  34. VOID do_gpi_fonts_shear   (HWND hwnd);
  35. VOID do_gpi_fonts_all     (HWND hwnd);
  36.  
  37. VOID do_gpi_lines_arcs    (HWND hwnd);
  38. VOID do_gpi_lines_boxes   (HWND hwnd);
  39. VOID do_gpi_lines_fillets (HWND hwnd);
  40. VOID do_gpi_lines_lines   (HWND hwnd);
  41. VOID do_gpi_lines_splines (HWND hwnd);
  42. VOID do_gpi_lines_styles  (HWND hwnd);
  43. VOID do_gpi_lines_all     (HWND hwnd);
  44.  
  45. VOID do_gpi_marker_all    (HWND hwnd);
  46. VOID do_gpi_marker_box    (HWND hwnd);
  47. VOID do_gpi_marker_poly   (HWND hwnd);
  48. VOID do_gpi_marker_single (HWND hwnd);
  49. VOID do_gpi_marker_userdef(HWND hwnd);
  50.  
  51. VOID do_gpi_paths_ends    (HWND hwnd);
  52. VOID do_gpi_paths_fill    (HWND hwnd);
  53. VOID do_gpi_paths_join    (HWND hwnd); 
  54. VOID do_gpi_paths_lines   (HWND hwnd);
  55. VOID do_gpi_paths_pattern (HWND hwnd);
  56. VOID do_gpi_paths_width   (HWND hwnd);
  57. VOID do_gpi_paths_all     (HWND hwnd);
  58.  
  59. VOID do_gpi_all           (HWND hwnd);
  60. VOID do_gpi_extend        (HWND hwnd);
  61.   
  62. HAB      hab;
  63. HMQ      hmq;
  64. HDC      hdc;
  65. HWND     hwndMainFrame,hwndMainClient;
  66.  
  67. POINTL   center;
  68. INT      cx,cy;
  69.  
  70. DATETIME start_dt,ende_dt;
  71.  
  72. LONG colors[16] = { CLR_BLACK,
  73.                     CLR_DARKBLUE,
  74.                     CLR_DARKGREEN,
  75.                     CLR_DARKCYAN,
  76.                     CLR_DARKPINK,
  77.                     CLR_DARKRED,
  78.                     CLR_BROWN,
  79.                     CLR_PALEGRAY,
  80.                     CLR_DARKGRAY,
  81.                     CLR_BLUE,
  82.                     CLR_GREEN, 
  83.                     CLR_CYAN,
  84.                     CLR_PINK,
  85.                     CLR_RED,
  86.                     CLR_YELLOW,
  87.                     CLR_WHITE };
  88.  
  89. LONG linetype[8] = { LINETYPE_DEFAULT,
  90.                      LINETYPE_DOT,
  91.                      LINETYPE_SHORTDASH,
  92.                      LINETYPE_DASHDOT,
  93.                      LINETYPE_DOUBLEDOT,
  94.                      LINETYPE_LONGDASH,
  95.                      LINETYPE_DASHDOUBLEDOT,
  96.                      LINETYPE_SOLID };
  97.  
  98. CHAR linetext[8][15] = { "DEFAULT",
  99.                          "DOT",
  100.                          "SHORTDASH",
  101.                          "DASHDOT",
  102.                          "DOUBLEDOT",
  103.                          "LONGDASH",
  104.                          "DASHDOUBLEDOT",
  105.                          "SOLID" };
  106.  
  107. LONG endstyles[4] = { LINEEND_DEFAULT,
  108.                       LINEEND_FLAT,
  109.                       LINEEND_ROUND,
  110.                       LINEEND_SQUARE };
  111.  
  112. LONG markertype[11] = { MARKSYM_DEFAULT,
  113.                         MARKSYM_CROSS,
  114.                         MARKSYM_PLUS,
  115.                         MARKSYM_DIAMOND,
  116.                         MARKSYM_SQUARE,
  117.                         MARKSYM_SIXPOINTSTAR,
  118.                         MARKSYM_EIGHTPOINTSTAR,
  119.                         MARKSYM_SOLIDDIAMOND,
  120.                         MARKSYM_SOLIDSQUARE,
  121.                         MARKSYM_DOT,
  122.                         MARKSYM_SMALLCIRCLE };
  123.  
  124. LONG pattern[19] = { PATSYM_BLANK,
  125.                      PATSYM_DEFAULT,
  126.                      PATSYM_DENSE1,
  127.                      PATSYM_DENSE2,
  128.                      PATSYM_DENSE3,
  129.                      PATSYM_DENSE4,
  130.                      PATSYM_DENSE5,
  131.                      PATSYM_DENSE6,
  132.                      PATSYM_DENSE7,
  133.                      PATSYM_DENSE8,
  134.                      PATSYM_DIAG1,
  135.                      PATSYM_DIAG2,
  136.                      PATSYM_DIAG3,
  137.                      PATSYM_DIAG4,
  138.                      PATSYM_HALFTONE,
  139.                      PATSYM_HORIZ,
  140.                      PATSYM_NOSHADE,
  141.                      PATSYM_SOLID,
  142.                      PATSYM_VERT };
  143.  
  144. SHORT select[15] = { 0,
  145.                      FATTR_SEL_ITALIC,
  146.                      FATTR_SEL_ITALIC ^ FATTR_SEL_UNDERSCORE,
  147.                      FATTR_SEL_ITALIC ^ FATTR_SEL_STRIKEOUT,
  148.                      FATTR_SEL_ITALIC ^ FATTR_SEL_BOLD,
  149.                      FATTR_SEL_ITALIC ^ FATTR_SEL_UNDERSCORE ^ FATTR_SEL_STRIKEOUT,
  150.                      FATTR_SEL_ITALIC ^ FATTR_SEL_UNDERSCORE ^ FATTR_SEL_BOLD,
  151.                      FATTR_SEL_ITALIC ^ FATTR_SEL_UNDERSCORE ^ FATTR_SEL_STRIKEOUT ^ FATTR_SEL_BOLD,
  152.                      FATTR_SEL_UNDERSCORE,
  153.                      FATTR_SEL_UNDERSCORE ^ FATTR_SEL_STRIKEOUT,
  154.                      FATTR_SEL_UNDERSCORE ^ FATTR_SEL_BOLD,
  155.                      FATTR_SEL_UNDERSCORE ^ FATTR_SEL_STRIKEOUT ^ FATTR_SEL_BOLD,
  156.                      FATTR_SEL_STRIKEOUT,
  157.                      FATTR_SEL_STRIKEOUT ^ FATTR_SEL_BOLD,
  158.                      FATTR_SEL_BOLD };
  159.  
  160. LONG direct[4] = { CHDIRN_LEFTRIGHT,
  161.                    CHDIRN_RIGHTLEFT,
  162.                    CHDIRN_TOPBOTTOM,
  163.                    CHDIRN_BOTTOMTOP };
  164.  
  165.  
  166. /*-----------------------------------------------------------------*/
  167. /*                          M A I N                                */
  168. /*-----------------------------------------------------------------*/
  169. void cdecl main()
  170. {
  171.  QMSG qmsg;
  172.  
  173.  srand( (unsigned) time(NULL) );
  174.  
  175.  if ( do_init() ){
  176.     while(WinGetMsg(hab, &qmsg, NULL, 0, 0))
  177.        WinDispatchMsg(hab, &qmsg);
  178.  
  179.     WinDestroyWindow( hwndMainFrame );
  180.     WinDestroyMsgQueue( hmq );
  181.     WinTerminate( hab );
  182.  }
  183.  
  184. }
  185.  
  186. /*-----------------------------------------------------------------*/
  187. /*                  Initialisierungs-Prozedur                      */
  188. /*-----------------------------------------------------------------*/
  189. INT do_init()
  190. {
  191.   BOOL ok;
  192.   ULONG flFlags = FCF_STANDARD;
  193.  
  194.   hab = WinInitialize( NULL );
  195.   hmq = WinCreateMsgQueue( hab,0 );
  196.  
  197.   ok = GpiLoadFonts( hab, "C:\\OS2\\DLL\\TIMES.FON" );
  198.  
  199.   if (!(WinRegisterClass(hab,"BenchProc", BenchProc, CS_SIZEREDRAW, 0))) {
  200.      WinDestroyMsgQueue( hmq );
  201.      WinTerminate( hab );
  202.      return FALSE;
  203.   }
  204.  
  205.   if (!(hwndMainFrame = WinCreateStdWindow(HWND_DESKTOP,WS_VISIBLE,&flFlags,
  206.                        "BenchProc",NULL,WS_SYNCPAINT,NULL,MID_MAIN,&hwndMainClient))) {
  207.      WinDestroyMsgQueue( hmq );
  208.      WinTerminate( hab );
  209.      return FALSE;
  210.   }
  211.  
  212.   WinSetWindowText(hwndMainFrame,"Benchmark Program");
  213.   return TRUE;
  214. }
  215.  
  216. /*-----------------------------------------------------------------*/
  217. /*                 M A I N C L I E N T P R O C                     */
  218. /*-----------------------------------------------------------------*/
  219. MRESULT EXPENTRY BenchProc(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  220. {
  221.   switch (msg)
  222.    {
  223.      case WM_CREATE:
  224.           break;
  225.      case WM_COMMAND:
  226.           do_command(hwnd,mp1);
  227.           return 0;
  228.      case WM_PAINT:
  229.           do_paint(hwnd);
  230.           return 0;
  231.      case WM_SIZE:
  232.           do_size(mp2);
  233.           return 0;
  234.      case WM_CLOSE:
  235.           WinPostMsg( hwnd, WM_QUIT, 0L, 0L);
  236.           return 0;
  237.      default:
  238.           break;
  239.    }
  240.     return (WinDefWindowProc(hwnd, msg, mp1, mp2 ));
  241. }
  242.  
  243. /*-----------------------------------------------------------------*/
  244. /*                       Command-Prozeduren                        */
  245. /*-----------------------------------------------------------------*/
  246. VOID do_command(HWND hwnd, MPARAM mp1)
  247. {
  248.    HPOINTER hptr;
  249.  
  250.    hptr = WinQueryPointer( HWND_DESKTOP );
  251.    WinSetPointer( HWND_DESKTOP, (HPOINTER) NULL );
  252.  
  253.    DosGetDateTime(&start_dt);
  254.  
  255.    switch (SHORT1FROMMP(mp1))
  256.    { 
  257.      case MID_GPI_FONTS_BOX:
  258.           do_gpi_fonts_box(hwnd);
  259.           break;
  260.      case MID_GPI_FONTS_CHARS:
  261.           do_gpi_fonts_chars(hwnd);
  262.           break;
  263.      case MID_GPI_FONTS_DIRECT:
  264.           do_gpi_fonts_direct(hwnd);
  265.           break;
  266.      case MID_GPI_FONTS_ANGLE:
  267.           do_gpi_fonts_angle(hwnd);
  268.           break;
  269.      case MID_GPI_FONTS_SHEAR:
  270.           do_gpi_fonts_shear(hwnd);
  271.           break;
  272.      case MID_GPI_FONTS_ALL:
  273.           do_gpi_fonts_all(hwnd);
  274.           break;
  275.      case MID_GPI_LINES_ARCS:
  276.           do_gpi_lines_arcs(hwnd);
  277.           break;
  278.      case MID_GPI_LINES_BOXES:
  279.           do_gpi_lines_boxes(hwnd);
  280.           break;
  281.      case MID_GPI_LINES_FILLETS:
  282.           do_gpi_lines_fillets(hwnd);
  283.           break;
  284.      case MID_GPI_LINES_LINES:
  285.           do_gpi_lines_lines(hwnd);
  286.           break;
  287.      case MID_GPI_LINES_SPLINES:
  288.           do_gpi_lines_splines(hwnd);
  289.           break;
  290.      case MID_GPI_LINES_STYLES:
  291.           do_gpi_lines_styles(hwnd);
  292.           break;
  293.      case MID_GPI_LINES_ALL:
  294.           do_gpi_lines_all(hwnd);
  295.           break;
  296.      case MID_GPI_MARKER_BOX :
  297.           do_gpi_marker_box(hwnd);
  298.           break;
  299.      case MID_GPI_MARKER_POLY :
  300.           do_gpi_marker_poly(hwnd);
  301.           break;
  302.      case MID_GPI_MARKER_SINGLE :
  303.           do_gpi_marker_single(hwnd);
  304.           break;
  305.      case MID_GPI_MARKER_USERDEF :
  306.           do_gpi_marker_userdef(hwnd);
  307.           break;
  308.      case MID_GPI_MARKER_ALL :
  309.           do_gpi_marker_all(hwnd);
  310.           break;
  311.      case MID_GPI_PATHS_ENDS:
  312.           do_gpi_paths_ends(hwnd);
  313.           break;
  314.      case MID_GPI_PATHS_FILL:
  315.           do_gpi_paths_fill(hwnd);
  316.           break;
  317.      case MID_GPI_PATHS_JOIN:
  318.           do_gpi_paths_join(hwnd);
  319.           break;
  320.      case MID_GPI_PATHS_LINES:
  321.           do_gpi_paths_lines(hwnd);
  322.           break;
  323.      case MID_GPI_PATHS_PATTERN:
  324.           do_gpi_paths_pattern(hwnd);
  325.           break;
  326.      case MID_GPI_PATHS_WIDTH:
  327.           do_gpi_paths_width(hwnd);
  328.           break;
  329.      case MID_GPI_PATHS_ALL:
  330.           do_gpi_paths_all(hwnd);
  331.           break;
  332.      case MID_GPI_ALL:
  333.           do_gpi_all(hwnd);
  334.           break;
  335.      case MID_GPI_EXTEND:
  336.           do_gpi_extend(hwnd);
  337.           break;
  338.      case CMD_CLEAR:
  339.           do_clear_screen(hwnd);
  340.           break;
  341.      case CMD_EXIT:
  342.           WinPostMsg(hwnd,WM_CLOSE,(MPARAM) NULL,(MPARAM) NULL);
  343.           return;
  344.      default:
  345.           return;
  346.      }
  347.  
  348.    DosGetDateTime(&ende_dt);
  349.    Display_Time( hwnd );
  350.  
  351.    WinSetPointer( HWND_DESKTOP, hptr );
  352.  
  353. }
  354.  
  355. VOID Display_Time(HWND hwnd)
  356. {
  357.   CHAR buffer[50];
  358.  
  359.   sprintf( buffer, "Benchmark result : %lu ms", Calc_MSec(&ende_dt)-Calc_MSec(&start_dt));
  360.  
  361.   WinSetWindowText( hwndMainFrame, buffer );
  362.  
  363. }
  364.  
  365. #define MS_HUNDREDTHS   10L
  366. #define MS_SECONDS    1000L
  367. #define MS_MINUTES   60000L
  368. #define MS_HOUR    3600000L 
  369.  
  370. LONG Calc_MSec( PDATETIME dt )
  371. {
  372.  
  373.   return dt->hours      * MS_HOUR     +
  374.          dt->minutes    * MS_MINUTES  +
  375.          dt->seconds    * MS_SECONDS  +
  376.          dt->hundredths * MS_HUNDREDTHS;
  377.  
  378. }
  379.  
  380. LONG Calc_Fraction( LONG value )
  381. {
  382.   return (LONG)((FLOAT)rand()/(FLOAT)RAND_MAX*(FLOAT)value);
  383. }
  384.  
  385. /*-----------------------------------------------------------------*/
  386. /*                       Zeichen-Prozeduren                        */
  387. /*-----------------------------------------------------------------*/
  388. VOID do_paint(HWND hwnd)
  389. {
  390.   RECTL rc;
  391.   HPS hps;
  392.  
  393.   hps =  WinBeginPaint(hwnd, (HPS)NULL, &rc);
  394.          WinFillRect( hps, &rc, SYSCLR_WINDOW);
  395.          WinEndPaint(hps);
  396. }
  397.  
  398. VOID do_clear_screen( HWND hwnd )
  399. {
  400.   HPS hps;
  401.   RECTL rc;
  402.  
  403.   rc.xLeft  = rc.yBottom = 0L;
  404.   rc.xRight = cx;
  405.   rc.yTop   = cy;
  406.  
  407.   hps = WinGetPS( hwnd );
  408.         WinFillRect( hps, &rc, colors[ rand() % 16 ] );
  409.         WinReleasePS( hwnd );
  410.  
  411. }
  412.  
  413.  
  414. VOID do_size( MPARAM mp2 )
  415. {
  416.   cx = SHORT1FROMMP(mp2);
  417.   cy = SHORT2FROMMP(mp2);
  418.   center.x = (LONG)cx/2;
  419.   center.y = (LONG)cy/2; 
  420. } 
  421.  
  422. /* Fonts */
  423.  
  424. VOID do_gpi_fonts_box(HWND hwnd)
  425. {
  426.   INT i,j;
  427.   POINTL pkt;
  428.   FATTRS fat;
  429.   SIZEF siz;
  430.   BOOL ok;
  431.   HPS hps;
  432.  
  433.   fat.usRecordLength = sizeof(FATTRS);
  434.   fat.fsSelection    = 0;
  435.   fat.lMatch         = 0;
  436.   fat.idRegistry     = 0;
  437.   fat.usCodePage     = 850;
  438.   fat.lMaxBaselineExt= 0L;
  439.   fat.lAveCharWidth  = 0L;
  440.   fat.fsType         = 0;
  441.   fat.fsFontUse      = FATTR_FONTUSE_OUTLINE;
  442.   strcpy(fat.szFacename,"Tms Rmn");
  443.  
  444.   hps = WinGetPS( hwnd );
  445.  
  446.   ok = GpiCreateLogFont( hps, (PSTR8) NULL, 1, &fat );
  447.   ok = GpiSetCharSet( hps, 1 );
  448.  
  449.   for (i=0; i<100; i++ ) {
  450.       pkt.x = Calc_Fraction( cx/3 );
  451.       pkt.y = Calc_Fraction( cy );
  452.       siz.cx = MAKEFIXED( rand() % 200 ,0 );
  453.       siz.cy = MAKEFIXED( rand() % 200 ,0 );
  454.       ok = GpiSetColor( hps, colors[rand() % 16] );
  455.       ok = GpiMove( hps, &pkt );
  456.       ok = GpiSetCharBox( hps, &siz );
  457.       ok = GpiCharString( hps, 10, "Benchmark");
  458.   }
  459.  
  460.   WinReleasePS( hwnd );
  461.  
  462. }
  463.  
  464. VOID do_gpi_fonts_direct(HWND hwnd)
  465. {
  466.   INT i,j;
  467.   POINTL pkt;
  468.   FATTRS fat;
  469.   SIZEF size;
  470.   BOOL ok;
  471.   HPS hps;
  472.  
  473.   fat.usRecordLength = sizeof(FATTRS);
  474.   fat.fsSelection    = 0;
  475.   fat.lMatch         = 0;
  476.   fat.idRegistry     = 0;
  477.   fat.usCodePage     = 850;
  478.   fat.lMaxBaselineExt= 0L;
  479.   fat.lAveCharWidth  = 0L;
  480.   fat.fsType         = 0;
  481.   fat.fsFontUse      = FATTR_FONTUSE_OUTLINE;
  482.   strcpy(fat.szFacename,"Tms Rmn");
  483.  
  484.   size.cx = MAKEFIXED( 50,0 );
  485.   size.cy = MAKEFIXED( 50,0 );
  486.  
  487.   hps = WinGetPS( hwnd );
  488.  
  489.   ok = GpiCreateLogFont( hps, (PSTR8) NULL, 1, &fat );
  490.   ok = GpiSetCharSet( hps, 1 );
  491.   ok = GpiSetCharBox( hps, &size );
  492.  
  493.   for (i=0; i<100; i++ ) {
  494.       pkt.x = Calc_Fraction( cx );
  495.       pkt.y = Calc_Fraction( cy );
  496.       ok = GpiSetColor( hps, colors[rand() % 16] );
  497.       ok = GpiSetCharDirection( hps, direct[rand() % 4] );
  498.       ok = GpiMove( hps, &pkt );
  499.       ok = GpiCharString( hps, 10, "Benchmark");
  500.   }
  501.  
  502.   WinReleasePS( hwnd );
  503.  
  504. }
  505.  
  506. VOID do_gpi_fonts_chars(HWND hwnd)
  507. {
  508.   INT i,j;
  509.   POINTL pkt;
  510.   FATTRS fat;
  511.   SIZEF size;
  512.   BOOL ok;
  513.   HPS hps;
  514.  
  515.   fat.usRecordLength = sizeof(FATTRS);
  516.   fat.fsSelection    = 0;
  517.   fat.lMatch         = 0;
  518.   fat.idRegistry     = 0;
  519.   fat.usCodePage     = 850;
  520.   fat.lMaxBaselineExt= 0L;
  521.   fat.lAveCharWidth  = 0L;
  522.   fat.fsType         = 0;
  523.   fat.fsFontUse      = FATTR_FONTUSE_OUTLINE;
  524.   strcpy(fat.szFacename,"Tms Rmn");
  525.  
  526.   size.cx = MAKEFIXED( 50,0 );
  527.   size.cy = MAKEFIXED( 50,0 );
  528.  
  529.   hps = WinGetPS( hwnd );
  530.  
  531.   for (i=0; i<100; i++ ) {
  532.       pkt.x = Calc_Fraction( cx );
  533.       pkt.y = Calc_Fraction( cy );
  534.       fat.fsSelection = select[ rand() % 15 ];
  535.       ok = GpiCreateLogFont( hps, (PSTR8) NULL, 1, &fat );
  536.       ok = GpiSetCharSet( hps, 1 );
  537.       ok = GpiSetCharBox( hps, &size );
  538.       ok = GpiSetColor( hps, colors[rand() % 16] );
  539.       ok = GpiMove( hps, &pkt );
  540.       ok = GpiCharString( hps, 10, "Benchmark");
  541.       ok = GpiSetCharSet( hps, 0 );
  542.       ok = GpiDeleteSetId( hps, 1);
  543.   }
  544.  
  545.   WinReleasePS( hwnd );
  546.  
  547. }
  548.  
  549. VOID do_gpi_fonts_angle(HWND hwnd)
  550. {
  551.   INT i;
  552.   POINTL pkt;
  553.   FATTRS fat;
  554.   GRADIENTL grad;
  555.   SIZEF size;
  556.   BOOL ok;
  557.   HPS hps;
  558.  
  559.   fat.usRecordLength = sizeof(FATTRS);
  560.   fat.fsSelection    = 0;
  561.   fat.lMatch         = 0;
  562.   fat.idRegistry     = 0;
  563.   fat.usCodePage     = 850;
  564.   fat.lMaxBaselineExt= 0L;
  565.   fat.lAveCharWidth  = 0L;
  566.   fat.fsType         = 0;
  567.   fat.fsFontUse      = FATTR_FONTUSE_OUTLINE;
  568.   strcpy(fat.szFacename,"Tms Rmn");
  569.  
  570.   size.cx = MAKEFIXED( 50,0 );
  571.   size.cy = MAKEFIXED( 50,0 );
  572.  
  573.   hps = WinGetPS( hwnd );
  574.  
  575.   ok = GpiCreateLogFont( hps, (PSTR8) NULL, 1, &fat );
  576.   ok = GpiSetCharSet( hps, 1 );
  577.   ok = GpiSetCharBox( hps, &size );
  578.  
  579.   for (i=0; i<100; i++ ) {
  580.       pkt.x = Calc_Fraction( cx );
  581.       pkt.y = Calc_Fraction( cy );
  582.       grad.x = (LONG)(25-rand() % 50 );
  583.       grad.y = (LONG)(25-rand() % 50 );
  584.       ok = GpiSetColor( hps, colors[rand() % 16] );
  585.       ok = GpiMove( hps, &pkt );
  586.       ok = GpiSetCharAngle( hps, &grad );      
  587.       ok = GpiCharString( hps, 10, "Benchmark" );
  588.   }
  589.  
  590.   WinReleasePS( hwnd );
  591.  
  592. }
  593.  
  594. VOID do_gpi_fonts_shear(HWND hwnd)
  595. {
  596.   INT i;
  597.   POINTL pkt,shear;
  598.   FATTRS fat;
  599.   SIZEF size;
  600.   BOOL ok;
  601.   HPS hps;
  602.  
  603.   fat.usRecordLength = sizeof(FATTRS);
  604.   fat.fsSelection    = 0;
  605.   fat.lMatch         = 0;
  606.   fat.idRegistry     = 0;
  607.   fat.usCodePage     = 850;
  608.   fat.lMaxBaselineExt= 0L;
  609.   fat.lAveCharWidth  = 0L;
  610.   fat.fsType         = 0;
  611.   fat.fsFontUse      = FATTR_FONTUSE_OUTLINE;
  612.   strcpy(fat.szFacename,"Tms Rmn");
  613.  
  614.   size.cx = MAKEFIXED( 50,0 );
  615.   size.cy = MAKEFIXED( 50,0 );
  616.  
  617.   hps = WinGetPS( hwnd );
  618.  
  619.   ok = GpiCreateLogFont( hps, (PSTR8) NULL, 1, &fat );
  620.   ok = GpiSetCharSet( hps, 1 );
  621.   ok = GpiSetCharBox( hps, &size );
  622.  
  623.   for (i=0; i<100; i++ ) {
  624.       pkt.x = Calc_Fraction( cx );
  625.       pkt.y = Calc_Fraction( cy );
  626.       shear.x = (LONG)(25-rand() % 50 );
  627.       shear.y = (LONG)(25-rand() % 50 );
  628.       ok = GpiSetColor( hps, colors[rand() % 16] );
  629.       ok = GpiMove( hps, &pkt );
  630.       ok = GpiSetCharShear( hps, &shear );      
  631.       ok = GpiCharString( hps, 10, "Benchmark" );
  632.   }
  633.  
  634.   WinReleasePS( hwnd );
  635.  
  636. }
  637.  
  638. VOID do_gpi_fonts_all(HWND hwnd)
  639. {
  640.   do_gpi_fonts_box     (hwnd);
  641.   do_gpi_fonts_chars   (hwnd);
  642.   do_gpi_fonts_direct  (hwnd);
  643.   do_gpi_fonts_angle   (hwnd);
  644.   do_gpi_fonts_shear   (hwnd);
  645. }
  646.  
  647. /* Lines */
  648.  
  649. VOID do_gpi_lines_arcs(HWND hwnd)
  650. {
  651.  
  652.   INT i;
  653.   ARCPARAMS arcp = { 1, 1, 0, 0 };
  654.   POINTL pkt;
  655.   BOOL ok;
  656.   HPS hps;
  657.  
  658.   hps = WinGetPS( hwnd );
  659.  
  660.   ok = GpiSetArcParams( hps, &arcp );
  661.  
  662.   for (i=0; i<500; i++) {
  663.       pkt.x = Calc_Fraction( cx );
  664.       pkt.y = Calc_Fraction( cy );
  665.       ok = GpiSetColor( hps, colors[rand() % 16] );
  666.       ok = GpiMove( hps, &pkt );
  667.       ok = GpiFullArc( hps, DRO_OUTLINEFILL, MAKEFIXED( rand() % 64, 0 ) );
  668.   }
  669.  
  670.   WinReleasePS( hwnd );
  671.  
  672. }
  673.  
  674. VOID do_gpi_lines_boxes(HWND hwnd)
  675. {
  676.  
  677.   INT i;
  678.   BOOL ok;
  679.   HPS hps;
  680.   POINTL pkt;
  681.  
  682.   hps = WinGetPS( hwnd );
  683.  
  684.   ok = GpiMove( hps, ¢er );
  685.   ok = GpiSetColor( hps, CLR_DARKGRAY );
  686.  
  687.   for (i=0; i<500; i++) {
  688.       pkt.x = Calc_Fraction( cx );
  689.       pkt.y = Calc_Fraction( cy );
  690.       ok = GpiSetColor( hps, colors[rand() % 16] );
  691.       ok = GpiBox( hps, DRO_OUTLINEFILL, &pkt, NULL, NULL );
  692.       ok = GpiMove( hps, &pkt );
  693.   }
  694.  
  695.   WinReleasePS( hwnd );
  696.  
  697. }
  698.  
  699. VOID do_gpi_lines_fillets(HWND hwnd)
  700. { 
  701.   HPS hps;
  702.   POINTL Multipkt[2];
  703.   BOOL ok;
  704.   INT i,j;
  705.  
  706.   hps = WinGetPS( hwnd );
  707.  
  708.   ok =  GpiMove(hps, ¢er);
  709.   for (j=0; j<500; j++ ) {
  710.       for (i=0; i<2; i++ ) {
  711.           ok = GpiSetColor( hps, colors[rand() % 16] );
  712.           Multipkt[i].x = Calc_Fraction( cx );
  713.           Multipkt[i].y = Calc_Fraction( cy );
  714.           ok =  GpiPolyFillet(hps, 2, Multipkt);
  715.       }
  716.   }
  717.  
  718.   WinReleasePS( hwnd );
  719. }
  720.  
  721. VOID do_gpi_lines_lines(HWND hwnd)
  722. { 
  723.   BOOL ok;
  724.   POINTL p1;
  725.   INT i,c;
  726.   HPS hps;
  727.  
  728.   hps = WinGetPS( hwnd );
  729.  
  730.   p1.x = 0L;
  731.   p1.y = 0L;
  732.  
  733.   for (c=0; c<16; c++ ) {
  734.       ok = GpiSetColor( hps, colors[c] );
  735.       for (i=0 ; i<360; i++ ) {
  736.           ok = GpiMove( hps, ¢er );
  737.           if (i<90) {
  738.              p1.x =(LONG)((FLOAT)cx*(FLOAT)i/90.0);
  739.              }
  740.           else if ( i<180 ) {
  741.              p1.x = cx;
  742.              p1.y = (LONG)((FLOAT)cy*(FLOAT)(i-90)/90.0);
  743.              }
  744.           else if ( i<270 ) {
  745.              p1.x = (LONG)((FLOAT)cx*(FLOAT)(270-i)/90.0);
  746.              p1.y = cy;
  747.              }
  748.           else if ( i<360 ) {
  749.              p1.x = 0L;
  750.              p1.y = (LONG)((FLOAT)cy*(FLOAT)(360-i)/90.0);
  751.              }
  752.           ok = GpiLine( hps, &p1 );
  753.       }
  754.   } 
  755.   WinReleasePS( hwnd );
  756.  
  757. }
  758.  
  759. VOID do_gpi_lines_splines(HWND hwnd)
  760. {
  761.   HPS hps;
  762.   POINTL Multipkt[3];
  763.   BOOL ok;
  764.   INT i,j;
  765.  
  766.   hps = WinGetPS( hwnd );
  767.  
  768.   ok =  GpiSetColor(hps, CLR_CYAN);
  769.   ok =  GpiMove(hps, ¢er);   
  770.  
  771.   for (i=0; i<500; i++ ) {
  772.       for (j=0;j<3;j++) {
  773.           Multipkt[j].x = Calc_Fraction( cx );
  774.           Multipkt[j].y = Calc_Fraction( cy );
  775.       }
  776.       ok = GpiSetColor( hps, colors[rand() % 16] );
  777.       ok = GpiPolySpline(hps, 3, Multipkt);
  778.   } 
  779.  
  780.  
  781.   WinReleasePS( hwnd );
  782. }
  783.  
  784. VOID do_gpi_lines_styles(HWND hwnd)
  785. {
  786.   HPS hps;
  787.   BOOL ok;
  788.   POINTL pkt;
  789.   INT i,j;
  790.  
  791.   hps = WinGetPS( hwnd );
  792.   
  793.   for ( i=0; i<8; i++) {
  794.       pkt.y = (LONG)((FLOAT)cy/8.0*(FLOAT)i);
  795.       ok = GpiSetLineType(hps,linetype[i]);
  796.       for (j=0; j<(INT)((FLOAT)cy/8.0);j+=3) {
  797.           ok = GpiSetColor( hps, colors[rand() % 16] );
  798.           pkt.x = 0L;
  799.           ok = GpiMove(hps,&pkt);
  800.           pkt.x = cx;
  801.           ok = GpiLine(hps,&pkt);
  802.           pkt.y+=3;
  803.       }
  804.       ok = GpiSetColor( hps, colors[0] );
  805.       pkt.x = 10L;
  806.       pkt.y = (LONG)((FLOAT)cy/8.0*(FLOAT)i);
  807.       ok = GpiMove( hps, &pkt );
  808.       ok = GpiCharString( hps, strlen(linetext[i]), linetext[i] );
  809.   }
  810.  
  811.   WinReleasePS( hwnd );
  812. }
  813.  
  814. VOID do_gpi_lines_all(HWND hwnd)
  815. {
  816.   do_gpi_lines_arcs    (hwnd);
  817.   do_gpi_lines_boxes   (hwnd);
  818.   do_gpi_lines_fillets (hwnd);
  819.   do_gpi_lines_lines   (hwnd);
  820.   do_gpi_lines_splines (hwnd);
  821.   do_gpi_lines_styles  (hwnd);
  822. }
  823.  
  824.  
  825. /* marker */
  826.  
  827. VOID do_gpi_marker_box(HWND hwnd)
  828. {
  829.  
  830.   INT i,j;
  831.   POINTL pkt;
  832.   FATTRS fat;
  833.   SIZEF siz;
  834.   BOOL ok;
  835.   HPS hps;
  836.  
  837.   fat.usRecordLength = sizeof(FATTRS);
  838.   fat.fsSelection    = 0;
  839.   fat.lMatch         = 0;
  840.   fat.idRegistry     = 0;
  841.   fat.usCodePage     = 850;
  842.   fat.lMaxBaselineExt= 0L;
  843.   fat.lAveCharWidth  = 0L;
  844.   fat.fsType         = 0;
  845.   fat.fsFontUse      = FATTR_FONTUSE_OUTLINE;
  846.   strcpy(fat.szFacename,"Tms Rmn");
  847.  
  848.   hps = WinGetPS( hwnd );
  849.  
  850.   ok = GpiCreateLogFont( hps, (PSTR8) NULL, 1, &fat );
  851.   ok = GpiSetMarkerSet( hps, 1 );
  852.  
  853.   for (i=0; i<500; i++) {
  854.      pkt.x = Calc_Fraction( cx );
  855.      pkt.y = Calc_Fraction( cy );
  856.      siz.cx = MAKEFIXED( rand() % 200, 0 );
  857.      siz.cy = MAKEFIXED( rand() % 200, 0 );
  858.      ok = GpiSetColor( hps, colors[ rand() % 16 ] );
  859.      ok = GpiSetMarker( hps, rand() % 256 );
  860.      ok = GpiSetMarkerBox( hps, &siz );
  861.      ok = GpiMarker( hps, &pkt );
  862.  
  863.   }
  864.  
  865.   WinReleasePS( hwnd );
  866.  
  867. }
  868.  
  869. VOID do_gpi_marker_poly(HWND hwnd)
  870. {
  871.  
  872.   INT i,j;
  873.   POINTL pkt,pkte[30];
  874.   BOOL ok;
  875.   HPS hps;
  876.  
  877.   hps = WinGetPS( hwnd );
  878.   for (i=0; i<17; i++) {
  879.       for (j=0; j<30; j++ ) {
  880.           pkte[j].x = Calc_Fraction( cx );
  881.           pkte[j].y = Calc_Fraction( cy );
  882.       }
  883.      ok = GpiSetColor( hps, colors[ rand() % 16 ] );
  884.      ok = GpiSetMarker( hps, markertype[ rand() % 11 ] );
  885.      ok = GpiPolyMarker( hps, 30, pkte );
  886.       
  887.   }
  888.   WinReleasePS( hwnd );
  889.  
  890. }
  891.  
  892. VOID do_gpi_marker_single(HWND hwnd)
  893. {
  894.  
  895.   INT i;
  896.   POINTL pkt;
  897.   BOOL ok;
  898.   HPS hps;
  899.  
  900.   hps = WinGetPS( hwnd );
  901.   for( i=0; i<500; i++ ) {
  902.      pkt.x = Calc_Fraction( cx );
  903.      pkt.y = Calc_Fraction( cy );
  904.      ok = GpiSetColor( hps, colors[ rand() % 16 ] );
  905.      ok = GpiSetMarker( hps, markertype[ rand() % 11 ] );
  906.      ok = GpiMarker( hps, &pkt );
  907.   }
  908.  
  909.   WinReleasePS( hwnd );
  910.  
  911. }
  912.  
  913. VOID do_gpi_marker_userdef(HWND hwnd)
  914. {
  915.  
  916.   INT i,j;
  917.   POINTL pkt;
  918.   FATTRS fat;
  919.   BOOL ok;
  920.   HPS hps;
  921.  
  922.   fat.usRecordLength = sizeof(FATTRS);
  923.   fat.fsSelection    = 0;
  924.   fat.lMatch         = 0;
  925.   fat.idRegistry     = 0;
  926.   fat.usCodePage     = 850;
  927.   fat.lMaxBaselineExt= 0L;
  928.   fat.lAveCharWidth  = 0L;
  929.   fat.fsType         = 0;
  930.   fat.fsFontUse      = FATTR_FONTUSE_OUTLINE;
  931.  
  932.   hps = WinGetPS( hwnd );
  933.  
  934.   ok = GpiCreateLogFont( hps, (PSTR8) NULL, 1, &fat );
  935.   ok = GpiSetMarkerSet( hps, 1 );
  936.  
  937.   for (i=0; i<500; i++) {
  938.      pkt.x = Calc_Fraction( cx );
  939.      pkt.y = Calc_Fraction( cy );
  940.      ok = GpiSetColor( hps, colors[ rand() % 16 ] );
  941.      ok = GpiSetMarker( hps, rand() % 256 );
  942.      ok = GpiMarker( hps, &pkt );
  943.  
  944.   }
  945.  
  946.   WinReleasePS( hwnd );
  947.  
  948. }
  949.  
  950. VOID do_gpi_marker_all(HWND hwnd)
  951. {
  952.   do_gpi_marker_box(hwnd);
  953.   do_gpi_marker_poly(hwnd);
  954.   do_gpi_marker_single(hwnd);
  955.   do_gpi_marker_userdef(hwnd);
  956. }
  957.  
  958.  
  959. /* paths */
  960.  
  961. VOID do_gpi_paths_ends(HWND hwnd)
  962. {
  963.   HPS hps;
  964.   BOOL ok;
  965.   POINTL p1,p2;
  966.   INT i,j;
  967.  
  968.   hps = WinGetPS( hwnd );
  969.   
  970.   for (i=0; i<4; i++ ) {
  971.       for (j=0; j<125; j++) {
  972.           p1.x = Calc_Fraction( cx );
  973.           p1.y = Calc_Fraction( cy );
  974.           p2.x = Calc_Fraction( cx );
  975.           p2.y = Calc_Fraction( cy );
  976.           ok = GpiBeginPath( hps, 1L );
  977.           ok = GpiSetLineEnd( hps, endstyles[i] );
  978.           ok = GpiSetLineWidthGeom( hps, 20L );
  979.           ok = GpiSetColor( hps, colors[ rand() % 16 ] );
  980.           ok = GpiMove( hps, &p1 );
  981.           ok = GpiLine( hps, &p2 );
  982.           ok = GpiEndPath( hps );
  983.           ok = GpiStrokePath( hps, 1L, NULL );
  984.       }
  985.   }
  986.  
  987.   WinReleasePS( hwnd );
  988.  
  989. }
  990.  
  991. VOID do_gpi_paths_fill(HWND hwnd)
  992. {
  993.   HPS hps;
  994.   BOOL ok;
  995.   INT i;
  996.   POINTL p1, pkt[2];
  997.  
  998.   hps = WinGetPS( hwnd );
  999.   for (i=0; i<500; i++) {
  1000.       p1.x = Calc_Fraction( cx );
  1001.       p1.y = Calc_Fraction( cy );
  1002.       pkt[0].x = Calc_Fraction( cx );
  1003.       pkt[0].y = Calc_Fraction( cy );
  1004.       pkt[1].x = Calc_Fraction( cx );
  1005.       pkt[1].y = Calc_Fraction( cy );
  1006.       ok = GpiBeginPath( hps, 1L );
  1007.       ok = GpiSetColor( hps, colors[ rand() % 16 ] );
  1008.       ok = GpiMove( hps, &p1 );
  1009.       ok = GpiPolyLine( hps, 2, pkt );
  1010.       ok = GpiLine( hps, &p1 );
  1011.       ok = GpiEndPath( hps );
  1012.       ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1013.   }
  1014.  
  1015.   WinReleasePS( hwnd );
  1016.  
  1017. }
  1018.  
  1019. VOID do_gpi_paths_join(HWND hwnd)
  1020. {
  1021.   static LONG joinstyle[4] = { LINEJOIN_BEVEL,
  1022.                                LINEJOIN_DEFAULT,
  1023.                                LINEJOIN_MITRE,
  1024.                                LINEJOIN_ROUND };
  1025.   HPS hps;
  1026.   BOOL ok;
  1027.   INT i;
  1028.   POINTL p1, pkt[2];
  1029.  
  1030.   hps = WinGetPS( hwnd );
  1031.   for (i=0; i<500; i++) {
  1032.       p1.x = Calc_Fraction( cx );
  1033.       p1.y = Calc_Fraction( cy );
  1034.       pkt[0].x = Calc_Fraction( cx );
  1035.       pkt[0].y = Calc_Fraction( cy );
  1036.       pkt[1].x = Calc_Fraction( cx );
  1037.       pkt[1].y = Calc_Fraction( cy );
  1038.       ok = GpiBeginPath( hps, 1L );
  1039.       ok = GpiSetColor( hps, colors[ rand() % 16 ] );
  1040.       ok = GpiSetLineWidthGeom( hps, 10L );
  1041.       ok = GpiSetLineJoin( hps, joinstyle[ rand() % 4 ] ); 
  1042.       ok = GpiMove( hps, &p1 );
  1043.       ok = GpiPolyLine( hps, 2, pkt );
  1044.       ok = GpiLine( hps, &p1 );
  1045.       ok = GpiEndPath( hps );
  1046.       ok = GpiStrokePath( hps, 1L, NULL );
  1047.   }
  1048.  
  1049.   WinReleasePS( hwnd );
  1050.  
  1051. }
  1052.  
  1053. VOID do_gpi_paths_lines(HWND hwnd)
  1054. {
  1055.   HPS hps;
  1056.   BOOL ok;
  1057.   POINTL pkt,pa1[2],pa2[3];
  1058.   INT i,sa,ea,ra;
  1059.  
  1060.   hps = WinGetPS( hwnd );
  1061.   for (i=0; i<125; i++) {
  1062.       pkt.x = Calc_Fraction( cx );
  1063.       pkt.y = Calc_Fraction( cy );
  1064.       sa = (INT) Calc_Fraction( 360L );
  1065.       ea = (INT) Calc_Fraction( 360L );
  1066.       ra = (INT) Calc_Fraction( 200L );
  1067.       ok = GpiBeginPath( hps, 1L );
  1068.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1069.       ok = GpiMove( hps, &pkt ); 
  1070.       ok = GpiPartialArc( hps, &pkt, MAKEFIXED( ra, 0), MAKEFIXED( sa, 0 ), MAKEFIXED( ea,0) );
  1071.       ok = GpiLine( hps, &pkt );
  1072.       ok = GpiEndPath( hps );
  1073.       ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1074.   }
  1075.  
  1076.   for (i=0; i<125; i++) {
  1077.       pkt.x = Calc_Fraction( cx );
  1078.       pkt.y = Calc_Fraction( cy );
  1079.       pa1[0].x = Calc_Fraction( cx );
  1080.       pa1[0].y = Calc_Fraction( cy );
  1081.       pa1[1].x = Calc_Fraction( cx );
  1082.       pa1[1].y = Calc_Fraction( cy );
  1083.       ok = GpiBeginPath( hps, 1L );
  1084.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1085.       ok = GpiMove( hps, &pkt );
  1086.       ok = GpiPolyFillet( hps, 2, pa1 );
  1087.       ok = GpiLine( hps, &pkt );
  1088.       ok = GpiEndPath( hps );
  1089.       ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1090.   }
  1091.  
  1092.   for (i=0; i<125; i++) {
  1093.       pkt.x = Calc_Fraction( cx );
  1094.       pkt.y = Calc_Fraction( cy );
  1095.       pa2[0].x = Calc_Fraction( cx );
  1096.       pa2[0].y = Calc_Fraction( cy );
  1097.       pa2[1].x = Calc_Fraction( cx );
  1098.       pa2[1].y = Calc_Fraction( cy );
  1099.       pa2[2].x = Calc_Fraction( cx );
  1100.       pa2[2].y = Calc_Fraction( cy );
  1101.       ok = GpiBeginPath( hps, 1L );
  1102.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1103.       ok = GpiMove( hps, &pkt );
  1104.       ok = GpiPolySpline( hps, 3, pa2 );
  1105.       ok = GpiLine( hps, &pkt );
  1106.       ok = GpiEndPath( hps );
  1107.       ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1108.   }
  1109.  
  1110.   for (i=0; i<125; i++) {
  1111.       pkt.x = Calc_Fraction( cx );
  1112.       pkt.y = Calc_Fraction( cy );
  1113.       pa2[0].x = Calc_Fraction( cx );
  1114.       pa2[0].y = Calc_Fraction( cy );
  1115.       pa2[1].x = Calc_Fraction( cx );
  1116.       pa2[1].y = Calc_Fraction( cy );
  1117.       pa2[2].x = Calc_Fraction( cx );
  1118.       pa2[2].y = Calc_Fraction( cy );
  1119.       ok = GpiBeginPath( hps, 1L );
  1120.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1121.       ok = GpiMove( hps, &pkt );
  1122.       ok = GpiPolyLine( hps, 3, pa2 );
  1123.       ok = GpiLine( hps, &pkt );
  1124.       ok = GpiEndPath( hps );
  1125.       ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1126.   }
  1127.  
  1128.   WinReleasePS( hwnd );
  1129.  
  1130. }
  1131.  
  1132. VOID do_gpi_paths_pattern(HWND hwnd)
  1133. {
  1134.   HPS hps;
  1135.   BOOL ok;
  1136.   POINTL pkt,pa1[2],pa2[3];
  1137.   INT i,sa,ea,ra;
  1138.  
  1139.   hps = WinGetPS( hwnd );
  1140.   for (i=0; i<125; i++) {
  1141.       pkt.x = Calc_Fraction( cx );
  1142.       pkt.y = Calc_Fraction( cy );
  1143.       sa = (INT) Calc_Fraction( 360L );
  1144.       ea = (INT) Calc_Fraction( 360L );
  1145.       ra = (INT) Calc_Fraction( 200L );
  1146.       ok = GpiBeginPath( hps, 1L );
  1147.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1148.       ok = GpiSetPattern( hps, pattern[ rand() % 19 ] );
  1149.       ok = GpiMove( hps, &pkt ); 
  1150.       ok = GpiPartialArc( hps, &pkt, MAKEFIXED( ra, 0), MAKEFIXED( sa, 0 ), MAKEFIXED( ea,0) );
  1151.       ok = GpiLine( hps, &pkt );
  1152.       ok = GpiEndPath( hps );
  1153.       ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1154.   }
  1155.  
  1156.   for (i=0; i<125; i++) {
  1157.       pkt.x = Calc_Fraction( cx );
  1158.       pkt.y = Calc_Fraction( cy );
  1159.       pa1[0].x = Calc_Fraction( cx );
  1160.       pa1[0].y = Calc_Fraction( cy );
  1161.       pa1[1].x = Calc_Fraction( cx );
  1162.       pa1[1].y = Calc_Fraction( cy );
  1163.       ok = GpiBeginPath( hps, 1L );
  1164.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1165.       ok = GpiSetPattern( hps, pattern[ rand() % 19 ] );
  1166.       ok = GpiMove( hps, &pkt );
  1167.       ok = GpiPolyFillet( hps, 2, pa1 );
  1168.       ok = GpiLine( hps, &pkt );
  1169.       ok = GpiEndPath( hps );
  1170.       ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1171.   }
  1172.  
  1173.   for (i=0; i<125; i++) {
  1174.       pkt.x = Calc_Fraction( cx );
  1175.       pkt.y = Calc_Fraction( cy );
  1176.       pa2[0].x = Calc_Fraction( cx );
  1177.       pa2[0].y = Calc_Fraction( cy );
  1178.       pa2[1].x = Calc_Fraction( cx );
  1179.       pa2[1].y = Calc_Fraction( cy );
  1180.       pa2[2].x = Calc_Fraction( cx );
  1181.       pa2[2].y = Calc_Fraction( cy );
  1182.       ok = GpiBeginPath( hps, 1L );
  1183.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1184.       ok = GpiSetPattern( hps, pattern[ rand() % 19 ] );
  1185.       ok = GpiMove( hps, &pkt );
  1186.       ok = GpiPolySpline( hps, 3, pa2 );
  1187.       ok = GpiLine( hps, &pkt );
  1188.       ok = GpiEndPath( hps );
  1189.       ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1190.   }
  1191.  
  1192.   for (i=0; i<125; i++) {
  1193.       pkt.x = Calc_Fraction( cx );
  1194.       pkt.y = Calc_Fraction( cy );
  1195.       pa2[0].x = Calc_Fraction( cx );
  1196.       pa2[0].y = Calc_Fraction( cy );
  1197.       pa2[1].x = Calc_Fraction( cx );
  1198.       pa2[1].y = Calc_Fraction( cy );
  1199.       pa2[2].x = Calc_Fraction( cx );
  1200.       pa2[2].y = Calc_Fraction( cy );
  1201.       ok = GpiBeginPath( hps, 1L );
  1202.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1203.       ok = GpiSetPattern( hps, pattern[ rand() % 19 ] );
  1204.       ok = GpiMove( hps, &pkt );
  1205.       ok = GpiPolyLine( hps, 3, pa2 );
  1206.       ok = GpiLine( hps, &pkt );
  1207.       ok = GpiEndPath( hps );
  1208.       ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1209.   }
  1210.  
  1211.   WinReleasePS( hwnd );
  1212.  
  1213. }
  1214.  
  1215. VOID do_gpi_paths_width(HWND hwnd)
  1216. {
  1217.   HPS hps;
  1218.   BOOL ok;
  1219.   POINTL pkt,pa1[2],pa2[3];
  1220.   INT i,sa,ea,ra;
  1221.  
  1222.   hps = WinGetPS( hwnd );
  1223.  
  1224.   for (i=0; i<125; i++) {
  1225.       pkt.x = Calc_Fraction( cx );
  1226.       pkt.y = Calc_Fraction( cy );
  1227.       sa = (INT) Calc_Fraction( 360L );
  1228.       ea = (INT) Calc_Fraction( 360L );
  1229.       ra = (INT) Calc_Fraction( 200L );
  1230.       ok = GpiBeginPath( hps, 1L );
  1231.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1232.       ok = GpiSetLineWidthGeom( hps, Calc_Fraction( 64L ) );
  1233.       ok = GpiMove( hps, &pkt ); 
  1234.       ok = GpiPartialArc( hps, &pkt, MAKEFIXED( ra, 0), MAKEFIXED( sa, 0 ), MAKEFIXED( ea,0) );
  1235.       ok = GpiLine( hps, &pkt );
  1236.       ok = GpiEndPath( hps );
  1237.       ok = GpiStrokePath( hps, 1L, NULL );
  1238.   }
  1239.  
  1240.   for (i=0; i<125; i++) {
  1241.       pkt.x = Calc_Fraction( cx );
  1242.       pkt.y = Calc_Fraction( cy );
  1243.       pa1[0].x = Calc_Fraction( cx );
  1244.       pa1[0].y = Calc_Fraction( cy );
  1245.       pa1[1].x = Calc_Fraction( cx );
  1246.       pa1[1].y = Calc_Fraction( cy );
  1247.       ok = GpiBeginPath( hps, 1L );
  1248.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1249.       ok = GpiSetLineWidthGeom( hps, Calc_Fraction( 64L ) );
  1250.       ok = GpiMove( hps, &pkt );
  1251.       ok = GpiPolyFillet( hps, 2, pa1 );
  1252.       ok = GpiLine( hps, &pkt );
  1253.       ok = GpiEndPath( hps );
  1254.       ok = GpiStrokePath( hps, 1L, NULL );
  1255.   }
  1256.  
  1257.   for (i=0; i<125; i++) {
  1258.       pkt.x = Calc_Fraction( cx );
  1259.       pkt.y = Calc_Fraction( cy );
  1260.       pa2[0].x = Calc_Fraction( cx );
  1261.       pa2[0].y = Calc_Fraction( cy );
  1262.       pa2[1].x = Calc_Fraction( cx );
  1263.       pa2[1].y = Calc_Fraction( cy );
  1264.       pa2[2].x = Calc_Fraction( cx );
  1265.       pa2[2].y = Calc_Fraction( cy );
  1266.       ok = GpiBeginPath( hps, 1L );
  1267.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1268.       ok = GpiSetLineWidthGeom( hps, Calc_Fraction( 64L ) );
  1269.       ok = GpiMove( hps, &pkt );
  1270.       ok = GpiPolySpline( hps, 3, pa2 );
  1271.       ok = GpiLine( hps, &pkt );
  1272.       ok = GpiEndPath( hps );
  1273.       ok = GpiStrokePath( hps, 1L, NULL );
  1274.   }
  1275.  
  1276.   for (i=0; i<125; i++) {
  1277.       pkt.x = Calc_Fraction( cx );
  1278.       pkt.y = Calc_Fraction( cy );
  1279.       pa2[0].x = Calc_Fraction( cx );
  1280.       pa2[0].y = Calc_Fraction( cy );
  1281.       pa2[1].x = Calc_Fraction( cx );
  1282.       pa2[1].y = Calc_Fraction( cy );
  1283.       pa2[2].x = Calc_Fraction( cx );
  1284.       pa2[2].y = Calc_Fraction( cy );
  1285.       ok = GpiBeginPath( hps, 1L );
  1286.       ok = GpiSetColor( hps, colors[rand() % 16] );
  1287.       ok = GpiSetLineWidthGeom( hps, Calc_Fraction( 64L ) );
  1288.       ok = GpiMove( hps, &pkt );
  1289.       ok = GpiPolyLine( hps, 3, pa2 );
  1290.       ok = GpiLine( hps, &pkt );
  1291.       ok = GpiEndPath( hps );
  1292.       ok = GpiStrokePath( hps, 1L, NULL );
  1293.   }
  1294.  
  1295.   WinReleasePS( hwnd );
  1296.  
  1297. }
  1298.  
  1299. VOID do_gpi_paths_all(HWND hwnd)
  1300. {
  1301.   do_gpi_paths_ends    (hwnd);
  1302.   do_gpi_paths_fill    (hwnd);
  1303.   do_gpi_paths_join    (hwnd);
  1304.   do_gpi_paths_lines   (hwnd);
  1305.   do_gpi_paths_pattern (hwnd);
  1306.   do_gpi_paths_width   (hwnd);
  1307. }
  1308.  
  1309. VOID do_gpi_all(HWND hwnd)
  1310. { 
  1311.   do_gpi_fonts_all  (hwnd);
  1312.   do_gpi_lines_all  (hwnd);
  1313.   do_gpi_marker_all (hwnd);
  1314.   do_gpi_paths_all  (hwnd);
  1315. }
  1316.  
  1317. VOID do_gpi_extend(HWND hwnd)
  1318. {
  1319.   HPS hps;
  1320.   BOOL ok;
  1321.   POINTL pkt,shear;
  1322.   INT i,sa,ea,ra;
  1323.   FATTRS fat;
  1324.   SIZEF size;
  1325.   GRADIENTL grad;
  1326.  
  1327.   static INT  pie[5] = { 40, 60, 95, 65, 50 };
  1328.   static LONG col[5] = { CLR_PINK, CLR_DARKCYAN, CLR_YELLOW, CLR_DARKPINK, CLR_CYAN }; 
  1329.  
  1330.   fat.usRecordLength = sizeof(FATTRS);
  1331.   fat.fsSelection    = 0;
  1332.   fat.lMatch         = 0;
  1333.   fat.idRegistry     = 0;
  1334.   fat.usCodePage     = 850;
  1335.   fat.lMaxBaselineExt= 0L;
  1336.   fat.lAveCharWidth  = 0L;
  1337.   fat.fsType         = 0;
  1338.   fat.fsFontUse      = FATTR_FONTUSE_OUTLINE;
  1339.   strcpy(fat.szFacename,"Tms Rmn");
  1340.  
  1341.   size.cx = MAKEFIXED( 50,0 );
  1342.   size.cy = MAKEFIXED( 50,0 );
  1343.  
  1344.   shear.x = 20;
  1345.   shear.y = 20;
  1346.  
  1347.   pkt.x = 10;
  1348.   pkt.y = 10;
  1349.  
  1350.   hps = WinGetPS( hwnd );
  1351.  
  1352.   ok = GpiCreateLogFont( hps, (PSTR8) NULL, 1, &fat );
  1353.   ok = GpiSetCharSet( hps, 1 );
  1354.   ok = GpiSetCharBox( hps, &size );
  1355.   ok = GpiSetCharShear( hps, &shear );
  1356.   ok = GpiMove( hps, &pkt );
  1357.   ok = GpiSetColor( hps, CLR_DARKGRAY );
  1358.   ok = GpiCharString( hps, 10, "Benchmark" );
  1359.  
  1360.   shear.x = 0;
  1361.   shear.y = 0;
  1362.  
  1363.   ok = GpiMove( hps, &pkt );
  1364.   ok = GpiSetColor( hps, CLR_PALEGRAY );
  1365.   ok = GpiSetCharShear( hps, &shear );
  1366.   ok = GpiCharString( hps, 10, "Benchmark" );
  1367.  
  1368.   pkt.x = center.x/2;
  1369.   pkt.y = center.y;
  1370.  
  1371.   ra = 75; sa = 0; ea = 50;
  1372.  
  1373.   for (i=0; i<5; i++ ) {
  1374.      ok = GpiBeginPath( hps, 1L );
  1375.      ok = GpiSetColor( hps, col[i] );
  1376.      ok = GpiMove( hps, &pkt);
  1377.      ok = GpiPartialArc( hps, &pkt, MAKEFIXED( ra, 0 ), MAKEFIXED( sa, 0 ), MAKEFIXED( ea, 0 )  );
  1378.      ok = GpiLine( hps, &pkt);
  1379.      ok = GpiEndPath( hps );
  1380.      ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1381.      sa += ea; ea = pie[i];
  1382.   }
  1383.  
  1384.   pkt.x += 10;
  1385.   pkt.y -= 4;
  1386.  
  1387.   ok = GpiBeginPath( hps, 1L );
  1388.   ok = GpiSetColor( hps, CLR_BLUE );
  1389.   ok = GpiMove( hps, &pkt);
  1390.   ok = GpiPartialArc( hps, &pkt, MAKEFIXED( ra, 0 ), MAKEFIXED( sa, 0 ), MAKEFIXED( ea, 0 )  );
  1391.   ok = GpiLine( hps, &pkt);
  1392.   ok = GpiEndPath( hps );
  1393.   ok = GpiFillPath( hps, 1L, FPATH_ALTERNATE );
  1394.  
  1395.   grad.x =  50;
  1396.   grad.y = -25;
  1397.  
  1398.   size.cx = MAKEFIXED( 20,0 );
  1399.   size.cy = MAKEFIXED( 20,0 );
  1400.  
  1401.   pkt.x += 80;
  1402.   pkt.y -= 38;
  1403.  
  1404.   ok = GpiSetColor( hps, CLR_DARKBLUE );
  1405.   ok = GpiMove( hps, &pkt );
  1406.   ok = GpiSetCharAngle( hps, &grad );
  1407.   ok = GpiSetCharBox( hps, &size );
  1408.   ok = GpiCharString( hps, 14, "Extra Segment" );
  1409.  
  1410.   ok = GpiBeginPath( hps, 1L );
  1411.   ok = GpiSetColor( hps, CLR_BLACK );
  1412.   pkt.x = center.x+20;
  1413.   pkt.y = center.y-5;
  1414.   ok = GpiMove( hps, &pkt );
  1415.   pkt.y = cy-5;
  1416.   ok = GpiLine( hps, &pkt );
  1417.   pkt.x = center.x+15;
  1418.   pkt.y = center.y;
  1419.   ok = GpiMove( hps, &pkt );
  1420.   pkt.x = cx-5;
  1421.   ok = GpiLine( hps, &pkt );
  1422.   ok = GpiEndPath( hps );
  1423.   ok = GpiStrokePath( hps, 1L, FPATH_ALTERNATE );
  1424.  
  1425.   WinReleasePS( hwnd );
  1426.  
  1427. }
  1428.