home *** CD-ROM | disk | FTP | other *** search
/ High Voltage Shareware / high1.zip / high1 / DIR24 / MEMSZ210.ZIP / ITEMS.CC < prev    next >
C/C++ Source or Header  |  1993-07-28  |  13KB  |  695 lines
  1. /******************************************************************* ITEMS.CC
  2.  *                                        *
  3.  *               Display Item Class Functions                *
  4.  *                                        *
  5.  ****************************************************************************/
  6.  
  7. #define INCL_BASE
  8. #define INCL_PM
  9. #include <os2.h>
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14.  
  15. #include "debug.h"
  16. #include "support.h"
  17. #include "restring.h"
  18.  
  19. #include "items.h"
  20.  
  21.  
  22. VOID Item::Paint
  23. (
  24.   HPS hPS,
  25.   RECTL &Rectangle,
  26.   COLOR TextColor,
  27.   COLOR BackColor,
  28.   PSZ Text,
  29.   ULONG NewValue
  30. )
  31. {
  32.   WinDrawText ( hPS, strlen(PCHAR(Text)), Text, &Rectangle,
  33.     TextColor, BackColor, DT_RIGHT | DT_BOTTOM | DT_ERASERECT ) ;
  34.  
  35.   WinDrawText ( hPS, strlen(PCHAR(Label)), Label, &Rectangle,
  36.     TextColor, BackColor, DT_LEFT | DT_BOTTOM ) ;
  37.  
  38.   Value = NewValue ;
  39. }
  40.  
  41.  
  42. ULONG Clock::NewValue ( void )
  43. {
  44.   DATETIME DateTime ;
  45.   DosGetDateTime ( &DateTime ) ;
  46.  
  47.   ULONG Time ;
  48.   Time = DateTime.month ;
  49.   Time *= 100 ;
  50.   Time += DateTime.day ;
  51.   Time *= 100 ;
  52.   Time += DateTime.hours ;
  53.   Time *= 100 ;
  54.   Time += DateTime.minutes ;
  55.  
  56.   return ( Time ) ;
  57. }
  58.  
  59.  
  60. VOID Clock::Repaint
  61. (
  62.   HPS hPS,
  63.   RECTL &Rectangle,
  64.   COLOR TextColor,
  65.   COLOR BackColor,
  66.   BOOL Mandatory
  67. )
  68. {
  69.   ULONG Time = NewValue ( ) ;
  70.  
  71.   if ( Mandatory || ( Time != Value ) )
  72.   {
  73.     BYTE Text [100] ;
  74.     ULONG Month  = ( Time % 100000000L ) / 1000000L ;
  75.     ULONG Day     = ( Time % 1000000L ) / 10000L ;
  76.     ULONG Hour     = ( Time % 10000L ) / 100L ;
  77.     ULONG Minute = ( Time % 100L ) ;
  78.  
  79.     switch ( CountryInfo.fsDateFmt )
  80.     {
  81.       case DATEFMT_DD_MM_YY:
  82.     sprintf ( (PCHAR)Text, "%02lu%s%02lu ",
  83.       Day, CountryInfo.szDateSeparator, Month ) ;
  84.     break ;
  85.  
  86.       case DATEFMT_YY_MM_DD:
  87.       case DATEFMT_MM_DD_YY:
  88.       default:
  89.     sprintf ( (PCHAR)Text, "%02lu%s%02lu ",
  90.       Month, CountryInfo.szDateSeparator, Day ) ;
  91.     break ;
  92.     }
  93.  
  94.     if ( CountryInfo.fsTimeFmt )
  95.     {
  96.       sprintf ( (PCHAR)(Text+strlen((PCHAR)Text)), "%02lu%s%02lu",
  97.     Hour,
  98.     CountryInfo.szTimeSeparator,
  99.     Minute ) ;
  100.     }
  101.     else
  102.     {
  103.       PCHAR AmPm ;
  104.  
  105.       if ( Hour )
  106.       {
  107.     if ( Hour < 12 )
  108.     {
  109.       AmPm = "a" ;
  110.     }
  111.     else if ( Hour == 12 )
  112.     {
  113.       if ( Minute )
  114.         AmPm = "p" ;
  115.       else
  116.         AmPm = "a" ;
  117.     }
  118.     else if ( Hour > 12 )
  119.     {
  120.       Hour -= 12 ;
  121.       AmPm = "p" ;
  122.     }
  123.       }
  124.       else
  125.       {
  126.     Hour = 12 ;
  127.     if ( Minute )
  128.       AmPm = "a" ;
  129.     else
  130.       AmPm = "p" ;
  131.       }
  132.       sprintf ( (PCHAR)(Text+strlen((PCHAR)Text)), "%02lu%s%02lu%s",
  133.     Hour, CountryInfo.szTimeSeparator, Minute, AmPm ) ;
  134.     }
  135.  
  136.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Time ) ;
  137.   }
  138. }
  139.  
  140.  
  141. ULONG ElapsedTime::NewValue ( void )
  142. {
  143.   ULONG Milliseconds ;
  144.   DosQuerySysInfo ( QSV_MS_COUNT, QSV_MS_COUNT, &Milliseconds, sizeof(Milliseconds) ) ;
  145.   return ( Milliseconds / 60000L ) ;
  146. }
  147.  
  148.  
  149. VOID ElapsedTime::Repaint
  150. (
  151.   HPS hPS,
  152.   RECTL &Rectangle,
  153.   COLOR TextColor,
  154.   COLOR BackColor,
  155.   BOOL Mandatory
  156. )
  157. {
  158.   ULONG Time = NewValue ( ) ;
  159.  
  160.   if ( Mandatory || ( Time != Value ) )
  161.   {
  162.     BYTE Text [100] ;
  163.  
  164.     memset ( Text, 0, sizeof(Text) ) ;
  165.  
  166.     ULONG NumberOfDays = Time / ( 60L * 24L ) ;
  167.  
  168.     if ( NumberOfDays )
  169.     {
  170.       sprintf ( PCHAR(Text), "%lu %s, ",
  171.     NumberOfDays, NumberOfDays > 1 ? Days->Ptr() : Day->Ptr() ) ;
  172.     }
  173.  
  174.     ULONG Minutes = Time % ( 60L * 24L ) ;
  175.  
  176.     sprintf ( PCHAR(Text+strlen(PCHAR(Text))), "%lu%s%02lu",
  177.       Minutes/60, CountryInfo.szTimeSeparator, Minutes%60 ) ;
  178.  
  179.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Time ) ;
  180.   }
  181. }
  182.  
  183.  
  184. ULONG MemoryFree::NewValue ( void )
  185. {
  186.   ULONG VirtualMemory ;
  187.   DosQuerySysInfo ( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &VirtualMemory, sizeof(VirtualMemory) ) ;
  188.  
  189.   ULONG SwapDiskFree = SwapFree->NewValue ( ) ;
  190.  
  191.   LONG Space = LONG(VirtualMemory) - LONG(SwapDiskFree) ;
  192.  
  193.   while ( Space < 0 )
  194.   {
  195.     Space += 0x100000 ;
  196.   }
  197.  
  198.   return ( ULONG(Space) ) ;
  199. }
  200.  
  201.  
  202. VOID MemoryFree::Repaint
  203. (
  204.   HPS hPS,
  205.   RECTL &Rectangle,
  206.   COLOR TextColor,
  207.   COLOR BackColor,
  208.   BOOL Mandatory
  209. )
  210. {
  211.   ULONG Size = NewValue ( ) ;
  212.  
  213.   if ( Mandatory || ( Size != Value ) )
  214.   {
  215.     BYTE Text [100] ;
  216.  
  217.     if ( Size < 0x80000 )
  218.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  219.     else
  220.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  221.  
  222.     {
  223.       PBYTE p1, p2 ;
  224.       BYTE Work[100] ;
  225.  
  226.       p1 = Text ;
  227.       p2 = Work ;
  228.       while ( *p1 )
  229.       {
  230.     *p2 = *p1 ;
  231.     p1 ++ ;
  232.     p2 ++ ;
  233.     if ( *p1 )
  234.     {
  235.       if ( strlen((PCHAR)p1) % 3 == 0 )
  236.       {
  237.         *p2 = CountryInfo.szThousandsSeparator [0] ;
  238.         p2 ++ ;
  239.       }
  240.     }
  241.       }
  242.       *p2 = 0 ;
  243.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  244.     }
  245.  
  246.     Text[strlen(PCHAR(Text))+1] = 0 ;
  247.     if ( Size < 0x80000 )
  248.       Text[strlen((PCHAR)Text)] = ' ' ;
  249.     else
  250.       Text[strlen((PCHAR)Text)] = 'K' ;
  251.  
  252.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  253.   }
  254. }
  255.  
  256.  
  257. ULONG SwapSize::NewValue ( void )
  258. {
  259.   char Path [_MAX_PATH+1] ;
  260.  
  261.   strcpy ( Path, (PCHAR)SwapPath ) ;
  262.  
  263.   if ( Path[strlen(Path)-1] != '\\' )
  264.   {
  265.     strcat ( Path, "\\" ) ;
  266.   }
  267.  
  268.   strcat ( Path, "SWAPPER.DAT" ) ;
  269.  
  270.   ULONG SwapSize = 0 ;
  271.   FILESTATUS3 Status ;
  272.   if ( DosQueryPathInfo ( (PSZ)Path, FIL_STANDARD, &Status, sizeof(Status) ) == 0 )
  273.   {
  274.     SwapSize = Status.cbFileAlloc ;
  275.   }
  276.  
  277.   return ( SwapSize ) ;
  278. }
  279.  
  280.  
  281. VOID SwapSize::Repaint
  282. (
  283.   HPS hPS,
  284.   RECTL &Rectangle,
  285.   COLOR TextColor,
  286.   COLOR BackColor,
  287.   BOOL Mandatory
  288. )
  289. {
  290.   ULONG Size = NewValue ( ) ;
  291.  
  292.   if ( Mandatory || ( Size != Value ) )
  293.   {
  294.     BYTE Text [100] ;
  295.  
  296.     if ( Size < 0x80000 )
  297.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  298.     else
  299.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  300.  
  301.     {
  302.       PBYTE p1, p2 ;
  303.       BYTE Work[100] ;
  304.  
  305.       p1 = Text ;
  306.       p2 = Work ;
  307.       while ( *p1 )
  308.       {
  309.     *p2 = *p1 ;
  310.     p1 ++ ;
  311.     p2 ++ ;
  312.     if ( *p1 )
  313.     {
  314.       if ( strlen((PCHAR)p1) % 3 == 0 )
  315.       {
  316.         *p2 = CountryInfo.szThousandsSeparator [0] ;
  317.         p2 ++ ;
  318.       }
  319.     }
  320.       }
  321.       *p2 = 0 ;
  322.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  323.     }
  324.  
  325.     Text[strlen(PCHAR(Text))+1] = 0 ;
  326.     if ( Size < 0x80000 )
  327.       Text[strlen((PCHAR)Text)] = ' ' ;
  328.     else
  329.       Text[strlen((PCHAR)Text)] = 'K' ;
  330.  
  331.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  332.   }
  333. }
  334.  
  335.  
  336. ULONG SwapFree::NewValue ( void )
  337. {
  338.   char Path [_MAX_PATH+1] ;
  339.  
  340.   strcpy ( Path, (PCHAR)SwapPath ) ;
  341.   strcat ( Path, "\\SWAPPER.DAT" ) ;
  342.  
  343.   ULONG SwapFree = 0 ;
  344.   if ( Path[0] )
  345.   {
  346.     DosError ( FERR_DISABLEHARDERR ) ;
  347.     FSALLOCATE Allocation ;
  348.     DosQueryFSInfo ( Path[0]-'A'+1, FSIL_ALLOC,
  349.       (PBYTE)&Allocation, sizeof(Allocation) ) ;
  350.     DosError ( FERR_ENABLEHARDERR ) ;
  351.  
  352.     SwapFree = Allocation.cUnitAvail*Allocation.cSectorUnit*Allocation.cbSector ;
  353.   }
  354.  
  355.   if ( SwapFree < ULONG(MinFree*1024L) )
  356.     return ( 0L ) ;
  357.   else
  358.     return ( SwapFree - ULONG(MinFree*1024L) ) ;
  359. }
  360.  
  361.  
  362. VOID SwapFree::Repaint
  363. (
  364.   HPS hPS,
  365.   RECTL &Rectangle,
  366.   COLOR TextColor,
  367.   COLOR BackColor,
  368.   BOOL Mandatory
  369. )
  370. {
  371.   ULONG Size = NewValue ( ) ;
  372.  
  373.   if ( Mandatory || ( Size != Value ) )
  374.   {
  375.     BYTE Text [100] ;
  376.  
  377.     if ( Size < 0x80000 )
  378.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  379.     else
  380.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  381.  
  382.     {
  383.       PBYTE p1, p2 ;
  384.       BYTE Work[100] ;
  385.  
  386.       p1 = Text ;
  387.       p2 = Work ;
  388.       while ( *p1 )
  389.       {
  390.     *p2 = *p1 ;
  391.     p1 ++ ;
  392.     p2 ++ ;
  393.     if ( *p1 )
  394.     {
  395.       if ( strlen((PCHAR)p1) % 3 == 0 )
  396.       {
  397.         *p2 = CountryInfo.szThousandsSeparator [0] ;
  398.         p2 ++ ;
  399.       }
  400.     }
  401.       }
  402.       *p2 = 0 ;
  403.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  404.     }
  405.  
  406.     Text[strlen(PCHAR(Text))+1] = 0 ;
  407.     if ( Size < 0x80000 )
  408.       Text[strlen((PCHAR)Text)] = ' ' ;
  409.     else
  410.       Text[strlen((PCHAR)Text)] = 'K' ;
  411.  
  412.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  413.   }
  414. }
  415.  
  416.  
  417. ULONG SpoolSize::NewValue ( void )
  418. {
  419.   ULONG PathSize ;
  420.   DosQuerySysInfo ( QSV_MAX_PATH_LENGTH, QSV_MAX_PATH_LENGTH, &PathSize, sizeof(PathSize) ) ;
  421.  
  422.   PBYTE Path = malloc ( PathSize ) ;
  423.   if ( Path == NULL )
  424.   {
  425.     Log ( "ERROR: Unable to allocate memory for spool-file search path.\r\n" ) ;
  426.     return ( 0 ) ;
  427.   }
  428.  
  429.   PFILEFINDBUF3 Found = malloc ( PathSize + sizeof(FILEFINDBUF3) ) ;
  430.   if ( Found == NULL )
  431.   {
  432.     Log ( "ERROR: Unable to allocate memory for spool-file search result structure.\r\n" ) ;
  433.     free ( Path ) ;
  434.     return ( 0 ) ;
  435.   }
  436.  
  437.   strcpy ( (PCHAR)Path, (PCHAR)SpoolPath ) ;
  438.   strcat ( (PCHAR)Path, "\\*.*" ) ;
  439.  
  440.   HDIR hDir = (HDIR) HDIR_CREATE ;
  441.   ULONG Count = 1 ;
  442.   ULONG TotalSize = 0 ;
  443.  
  444.   if ( !DosFindFirst2 ( Path, &hDir,
  445.     FILE_NORMAL | FILE_READONLY | FILE_DIRECTORY | FILE_ARCHIVED,
  446.     Found, PathSize+sizeof(FILEFINDBUF3), &Count, FIL_STANDARD ) )
  447.   {
  448.  
  449.     do
  450.     {
  451.  
  452.       if ( !strcmp ( (PCHAR)Found->achName, "." )
  453.     OR !strcmp ( (PCHAR)Found->achName, ".." ) )
  454.       {
  455.     continue ;
  456.       }
  457.  
  458.       if ( Found->attrFile & FILE_DIRECTORY )
  459.       {
  460.     HDIR hDir = (HDIR) HDIR_CREATE ;
  461.  
  462.     strcpy ( (PCHAR)Path, (PCHAR)SpoolPath ) ;
  463.     strcat ( (PCHAR)Path, "\\" ) ;
  464.     strcat ( (PCHAR)Path, (PCHAR)Found->achName ) ;
  465.     strcat ( (PCHAR)Path, "\\*.*" ) ;
  466.  
  467.     Count = 1 ;
  468.     if ( !DosFindFirst2 ( Path, &hDir,
  469.       FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED,
  470.       Found, PathSize+sizeof(FILEFINDBUF3), &Count, FIL_STANDARD ) )
  471.     {
  472.       do
  473.       {
  474.         TotalSize += Found->cbFileAlloc ;
  475.       }
  476.       while ( !DosFindNext ( hDir, Found, PathSize+sizeof(FILEFINDBUF3), &Count ) ) ;
  477.       DosFindClose ( hDir ) ;
  478.     }
  479.  
  480.     Count = 1 ;
  481.       }
  482.  
  483.       else
  484.       {
  485.     TotalSize += Found->cbFileAlloc ;
  486.       }
  487.     }
  488.     while ( !DosFindNext ( hDir, Found, PathSize+sizeof(FILEFINDBUF3), &Count ) ) ;
  489.  
  490.     DosFindClose ( hDir ) ;
  491.   }
  492.  
  493.   free ( Path ) ;
  494.   free ( Found ) ;
  495.  
  496.   return ( TotalSize ) ;
  497. }
  498.  
  499.  
  500. VOID SpoolSize::Repaint
  501. (
  502.   HPS hPS,
  503.   RECTL &Rectangle,
  504.   COLOR TextColor,
  505.   COLOR BackColor,
  506.   BOOL Mandatory
  507. )
  508. {
  509.   ULONG Size = NewValue ( ) ;
  510.  
  511.   if ( Mandatory || ( Size != Value ) )
  512.   {
  513.     BYTE Text [100] ;
  514.  
  515.     if ( Size < 0x80000 )
  516.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  517.     else
  518.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  519.  
  520.     {
  521.       PBYTE p1, p2 ;
  522.       BYTE Work[100] ;
  523.  
  524.       p1 = Text ;
  525.       p2 = Work ;
  526.       while ( *p1 )
  527.       {
  528.     *p2 = *p1 ;
  529.     p1 ++ ;
  530.     p2 ++ ;
  531.     if ( *p1 )
  532.     {
  533.       if ( strlen((PCHAR)p1) % 3 == 0 )
  534.       {
  535.         *p2 = CountryInfo.szThousandsSeparator [0] ;
  536.         p2 ++ ;
  537.       }
  538.     }
  539.       }
  540.       *p2 = 0 ;
  541.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  542.     }
  543.  
  544.     Text[strlen(PCHAR(Text))+1] = 0 ;
  545.     if ( Size < 0x80000 )
  546.       Text[strlen((PCHAR)Text)] = ' ' ;
  547.     else
  548.       Text[strlen((PCHAR)Text)] = 'K' ;
  549.  
  550.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  551.   }
  552. }
  553.  
  554.  
  555. ULONG CpuLoad::NewValue ( void )
  556. {
  557.   MaxCount = (ULONG) max ( MaxCount, *IdleCount ) ;
  558.  
  559.   ULONG Load = ( ( MaxCount - *IdleCount ) * 100 ) / MaxCount ;
  560.  
  561.   return ( Load ) ;
  562. }
  563.  
  564.  
  565. VOID CpuLoad::Repaint
  566. (
  567.   HPS hPS,
  568.   RECTL &Rectangle,
  569.   COLOR TextColor,
  570.   COLOR BackColor,
  571.   BOOL Mandatory
  572. )
  573. {
  574.   ULONG Load = NewValue ( ) ;
  575.  
  576.   if ( Mandatory || ( Load != Value ) )
  577.   {
  578.     BYTE Text [100] ;
  579.     sprintf ( (PCHAR)Text, "%lu%%", Load ) ;
  580.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Load ) ;
  581.   }
  582. }
  583.  
  584.  
  585. ULONG TaskCount::NewValue ( void )
  586. {
  587.   return ( WinQuerySwitchList ( Anchor, NULL, 0 ) ) ;
  588. }
  589.  
  590.  
  591. VOID TaskCount::Repaint
  592. (
  593.   HPS hPS,
  594.   RECTL &Rectangle,
  595.   COLOR TextColor,
  596.   COLOR BackColor,
  597.   BOOL Mandatory
  598. )
  599. {
  600.   ULONG Count = NewValue ( ) ;
  601.  
  602.   if ( Mandatory || ( Count != Value ) )
  603.   {
  604.     BYTE Text [100] ;
  605.     sprintf ( (PCHAR)Text, "%lu ", Count ) ;
  606.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Count ) ;
  607.   }
  608. }
  609.  
  610.  
  611. ULONG DriveFree::NewValue ( void )
  612. {
  613.   if ( Error )
  614.   {
  615.     return ( 0 ) ;
  616.   }
  617.  
  618.   DosError ( FERR_DISABLEHARDERR ) ;
  619.  
  620.   FSALLOCATE Allocation ;
  621.   USHORT Status = DosQueryFSInfo ( DriveNumber, FSIL_ALLOC, (PBYTE)&Allocation, sizeof(Allocation) ) ;
  622.  
  623.   DosError ( FERR_ENABLEHARDERR ) ;
  624.  
  625.   if ( Status )
  626.   {
  627.     Error = TRUE ;
  628.     return ( 0 ) ;
  629.   }
  630.  
  631.   return ( Allocation.cUnitAvail*Allocation.cSectorUnit*Allocation.cbSector ) ;
  632. }
  633.  
  634.  
  635. VOID DriveFree::Repaint
  636. (
  637.   HPS hPS,
  638.   RECTL &Rectangle,
  639.   COLOR TextColor,
  640.   COLOR BackColor,
  641.   BOOL Mandatory
  642. )
  643. {
  644.   ULONG Size = NewValue ( ) ;
  645.  
  646.   if ( Mandatory || ( Size != Value ) )
  647.   {
  648.     BYTE Text [100] ;
  649.  
  650.     if ( Error )
  651.     {
  652.       strcpy ( PCHAR(Text), PCHAR(DriveError->Ptr()) ) ;
  653.     }
  654.     else
  655.     {
  656.       if ( Size < 0x80000 )
  657.     sprintf ( (PCHAR)Text, "%lu", Size ) ;
  658.       else
  659.     sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  660.  
  661.       {
  662.     PBYTE p1, p2 ;
  663.     BYTE Work[100] ;
  664.  
  665.     p1 = Text ;
  666.     p2 = Work ;
  667.     while ( *p1 )
  668.     {
  669.       *p2 = *p1 ;
  670.       p1 ++ ;
  671.       p2 ++ ;
  672.       if ( *p1 )
  673.       {
  674.         if ( strlen((PCHAR)p1) % 3 == 0 )
  675.         {
  676.           *p2 = CountryInfo.szThousandsSeparator [0] ;
  677.           p2 ++ ;
  678.         }
  679.       }
  680.     }
  681.     *p2 = 0 ;
  682.     strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  683.       }
  684.  
  685.       Text[strlen(PCHAR(Text))+1] = 0 ;
  686.       if ( Size < 0x80000 )
  687.     Text[strlen((PCHAR)Text)] = ' ' ;
  688.       else
  689.     Text[strlen((PCHAR)Text)] = 'K' ;
  690.     }
  691.  
  692.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  693.   }
  694. }
  695.