sal/osl/w32/time.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21 #include "system.h"
  22
  23 #include "filetime.hxx"
  24 #include "time.hxx"
  25
  26 #include <osl/diagnose.h>
  27 #include <osl/time.h>
  28 #include <sys/timeb.h>
  29
  30 sal_Bool SAL_CALL osl_getSystemTime(TimeValue* pTimeVal)
  31 {
  32     unsigned __int64 CurTime;
  33
  34     typedef VOID (WINAPI *GetSystemTimePreciseAsFileTime_PROC)(LPFILETIME);
  35
  36     OSL_ASSERT(pTimeVal != nullptr);
  37
  38     static GetSystemTimePreciseAsFileTime_PROC pGetSystemTimePreciseAsFileTime = []()
  39     {
  40         HMODULE hModule = GetModuleHandleW( L"Kernel32.dll" );
  41         return reinterpret_cast<GetSystemTimePreciseAsFileTime_PROC>(
  42                 GetProcAddress(hModule, "GetSystemTimePreciseAsFileTime"));
  43     }();
  44
  45     // use ~1 microsecond resolution if available
  46     if (pGetSystemTimePreciseAsFileTime)
  47         pGetSystemTimePreciseAsFileTime(reinterpret_cast<LPFILETIME>(&CurTime));
  48     else
  49     {
  50         SYSTEMTIME SystemTime;
  51         GetSystemTime(&SystemTime);
  52         SystemTimeToFileTime(&SystemTime, reinterpret_cast<LPFILETIME>(&CurTime));
  53     }
  54
  55     static const unsigned __int64 OffTime = [] {
  56         SYSTEMTIME SystemTime;
  57         SystemTime.wYear = 1970;
  58         SystemTime.wMonth = 1;
  59         SystemTime.wDayOfWeek = 0;
  60         SystemTime.wDay = 1;
  61         SystemTime.wHour = 0;
  62         SystemTime.wMinute = 0;
  63         SystemTime.wSecond = 0;
  64         SystemTime.wMilliseconds = 0;
  65
  66         unsigned __int64 ft;
  67         SystemTimeToFileTime(&SystemTime, reinterpret_cast<LPFILETIME>(&ft));
  68         return ft;
  69     }();
  70
  71     const unsigned __int64 Value = CurTime - OffTime;
  72
  73     pTimeVal->Seconds  = static_cast<unsigned long>(Value / 10000000L);
  74     pTimeVal->Nanosec  = static_cast<unsigned long>((Value % 10000000L) * 100);
  75
  76     return true;
  77 }
  78
  79 sal_Bool SAL_CALL osl_getDateTimeFromTimeValue( const TimeValue* pTimeVal, oslDateTime* pDateTime )
  80 {
  81     FILETIME    aFileTime;
  82     SYSTEMTIME  aSystemTime;
  83
  84     if ( TimeValueToFileTime(pTimeVal, &aFileTime) )
  85     {
  86         if ( FileTimeToSystemTime( &aFileTime, &aSystemTime ) )
  87         {
  88             pDateTime->NanoSeconds  =   pTimeVal->Nanosec;
  89
  90             pDateTime->Seconds      =   aSystemTime.wSecond;
  91             pDateTime->Minutes      =   aSystemTime.wMinute;
  92             pDateTime->Hours        =   aSystemTime.wHour;
  93             pDateTime->Day          =   aSystemTime.wDay;
  94             pDateTime->DayOfWeek    =   aSystemTime.wDayOfWeek;
  95             pDateTime->Month        =   aSystemTime.wMonth;
  96             pDateTime->Year         =   aSystemTime.wYear;
  97
  98             return true;
  99         }
 100     }
 101
 102     return false;
 103 }
 104
 105 sal_Bool SAL_CALL osl_getTimeValueFromDateTime( const oslDateTime* pDateTime, TimeValue* pTimeVal )
 106 {
 107     FILETIME    aFileTime;
 108     SYSTEMTIME  aSystemTime;
 109
 110     aSystemTime.wMilliseconds   =   0;
 111     aSystemTime.wSecond         =   pDateTime->Seconds;
 112     aSystemTime.wMinute         =   pDateTime->Minutes;
 113     aSystemTime.wHour           =   pDateTime->Hours;
 114     aSystemTime.wDay            =   pDateTime->Day;
 115     aSystemTime.wDayOfWeek      =   pDateTime->DayOfWeek;
 116     aSystemTime.wMonth          =   pDateTime->Month;
 117     aSystemTime.wYear           =   pDateTime->Year;
 118
 119     if ( SystemTimeToFileTime( &aSystemTime, &aFileTime ) )
 120     {
 121         if (FileTimeToTimeValue( &aFileTime, pTimeVal  ) )
 122         {
 123             pTimeVal->Nanosec = pDateTime->NanoSeconds;
 124             return true;
 125         }
 126     }
 127
 128     return false;
 129 }
 130
 131 sal_Bool SAL_CALL osl_getLocalTimeFromSystemTime( const TimeValue* pSystemTimeVal, TimeValue* pLocalTimeVal )
 132 {
 133     TIME_ZONE_INFORMATION aTimeZoneInformation;
 134
 135     // get timezone information
 136     DWORD Success = GetTimeZoneInformation( &aTimeZoneInformation );
 137     if (Success == TIME_ZONE_ID_INVALID)
 138         return false;
 139
 140     sal_Int64 bias = aTimeZoneInformation.Bias;
 141
 142     // add bias for daylight saving time
 143     if ( Success == TIME_ZONE_ID_DAYLIGHT )
 144         bias+=aTimeZoneInformation.DaylightBias;
 145
 146     if ( static_cast<sal_Int64>(pSystemTimeVal->Seconds) > ( bias * 60 ) )
 147     {
 148         pLocalTimeVal->Seconds = static_cast<sal_uInt32>(pSystemTimeVal->Seconds - ( bias * 60) );
 149         pLocalTimeVal->Nanosec = pSystemTimeVal->Nanosec;
 150
 151         return true;
 152     }
 153     return false;
 154 }
 155
 156 sal_Bool SAL_CALL osl_getSystemTimeFromLocalTime( const TimeValue* pLocalTimeVal, TimeValue* pSystemTimeVal )
 157 {
 158     TIME_ZONE_INFORMATION aTimeZoneInformation;
 159
 160     // get timezone information
 161     DWORD Success = GetTimeZoneInformation( &aTimeZoneInformation );
 162     if ( Success == TIME_ZONE_ID_INVALID )
 163         return false;
 164
 165     sal_Int64 bias = aTimeZoneInformation.Bias;
 166
 167     // add bias for daylight saving time
 168     if ( Success == TIME_ZONE_ID_DAYLIGHT )
 169         bias+=aTimeZoneInformation.DaylightBias;
 170
 171     if ( static_cast<sal_Int64>(pLocalTimeVal->Seconds) + ( bias * 60 ) > 0 )
 172     {
 173         pSystemTimeVal->Seconds = static_cast<sal_uInt32>( pLocalTimeVal->Seconds + ( bias * 60) );
 174         pSystemTimeVal->Nanosec = pLocalTimeVal->Nanosec;
 175
 176         return true;
 177     }
 178
 179     return false;
 180 }
 181
 182 static struct _timeb startTime;
 183 void sal_initGlobalTimer()
 184 {
 185     _ftime( &startTime );
 186 }
 187
 188 sal_uInt32 SAL_CALL osl_getGlobalTimer(void)
 189 {
 190   struct _timeb currentTime;
 191   sal_uInt32 nSeconds;
 192
 193   _ftime( &currentTime );
 194
 195   nSeconds = static_cast<sal_uInt32>( currentTime.time - startTime.time );
 196
 197   return ( nSeconds * 1000 ) + static_cast<long>( currentTime.millitm - startTime.millitm );
 198 }
 199
 200 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */