home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / dtime / data.1 / Dtime.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-08  |  15.1 KB  |  476 lines
  1. /*
  2. Module : DTIME.cpp
  3. Purpose: Defines the initialization routines for the DLL.
  4. Created: PJN / DATE/1 / 22-02-1996
  5. History: None
  6.  
  7. Copyright (c) 1995 by PJ Naughter.  
  8. All rights reserved.
  9.  
  10. */
  11.  
  12. /////////////////////////////////  Includes  //////////////////////////////////
  13. #include "stdafx.h"  
  14. #include <memory.h>
  15. #include "win32sup.h"
  16. #include "dtime.h"
  17. #include "dtwinver.h"
  18. #ifdef _WINDOWS
  19. #include <afxdllx.h>
  20. #endif
  21.  
  22.  
  23.  
  24. ///////////////////////////////// Locals //////////////////////////////////////
  25. #ifdef _WINDOWS
  26. static AFX_EXTENSION_MODULE DtimeDLL = { NULL, NULL };
  27. #endif
  28.  
  29.  
  30. /////////////////////////////////  Macros  ////////////////////////////////////
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif         
  36.  
  37.  
  38.  
  39. /////////////////////////////// Implementation ////////////////////////////////
  40. #ifdef _WINDOWS
  41. #ifdef _WIN32
  42. extern "C" int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
  43. {
  44.   if (dwReason == DLL_PROCESS_ATTACH)
  45.   {
  46.     TRACE0("DTIME Extension DLL Initializing\n");
  47.  
  48.     // Extension DLL one-time initialization
  49.     AfxInitExtensionModule(DtimeDLL, hInstance);
  50.  
  51.     // Insert this DLL into the resource chain
  52.     new CDynLinkLibrary(DtimeDLL);
  53.   }
  54.   else if (dwReason == DLL_PROCESS_DETACH)
  55.   {
  56.     TRACE0("DTIME Extension DLL Terminating\n");
  57.  
  58.     // Extension DLL one-time deinitialization
  59.     AfxTermExtensionModule(DtimeDLL);
  60.   }
  61.  
  62.   return 1;   // ok
  63. }
  64. #else
  65. extern "C" int CALLBACK LibMain(HINSTANCE hInstance, WORD, WORD, LPSTR)
  66. {                                              
  67.   TRACE0("DTIME Extension DLL Initializing\n");
  68.   AfxInitExtensionModule(DtimeDLL, hInstance);
  69.   return 1;
  70. }       
  71.  
  72. extern "C" int FAR PASCAL _WEP(int)
  73. {
  74.   TRACE0("DTIME Extension DLL Terminating\n");
  75.   return 1;
  76. }
  77.  
  78. #endif //_WIN32
  79. #endif //_WINDOWS
  80.  
  81. void InitDTime()
  82. {   
  83.   //Display some TRACE statements about the version of the DTime dll
  84.   #ifdef _WIN32
  85.     WORD wDTimeVer = ::GetDTimeVersion();
  86.     CString sVer;
  87.     sVer.Format(CString("%d.%02d"), HIBYTE(wDTimeVer), LOBYTE(wDTimeVer));
  88.  
  89.     #ifdef _UNICODE
  90.     TRACE1("(32 bit Unicode Debug Build) Version: %s (C) PJ Naughter 1996\n", sVer);
  91.     #else
  92.     TRACE1("(32 bit Ascii Debug Build) Version: %s (C) PJ Naughter 1996\n", sVer);
  93.     #endif
  94.   #else
  95.     WORD wDTimeVer = GetDTimeVersion();
  96.     CString sVer;
  97.     sVer.Format("%d.%02d", HIBYTE(wDTimeVer), LOBYTE(wDTimeVer));
  98.     TRACE1("(16 bit Debug Build) Version: %s (C) PJ Naughter 1996\n", sVer); 
  99.                    
  100.     //Also add into the resource chain for Win16 here
  101.     #ifdef _WINDOWS
  102.     new CDynLinkLibrary(DtimeDLL);
  103.     #endif
  104.   #endif           
  105.                  
  106.   //Display some info about which OS we are running on                                                
  107.   #ifdef _DEBUG
  108.     OS_VERSION_INFO osvi;          
  109.     memset(&osvi, 0, sizeof(OS_VERSION_INFO));
  110.     osvi.dwOSVersionInfoSize = sizeof(OS_VERSION_INFO);
  111.     GetOSVersion(&osvi);
  112.  
  113.     //generate a string based on the OS version to display
  114.     CString sOSVer;
  115.     switch (osvi.dwEmulatedPlatformId)
  116.     {
  117.       case PLATFORM_WIN32S:            sOSVer = _T("Win32s");                     break; 
  118.       case PLATFORM_WINDOWS95:         sOSVer = _T("Windows 95");                 break;
  119.       case PLATFORM_NT_WORKSTATION:    sOSVer = _T("Windows NT Workstation");     break;
  120.       case PLATFORM_WINDOWS:           sOSVer = _T("Windows");                    break;
  121.       case PLATFORM_WINDOWSFW:         sOSVer = _T("Windows For Workgroups");     break; 
  122.       case PLATFORM_DOS:               sOSVer = _T("Dos");                        break;
  123.       case PLATFORM_NT_SERVER:         sOSVer = _T("Windows NT Server");          break;
  124.       case PLATFORM_NT_ADVANCEDSERVER: sOSVer = _T("Windows NT Advanced Server"); break;
  125.       default:                         sOSVer = _T("Unknown");                    break;
  126.     }
  127.     CString sBuf;
  128.     sBuf.Format(_T(" v%d."), osvi.dwEmulatedMajorVersion);  
  129.     sOSVer += sBuf;
  130.     sBuf.Format(_T("%02d"), osvi.dwEmulatedMinorVersion); 
  131.     sOSVer += sBuf;
  132.     sBuf.Format(_T(" Build:%d, underlying OS: "), osvi.dwEmulatedBuildNumber); 
  133.     sOSVer += sBuf;
  134.     switch (osvi.dwUnderlyingPlatformId)
  135.     {
  136.       case PLATFORM_WIN32S:            sBuf = _T("Win32s");                     break;
  137.       case PLATFORM_WINDOWS95:         sBuf = _T("Windows 95");                 break;
  138.       case PLATFORM_NT_WORKSTATION:    sBuf = _T("Windows NT Workstation");     break;
  139.       case PLATFORM_WINDOWS:           sBuf = _T("Windows");                    break;
  140.       case PLATFORM_WINDOWSFW:         sBuf = _T("Windows For Workgroups");     break;
  141.       case PLATFORM_DOS:               sBuf = _T("Dos");                        break;
  142.       case PLATFORM_NT_SERVER:         sBuf = _T("Windows NT Server");          break;
  143.       case PLATFORM_NT_ADVANCEDSERVER: sBuf = _T("Windows NT Advanced Server"); break;
  144.       default:                         sBuf = _T("Unknown");                    break;
  145.     } 
  146.     sOSVer += sBuf;
  147.     sBuf.Format(_T(" v%d."), osvi.dwUnderlyingMajorVersion);
  148.     sOSVer += sBuf;
  149.     sBuf.Format(_T("%02d"), osvi.dwUnderlyingMinorVersion);
  150.     sOSVer += sBuf;
  151.     sBuf.Format(_T(" Build:%d"), osvi.dwUnderlyingBuildNumber); 
  152.     sOSVer += sBuf;
  153.     TRACE1("Running on OS: %s\n", sOSVer);
  154.   #endif
  155. }
  156.  
  157.  
  158. void TermDTime()
  159. {             
  160.   //Empty the static CStrings stored in the
  161.   //4 main classes. This avoids false
  162.   //memory leak statements displayed when DTime 
  163.   //is used by a Win16 app.          
  164.   
  165.   CDate::ClearStatics();
  166.   CLDate::ClearStatics();
  167.   CLTimeSpan::ClearStatics();
  168.   CLTimeOfDay::ClearStatics();  
  169. }
  170.                    
  171.                    
  172. WORD GetDTimeVersion()
  173. {
  174.   return 0x010b;       //v1.0   Original Release
  175.                        //v1.1   Port to Win16 / Dos
  176.                        //v1.11  Now includes German translation, minor bug fixes
  177. }
  178.  
  179.  
  180. BOOL InitDTimeSettings()
  181. {
  182.   BOOL bSuccess = FALSE;
  183.  
  184.   BOOL bUseRegistry;
  185. #ifdef _WIN32
  186.   bUseRegistry = TRUE;
  187.   
  188.   OSVERSIONINFO osvi;
  189.   GetVersionEx(&osvi);
  190.   if (osvi.dwPlatformId == VER_PLATFORM_WIN32s)
  191.     bUseRegistry = FALSE;
  192. #else                 
  193.   bUseRegistry = FALSE;
  194. #endif  
  195.  
  196. #ifdef _WIN32
  197.   if (bUseRegistry)
  198.   {
  199.     //use the registry if we are on Win32c or Win32n
  200.       
  201.     // Read the settings from the registry
  202.     // Try opening the registry key:
  203.     // HKEY_CURRENT_USER\Control Panel\DTime
  204.     HKEY hcpl;
  205.     if (RegOpenKeyEx(HKEY_CURRENT_USER,
  206.                      _T("Control Panel"),
  207.                      0,
  208.                      KEY_QUERY_VALUE,
  209.                      &hcpl) == ERROR_SUCCESS) 
  210.     {
  211.       HKEY happ;
  212.       if (RegOpenKeyEx(hcpl,
  213.                        _T("DTime"),
  214.                        0,
  215.                        KEY_QUERY_VALUE,
  216.                        &happ) == ERROR_SUCCESS) 
  217.       {
  218.         bSuccess = TRUE;
  219.         // Yes we are installed
  220.     
  221.         //First the begining day of week
  222.         DWORD wBeginDayOfWeek;
  223.         DWORD dwType = 0;
  224.         DWORD dwSize = sizeof(wBeginDayOfWeek);
  225.         LONG lSuccess = RegQueryValueEx(happ,
  226.                         _T("BeginDayOfWeek"),
  227.                         NULL,
  228.                         &dwType,
  229.                         (BYTE*)&wBeginDayOfWeek,
  230.                         &dwSize);
  231.         CDate::SetBeginingDayOfWeek((WORD) wBeginDayOfWeek);
  232.     
  233.     
  234.     
  235.         //the day part of the julian end date
  236.         dwType = 0;
  237.         DWORD Day;
  238.         dwSize = sizeof(DWORD);
  239.         lSuccess = RegQueryValueEx(happ,
  240.                         _T("JulianEndDay"),
  241.                         NULL,
  242.                         &dwType,
  243.                         (BYTE*)&Day,
  244.                         &dwSize);
  245.     
  246.         //the month part of the julian end date
  247.         dwType = 0;
  248.         DWORD Month;
  249.         dwSize = sizeof(DWORD);
  250.         lSuccess = RegQueryValueEx(happ,
  251.                         _T("JulianEndMonth"),
  252.                         NULL,
  253.                         &dwType,
  254.                         (BYTE*)&Month,
  255.                         &dwSize);
  256.     
  257.         //the year part of the julian end date
  258.         dwType = 0;
  259.         LONG Year;
  260.         dwSize = sizeof(LONG);
  261.         lSuccess = RegQueryValueEx(happ,
  262.                         _T("JulianEndYear"),
  263.                         NULL,
  264.                         &dwType,
  265.                         (BYTE*)&Year,
  266.                         &dwSize);
  267.     
  268.         CDate::SetEndJulianCalendar(Year, (WORD) Month, (WORD) Day);
  269.     
  270.     
  271.     
  272.         //the day part of the gregorian begin date
  273.         dwType = 0;
  274.         dwSize = sizeof(DWORD);
  275.         lSuccess = RegQueryValueEx(happ,
  276.                         _T("GregorianBeginDay"),
  277.                         NULL,
  278.                         &dwType,
  279.                         (BYTE*)&Day,
  280.                         &dwSize);
  281.     
  282.         //the month part of the gregorian begin date
  283.         dwType = 0;
  284.         dwSize = sizeof(DWORD);
  285.         lSuccess = RegQueryValueEx(happ,
  286.                         _T("GregorianBeginMonth"),
  287.                         NULL,
  288.                         &dwType,
  289.                         (BYTE*)&Month,
  290.                         &dwSize);
  291.     
  292.         //the year part of the gregorian begin date
  293.         dwType = 0;
  294.         dwSize = sizeof(LONG);
  295.         lSuccess = RegQueryValueEx(happ,
  296.                         _T("GregorianBeginYear"),
  297.                         NULL,
  298.                         &dwType,
  299.                         (BYTE*)&Year,
  300.                         &dwSize);
  301.     
  302.         CDate::SetBeginGregCalendar(Year, (WORD) Month, (WORD) Day);
  303.     
  304.     
  305.     
  306.     
  307.         //the default CDate format string
  308.         CString sDefaultFormat;
  309.         dwSize = 1024;
  310.         LPTSTR pBuf = sDefaultFormat.GetBufferSetLength(dwSize);
  311.         lSuccess = RegQueryValueEx(happ,
  312.                         _T("CDateDefaultFormat"),
  313.                         NULL,
  314.                         &dwType,
  315.                         (BYTE*)pBuf,
  316.                         &dwSize);
  317.         sDefaultFormat.ReleaseBuffer();
  318.         CDate::SetDefaultFormat(sDefaultFormat);
  319.     
  320.         //the default CLDate format string
  321.         dwSize = 1024;
  322.         pBuf = sDefaultFormat.GetBufferSetLength(dwSize);
  323.         lSuccess = RegQueryValueEx(happ,
  324.                         _T("CLDateDefaultFormat"),
  325.                         NULL,
  326.                         &dwType,
  327.                         (BYTE*)pBuf,
  328.                         &dwSize);
  329.         sDefaultFormat.ReleaseBuffer();
  330.         CLDate::SetDefaultFormat(sDefaultFormat);
  331.     
  332.         //the default CLTimeSpan format string
  333.         dwSize = 1024;
  334.         pBuf = sDefaultFormat.GetBufferSetLength(dwSize);
  335.         lSuccess = RegQueryValueEx(happ,
  336.                         _T("CLTimeSpanDefaultFormat"),
  337.                         NULL,
  338.                         &dwType,
  339.                         (BYTE*)pBuf,
  340.                         &dwSize);
  341.         sDefaultFormat.ReleaseBuffer();
  342.         CLTimeSpan::SetDefaultFormat(sDefaultFormat);
  343.     
  344.         //the default CLTimeOfDay format string
  345.         dwSize = 1024;
  346.         pBuf = sDefaultFormat.GetBufferSetLength(dwSize);
  347.         lSuccess = RegQueryValueEx(happ,
  348.                         _T("CLTimeOfDayDefaultFormat"),
  349.                         NULL,
  350.                         &dwType,
  351.                         (BYTE*)pBuf,
  352.                         &dwSize);
  353.         sDefaultFormat.ReleaseBuffer();
  354.         CLTimeOfDay::SetDefaultFormat(sDefaultFormat);
  355.     
  356.         RegCloseKey(happ);
  357.       }
  358.       RegCloseKey(hcpl);
  359.     }  
  360.   }
  361. #endif                  
  362.   bSuccess = TRUE;
  363.  
  364.  
  365.   if (!bUseRegistry)
  366.   { 
  367.     //Use environment variables to configure DTIME if on Win32s, Win16 or Dos. 
  368.     //Ini files could have been used on Win32s, Win16 but then another
  369.     //method would be required for Dos as the Get/Write Profile.. are Windows
  370.     //specific
  371.     
  372.     char* pszCDateFormat = MyGetEnv("DATE_FMT");
  373.     if (pszCDateFormat)
  374.       CDate::SetDefaultFormat(pszCDateFormat);
  375.       
  376.     char* pszCLDateFormat = MyGetEnv("LDATE_FMT");
  377.     if (pszCLDateFormat)
  378.       CLDate::SetDefaultFormat(pszCLDateFormat);
  379.       
  380.     char* pszCLTimeSpanFormat = MyGetEnv("TS_FMT");
  381.     if (pszCLTimeSpanFormat)
  382.       CLTimeSpan::SetDefaultFormat(pszCLTimeSpanFormat);
  383.       
  384.     char* pszCLTimeOfDayFormat = MyGetEnv("TOD_FMT");
  385.     if (pszCLTimeOfDayFormat)
  386.       CLTimeOfDay::SetDefaultFormat(pszCLTimeOfDayFormat);
  387.                                        
  388.     char* pszBeginDayOfWeek = MyGetEnv("BDOW");
  389.     if (pszBeginDayOfWeek)
  390.       CDate::SetBeginingDayOfWeek((WORD) atoi(pszBeginDayOfWeek));
  391.  
  392.     char* pszEnvVar = MyGetEnv("JUL_END");
  393.     if (pszEnvVar)
  394.     {              
  395.       //take a copy of the string so that any changes
  396.       //we make will not be reflected back into the environment
  397.       char* pszJulianEnd = new char[strlen(pszEnvVar)];
  398.       
  399.       if (pszJulianEnd)
  400.       {
  401.         strcpy(pszJulianEnd, pszEnvVar);
  402.   
  403.         BOOL bParseOK = TRUE;
  404.         long Year;
  405.         WORD Month;
  406.         WORD Day;               
  407.         char* sepChars = " ";
  408.                 
  409.         char* pszTok = strtok(pszJulianEnd, sepChars);
  410.         bParseOK = (pszTok != NULL);         
  411.         if (bParseOK)
  412.           Year = atol(pszTok);
  413.         
  414.         pszTok = strtok(NULL, sepChars); 
  415.         bParseOK = bParseOK && (pszTok != NULL);         
  416.         if (bParseOK)
  417.           Month = (WORD) atoi(pszTok);   
  418.   
  419.         pszTok = strtok(NULL, sepChars);             
  420.         bParseOK = bParseOK && (pszTok != NULL);               
  421.         if (bParseOK)
  422.           Day = (WORD) atoi(pszTok);
  423.         
  424.         if (bParseOK)
  425.           //CDate::SetEndJulianCalendar(Year, Month, Day);
  426.           
  427.         delete []pszJulianEnd;
  428.       }  
  429.     }                                                              
  430.     
  431.     pszEnvVar = MyGetEnv("GREG_BEGIN");
  432.     if (pszEnvVar)
  433.     {                                       
  434.       //take a copy of the string so that any changes
  435.       //we make will not be reflected back into the environment
  436.       char* pszGregBegin = new char[strlen(pszEnvVar)];
  437.       
  438.       if (pszGregBegin)
  439.       {
  440.         strcpy(pszGregBegin, pszEnvVar);
  441.       
  442.         BOOL bParseOK = TRUE;
  443.         long Year;
  444.         WORD Month;
  445.         WORD Day;            
  446.         char* sepChars = " ";
  447.                 
  448.         char* pszTok = strtok(pszGregBegin, sepChars);
  449.         bParseOK = (pszTok != NULL);         
  450.         if (bParseOK)
  451.           Year = atol(pszTok);
  452.         
  453.         pszTok = strtok(NULL, sepChars); 
  454.         bParseOK = bParseOK && (pszTok != NULL);         
  455.         if (bParseOK)
  456.           Month = (WORD) atoi(pszTok);   
  457.   
  458.         pszTok = strtok(NULL, sepChars);             
  459.         bParseOK = bParseOK && (pszTok != NULL);               
  460.         if (bParseOK)
  461.           Day = (WORD) atoi(pszTok);
  462.         
  463.         if (bParseOK)
  464.           //CDate::SetBeginGregCalendar(Year, Month, Day);
  465.           
  466.         delete []pszGregBegin;
  467.       }  
  468.     }                                                              
  469.   }
  470.  
  471.   return bSuccess;
  472. }
  473.  
  474.                    
  475.  
  476.