home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / msj / msjv6_1 / wintro4 / db.c next >
Encoding:
C/C++ Source or Header  |  1991-01-01  |  7.3 KB  |  245 lines
  1. /*===========================================================================*/
  2. /*                                                                           */
  3. /* File    : DB.C                                                            */
  4. /*                                                                           */
  5. /* Purpose : Simple database routines for the stock charting application.    */
  6. /*                                                                           */
  7. /* History :                                                                 */
  8. /*                                                                           */
  9. /* (C) Copyright 1989,1990 Marc Adler/Magma Systems     All Rights Reserved  */
  10. /*===========================================================================*/
  11.  
  12. #include <string.h>
  13. #include <fcntl.h>
  14. #include <io.h>
  15. #include <sys\types.h>
  16. #include <sys\stat.h>
  17.  
  18. #include "windows.h"
  19. #include "stock.h"
  20.  
  21.  
  22. /****************************************************************************/
  23. /*                                                                          */
  24. /* Function : StockFIleRead()                                               */
  25. /*                                                                          */
  26. /* Purpose  : Reads a stock file in from the disk and allocates a stock     */
  27. /*            information structure for it.                                 */
  28. /*                                                                          */
  29. /* Returns  : TRUE if the stock file was read, FALSE if not.                */
  30. /*                                                                          */
  31. /****************************************************************************/
  32. int PASCAL StockFileRead(LPSTR szFileName)
  33. {
  34.   char         sz[128];
  35.   int          fd;
  36.   int          rc = FALSE;
  37.   HANDLE       hStockInfo;
  38.   LPSTOCKINFO  lpStockInfo;
  39.   LPTICK       lpTick;
  40.   HWND         hWnd;
  41.  
  42.   /*
  43.     Make sure it has the .STO extension if the user didn't specify one
  44.   */
  45.   lstrcpy((LPSTR) sz, szFileName);
  46.   if (!strchr(sz, '.'))
  47.     strcat(sz, ".sto");
  48.  
  49.   /*
  50.     Open the file for reading
  51.   */
  52.   if ((fd = _lopen(sz, O_RDONLY | O_BINARY)) < 0)
  53.   {
  54.     MessageBox(hWndMain, "Can't open the stock file for reading", "Error", MB_OK);
  55.     return FALSE;
  56.   }
  57.  
  58.   /*
  59.     Allocate space for the stock-file header
  60.   */
  61.   if ((hStockInfo = GlobalAlloc(GMEM_MOVEABLE, (DWORD) sizeof(STOCKINFO))) == NULL)
  62.     goto bye;
  63.   if ((lpStockInfo = (LPSTOCKINFO) GlobalLock(hStockInfo)) == NULL)
  64.   {
  65.     MessageBox(hWndMain, "Can't allocate the stock info structure", "Error", MB_OK);
  66.     GlobalFree(hStockInfo);
  67.     goto bye;
  68.   }
  69.  
  70.   /*
  71.     Save the absolute path name of the file
  72.   */
  73.   lstrcpy(lpStockInfo->szFileName, (LPSTR) sz);
  74.  
  75.   /*
  76.     Read the header
  77.   */
  78.   if (_lread(fd, (LPSTR) &lpStockInfo->StockFile, sizeof(STOCKFILE)) != sizeof(STOCKFILE))
  79.   {
  80.     MessageBox(hWndMain, "Bad stock header format", "Error", MB_OK);
  81.     GlobalUnlock(hStockInfo);
  82.     GlobalFree(hStockInfo);
  83.     goto bye;
  84.   }
  85.  
  86.   /*
  87.     Check the magic number to see if it's really a stock db file
  88.   */
  89.   if (lpStockInfo->StockFile.dwMagic != MAGIC_COOKIE)
  90.   {
  91.     MessageBox(hWndMain, "The file does not have the right signature", "Error", MB_OK);
  92.     GlobalUnlock(hStockInfo);
  93.     GlobalFree(hStockInfo);
  94.     goto bye;
  95.   }
  96.  
  97.   /*
  98.     Allocate global memory to hold the ticks
  99.   */
  100.   if ((lpStockInfo->hTicks = GlobalAlloc(GMEM_MOVEABLE,
  101.               (DWORD) sizeof(TICK) * lpStockInfo->StockFile.nTicks)) == NULL)
  102.   {
  103.     MessageBox(hWndMain, "Can't allocate the ticker array", "Error", MB_OK);
  104.     goto bye;
  105.   }
  106.   lpStockInfo->nTicksAllocated = lpStockInfo->StockFile.nTicks;
  107.   if ((lpTick = (LPTICK) GlobalLock(lpStockInfo->hTicks)) == NULL)
  108.   {
  109.     GlobalFree(lpStockInfo->hTicks);
  110.     goto bye;
  111.   }
  112.  
  113.   /*
  114.     Read the ticks into the global memory buffer
  115.   */
  116.   if (_lread(fd, (LPSTR)lpTick, sizeof(TICK)*lpStockInfo->StockFile.nTicks) != 
  117.       sizeof(TICK) * lpStockInfo->StockFile.nTicks)
  118.   {
  119.     MessageBox(hWndMain, "Error reading the ticker array", "Error", MB_OK);
  120.     GlobalUnlock(lpStockInfo->hTicks);
  121.     GlobalFree(lpStockInfo->hTicks);
  122.     goto bye;
  123.   }
  124.  
  125.   /*
  126.     Create a window for this guy
  127.   */
  128.   hWnd = lpStockInfo->hWnd = GraphCreateWindow((LPSTR) sz);
  129.   SetWindowWord(hWnd, 0, hStockInfo);
  130.   lpStockInfo->dwFlags |= (STATE_HAS_VGRID | STATE_HAS_HGRID);
  131.  
  132.   /*
  133.     Link this entry onto the stock info list
  134.   */
  135.   hCurrStockInfo = hStockInfo;
  136.  
  137.   GlobalUnlock(lpStockInfo->hTicks);
  138.   GlobalUnlock(hStockInfo);
  139.   rc = TRUE;
  140.  
  141.   /*
  142.     Done reading .... close the file
  143.   */
  144. bye:
  145.   close(fd);
  146.  
  147.   InvalidateRect(hWnd, (LPRECT) NULL, TRUE);
  148.   UpdateWindow(hWnd);
  149.   return rc;
  150. }
  151.  
  152.  
  153. int PASCAL StockFileSave(HANDLE hStockInfo)
  154. {
  155.   int    fd;
  156.   char   sz[80];
  157.   LPTICK lpTicks;
  158.   LPSTOCKINFO lpStockInfo;
  159.  
  160.   lpStockInfo = (LPSTOCKINFO) GlobalLock(hStockInfo);
  161.   lpTicks = (LPTICK) GlobalLock(lpStockInfo->hTicks);
  162.  
  163.   lstrcpy((LPSTR) sz, lpStockInfo->szFileName);
  164.   strlwr(sz);
  165.   if ((fd = open(sz, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IREAD|S_IWRITE)) < 0)
  166.   {
  167.     MessageBox(hWndMain, "Cannot open file", sz, MB_OK);
  168.     return FALSE;
  169.   }
  170.   _lwrite(fd, (LPSTR) &lpStockInfo->StockFile, sizeof(STOCKFILE));
  171.   _lwrite(fd, (LPSTR) lpTicks, sizeof(TICK) * lpStockInfo->StockFile.nTicks);
  172.   close(fd);
  173.  
  174.   lpStockInfo->dwFlags &= ~STATE_DIRTY;
  175.  
  176.   MessageBox(hWndMain, "The file has been saved", sz, MB_OK);
  177.   return TRUE;
  178. }
  179.  
  180.  
  181. /****************************************************************************/
  182. /*                                                                          */
  183. /* Function : MakeDummyStockFile()                                          */
  184. /*                                                                          */
  185. /* Purpose  : Creates a dummy stock file for testing purposes.              */
  186. /*                                                                          */
  187. /* Returns  :                                                               */
  188. /*                                                                          */
  189. /****************************************************************************/
  190. #define TEST
  191.  
  192. #ifdef TEST
  193.  
  194. STOCKFILE DummyStockInfo =
  195. {
  196.   MAGIC_COOKIE,
  197.   "IBM",
  198.   "Intl Business Machines",
  199.  
  200.   {
  201.    795, /* dwMinPrice     */
  202.    810, /* dwMaxPrice     */
  203.     1,  /* dwScaleFactor  */
  204.     1,  /* dwTickInterval */
  205.     1,  /* iDenominator   */
  206.     2   /* iGridPen       */
  207.   },
  208.  
  209.   10   /* nTicks */
  210. };
  211.  
  212. TICK DummyTicks[10] =
  213. {
  214.   { 800, 20000L, { 1, 1, 90 } },
  215.   { 802, 20500L, { 1, 2, 90 } },
  216.   { 799, 30000L, { 1, 3, 90 } },
  217.   { 805, 32000L, { 1, 4, 90 } },
  218.   { 802, 28900L, { 1, 5, 90 } },
  219.   { 804, 23500L, { 1, 8, 90 } },
  220.   { 800, 31000L, { 1, 9, 90 } },
  221.   { 801, 23000L, { 1,10, 90 } },
  222.   { 798, 29500L, { 1,11, 90 } },
  223.   { 800, 30000L, { 1,12, 90 } },
  224. };
  225.  
  226. int MakeDummyStockFile(LPSTR szFileName)
  227. {
  228.   int fd;
  229.   int i;
  230.   char sz[80];
  231.  
  232.   lstrcpy((LPSTR) sz, szFileName);
  233.  
  234.   if ((fd = open(sz, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IREAD|S_IWRITE)) < 0)
  235.     return FALSE;
  236.  
  237.   write(fd, (char *) &DummyStockInfo, sizeof(DummyStockInfo));
  238.   for (i = 0;  i < 10;  i++)
  239.     write(fd, (char *) &DummyTicks[i], sizeof(DummyTicks[0]));
  240.  
  241.   close(fd);
  242. }
  243.  
  244. #endif /* TEST */
  245.