Add support for WM_WINDOWPOSCHANGED to save new origin of window.
[wine] / dlls / ntdll / time.c
1 /*
2  * Conversion between Time and TimeFields
3  *
4  * RtlTimeToTimeFields, RtlTimeFieldsToTime and defines are taken from ReactOS and 
5  * adapted to wine with special permissions of the author  
6  * Rex Jolliff (rex@lvcablemodem.com)
7  * 
8  * Copyright 1999 Juergen Schmied
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with this library; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23  */
24
25 #include <string.h>
26 #include <time.h>
27 #include <sys/time.h>
28 #include <unistd.h>
29 #include "ntddk.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
33
34 #define TICKSPERSEC        10000000
35 #define TICKSPERMSEC       10000
36 #define SECSPERDAY         86400
37 #define SECSPERHOUR        3600
38 #define SECSPERMIN         60
39 #define MINSPERHOUR        60
40 #define HOURSPERDAY        24
41 #define EPOCHWEEKDAY       0
42 #define DAYSPERWEEK        7
43 #define EPOCHYEAR          1601
44 #define DAYSPERNORMALYEAR  365
45 #define DAYSPERLEAPYEAR    366
46 #define MONSPERYEAR        12
47
48 /* 1601 to 1970 is 369 years plus 89 leap days */
49 #define SECS_1601_TO_1970  ((369 * 365 + 89) * 86400ULL)
50 /* 1601 to 1980 is 379 years plus 91 leap days */
51 #define SECS_1601_to_1980  ((379 * 365 + 91) * 86400ULL)
52
53
54 static const int YearLengths[2] = {DAYSPERNORMALYEAR, DAYSPERLEAPYEAR};
55 static const int MonthLengths[2][MONSPERYEAR] =
56 {
57         { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
58         { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
59 };
60
61 static inline int IsLeapYear(int Year)
62 {
63         return Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0) ? 1 : 0;
64 }
65
66 static inline void NormalizeTimeFields(CSHORT *FieldToNormalize, CSHORT *CarryField,int Modulus)
67 {
68         *FieldToNormalize = (CSHORT) (*FieldToNormalize - Modulus);
69         *CarryField = (CSHORT) (*CarryField + 1);
70 }
71
72 /******************************************************************************
73  *  RtlTimeToTimeFields         [NTDLL.@]
74  *
75  */
76
77 VOID WINAPI RtlTimeToTimeFields(
78         PLARGE_INTEGER liTime,
79         PTIME_FIELDS TimeFields)
80 {
81         const int *Months;
82         int LeapSecondCorrections, SecondsInDay, CurYear;
83         int LeapYear, CurMonth, GMTOffset;
84         long int Days;
85         long long int Time = *(long long int *)&liTime;
86
87         /* Extract millisecond from time and convert time into seconds */
88         TimeFields->Milliseconds = (CSHORT) ((Time % TICKSPERSEC) / TICKSPERMSEC);
89         Time = Time / TICKSPERSEC;
90
91         /* FIXME: Compute the number of leap second corrections here */
92         LeapSecondCorrections = 0;
93
94         /* FIXME: get the GMT offset here */
95         GMTOffset = 0;
96
97         /* Split the time into days and seconds within the day */
98         Days = Time / SECSPERDAY;
99         SecondsInDay = Time % SECSPERDAY;
100
101         /* Adjust the values for GMT and leap seconds */
102         SecondsInDay += (GMTOffset - LeapSecondCorrections);
103         while (SecondsInDay < 0) 
104         { SecondsInDay += SECSPERDAY;
105           Days--;
106         }
107         while (SecondsInDay >= SECSPERDAY) 
108         { SecondsInDay -= SECSPERDAY;
109           Days++;
110         }
111
112         /* compute time of day */
113         TimeFields->Hour = (CSHORT) (SecondsInDay / SECSPERHOUR);
114         SecondsInDay = SecondsInDay % SECSPERHOUR;
115         TimeFields->Minute = (CSHORT) (SecondsInDay / SECSPERMIN);
116         TimeFields->Second = (CSHORT) (SecondsInDay % SECSPERMIN);
117
118         /* FIXME: handle the possibility that we are on a leap second (i.e. Second = 60) */
119
120         /* compute day of week */
121         TimeFields->Weekday = (CSHORT) ((EPOCHWEEKDAY + Days) % DAYSPERWEEK);
122
123         /* compute year */
124         CurYear = EPOCHYEAR;
125         /* FIXME: handle calendar modifications */
126         while (1)
127         { LeapYear = IsLeapYear(CurYear);
128           if (Days < (long) YearLengths[LeapYear])
129           { break;
130           }
131           CurYear++;
132           Days = Days - (long) YearLengths[LeapYear];
133         }
134         TimeFields->Year = (CSHORT) CurYear;
135
136         /* Compute month of year */
137         Months = MonthLengths[LeapYear];
138         for (CurMonth = 0; Days >= (long) Months[CurMonth]; CurMonth++)
139           Days = Days - (long) Months[CurMonth];
140         TimeFields->Month = (CSHORT) (CurMonth + 1);
141         TimeFields->Day = (CSHORT) (Days + 1);
142 }
143 /******************************************************************************
144  *  RtlTimeFieldsToTime         [NTDLL.@]
145  *
146  */
147 BOOLEAN WINAPI RtlTimeFieldsToTime(
148         PTIME_FIELDS tfTimeFields,
149         PLARGE_INTEGER Time)
150 {
151         int CurYear, CurMonth;
152         long long int rcTime;
153         TIME_FIELDS TimeFields = *tfTimeFields;
154
155         rcTime = 0;
156
157         /* FIXME: normalize the TIME_FIELDS structure here */
158         while (TimeFields.Second >= SECSPERMIN)
159         { NormalizeTimeFields(&TimeFields.Second, &TimeFields.Minute, SECSPERMIN);
160         }
161         while (TimeFields.Minute >= MINSPERHOUR)
162         { NormalizeTimeFields(&TimeFields.Minute, &TimeFields.Hour, MINSPERHOUR);
163         }
164         while (TimeFields.Hour >= HOURSPERDAY)
165         { NormalizeTimeFields(&TimeFields.Hour, &TimeFields.Day, HOURSPERDAY);
166         }
167         while (TimeFields.Day > MonthLengths[IsLeapYear(TimeFields.Year)][TimeFields.Month - 1])
168         { NormalizeTimeFields(&TimeFields.Day, &TimeFields.Month, SECSPERMIN);
169         }
170         while (TimeFields.Month > MONSPERYEAR)
171         { NormalizeTimeFields(&TimeFields.Month, &TimeFields.Year, MONSPERYEAR);
172         }
173
174         /* FIXME: handle calendar corrections here */
175         for (CurYear = EPOCHYEAR; CurYear < TimeFields.Year; CurYear++)
176         { rcTime += YearLengths[IsLeapYear(CurYear)];
177         }
178         for (CurMonth = 1; CurMonth < TimeFields.Month; CurMonth++)
179         { rcTime += MonthLengths[IsLeapYear(CurYear)][CurMonth - 1];
180         }
181         rcTime += TimeFields.Day - 1;
182         rcTime *= SECSPERDAY;
183         rcTime += TimeFields.Hour * SECSPERHOUR + TimeFields.Minute * SECSPERMIN + TimeFields.Second;
184         rcTime *= TICKSPERSEC;
185         rcTime += TimeFields.Milliseconds * TICKSPERMSEC;
186         *Time = *(LARGE_INTEGER *)&rcTime;
187
188         return TRUE;
189 }
190 /************* end of code by Rex Jolliff (rex@lvcablemodem.com) *******************/
191
192 /******************************************************************************
193  *  RtlSystemTimeToLocalTime    [NTDLL.@]
194  */
195 VOID WINAPI RtlSystemTimeToLocalTime(
196         IN  PLARGE_INTEGER SystemTime,
197         OUT PLARGE_INTEGER LocalTime)
198 {
199         FIXME("(%p, %p),stub!\n",SystemTime,LocalTime);
200
201         memcpy (LocalTime, SystemTime, sizeof (PLARGE_INTEGER));
202 }
203
204 /******************************************************************************
205  *  RtlTimeToSecondsSince1970           [NTDLL.@]
206  */
207 BOOLEAN WINAPI RtlTimeToSecondsSince1970( const FILETIME *time, LPDWORD res )
208 {
209     ULONGLONG tmp = RtlLargeIntegerDivide( ((LARGE_INTEGER *)time)->QuadPart, 10000000LL, NULL );
210     tmp -= SECS_1601_TO_1970;
211     if (tmp > 0xffffffff) return FALSE;
212     *res = (DWORD)tmp;
213     return TRUE;
214 }
215
216 /******************************************************************************
217  *  RtlTimeToSecondsSince1980           [NTDLL.@]
218  */
219 BOOLEAN WINAPI RtlTimeToSecondsSince1980( const FILETIME *time, LPDWORD res )
220 {
221     ULONGLONG tmp = RtlLargeIntegerDivide( ((LARGE_INTEGER *)time)->QuadPart, 10000000LL, NULL );
222     tmp -= SECS_1601_to_1980;
223     if (tmp > 0xffffffff) return FALSE;
224     *res = (DWORD)tmp;
225     return TRUE;
226 }
227
228 /******************************************************************************
229  *  RtlSecondsSince1970ToTime           [NTDLL.@]
230  */
231 void WINAPI RtlSecondsSince1970ToTime( DWORD time, FILETIME *res )
232 {
233     LONGLONG secs = time + SECS_1601_TO_1970;
234     ((LARGE_INTEGER *)res)->QuadPart = RtlExtendedIntegerMultiply( secs, 10000000 );
235 }
236
237 /******************************************************************************
238  *  RtlSecondsSince1980ToTime           [NTDLL.@]
239  */
240 void WINAPI RtlSecondsSince1980ToTime( DWORD time, FILETIME *res )
241 {
242     LONGLONG secs = time + SECS_1601_to_1980;
243     ((LARGE_INTEGER *)res)->QuadPart = RtlExtendedIntegerMultiply( secs, 10000000 );
244 }
245
246 /******************************************************************************
247  * RtlTimeToElapsedTimeFields [NTDLL.@]
248  * FIXME: prototype guessed
249  */
250 VOID WINAPI RtlTimeToElapsedTimeFields(
251         PLARGE_INTEGER liTime,
252         PTIME_FIELDS TimeFields)
253 {
254         FIXME("(%p,%p): stub\n",liTime,TimeFields);
255 }
256
257 /***********************************************************************
258  *      NtQuerySystemTime   (NTDLL.@)
259  *      ZwQuerySystemTime   (NTDLL.@)
260  */
261 void WINAPI NtQuerySystemTime( LARGE_INTEGER *time )
262 {
263     LONGLONG secs;
264     struct timeval now;
265
266     gettimeofday( &now, 0 );
267     secs = now.tv_sec + SECS_1601_TO_1970;
268     time->QuadPart = RtlExtendedIntegerMultiply( secs, 10000000 ) + now.tv_usec * 10;
269 }