Ignore:
Timestamp:
Sep 5, 2001, 2:05:03 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/datetime.c

    r6470 r6644  
     1/* $Id: datetime.c,v 1.18 2001-09-05 12:04:57 bird Exp $ */
    12/*
    23 * Date and time picker control
    … …  
    3435        COMCTL32_HEADER header;
    3536#endif
    36         HWND hMonthCal;
    37         HWND hUpdown;
    38         SYSTEMTIME date;
    39         BOOL dateValid;
    40         HWND hwndCheckbut;
    41         RECT rcClient; /* rect around the edge of the window */
    42         RECT rcDraw; /* rect inside of the border */
    43         RECT checkbox;  /* checkbox allowing the control to be enabled/disabled */
    44         RECT calbutton; /* button that toggles the dropdown of the monthcal control */
    45         BOOL bCalDepressed; /* TRUE = cal button is depressed */
    46         int  select;
    47         HFONT hFont;
    48         int nrFieldsAllocated;
    49         int nrFields;
    50         int haveFocus;
    51         int *fieldspec;
    52         RECT *fieldRect;
    53         int  *buflen;           
    54         char textbuf[256];
     37    HWND hMonthCal;
     38    HWND hUpdown;
     39    SYSTEMTIME date;
     40    BOOL dateValid;
     41    HWND hwndCheckbut;
     42    RECT rcClient; /* rect around the edge of the window */
     43    RECT rcDraw; /* rect inside of the border */
     44    RECT checkbox;  /* checkbox allowing the control to be enabled/disabled */
     45    RECT calbutton; /* button that toggles the dropdown of the monthcal control */
     46    BOOL bCalDepressed; /* TRUE = cal button is depressed */
     47    int  select;
     48    HFONT hFont;
     49    int nrFieldsAllocated;
     50    int nrFields;
     51    int haveFocus;
     52    int *fieldspec;
     53    RECT *fieldRect;
     54    int  *buflen;
     55    char textbuf[256];
    5556        POINT monthcal_pos;
    5657} DATETIME_INFO, *LPDATETIME_INFO;
    … …  
    6162/* this list of defines is closely related to `allowedformatchars' defined
    6263 * in datetime.c; the high nibble indicates the `base type' of the format
    63  * specifier. 
     64 * specifier.
    6465 * Do not change without first reading DATETIME_UseFormat.
    65  * 
     66 *
    6667 */
    6768
    68 #define DT_END_FORMAT      0 
    69 #define ONEDIGITDAY     0x01
    70 #define TWODIGITDAY     0x02
    71 #define THREECHARDAY    0x03
     69#define DT_END_FORMAT      0
     70#define ONEDIGITDAY     0x01
     71#define TWODIGITDAY     0x02
     72#define THREECHARDAY    0x03
    7273#define FULLDAY         0x04
    7374#define ONEDIGIT12HOUR  0x11
    … …  
    9495#define FORMATCALLBACK  0x81      /* -> maximum of 0x80 callbacks possible */
    9596#define FORMATCALLMASK  0x80
    96 #define DT_STRING       0x0100
     97#define DT_STRING   0x0100
    9798
    9899#define DTHT_DATEFIELD  0xff      /* for hit-testing */
    99100
    100101#define DTHT_NONE     0
    101 #define DTHT_CHECKBOX 0x200     /* these should end at '00' , to make */
     102#define DTHT_CHECKBOX 0x200 /* these should end at '00' , to make */
    102103#define DTHT_MCPOPUP  0x300     /* & DTHT_DATEFIELD 0 when DATETIME_KeyDown */
    103104#define DTHT_GOTFOCUS 0x400     /* tests for date-fields */
    … …  
    126127  if (!lParam) return GDT_NONE;
    127128
    128   if ((dwStyle & DTS_SHOWNONE) && 
     129  if ((dwStyle & DTS_SHOWNONE) &&
    129130       (SendMessageA (infoPtr->hwndCheckbut, BM_GETCHECK, 0, 0)))
    130131        return GDT_NONE;
    … …  
    145146  if (!lParam) return 0;
    146147
    147   if (lParam==GDT_VALID) 
    148         MONTHCAL_CopyTime (lprgSysTimeArray, &infoPtr->date);
     148  if (lParam==GDT_VALID)
     149    MONTHCAL_CopyTime (lprgSysTimeArray, &infoPtr->date);
    149150  if (lParam==GDT_NONE) {
    150         infoPtr->dateValid=FALSE;
     151    infoPtr->dateValid=FALSE;
    151152    SendMessageA (infoPtr->hwndCheckbut, BM_SETCHECK, 0, 0);
    152         }
     153    }
    153154  return 1;
    154155}
    … …  
    228229
    229230
    230 /* 
    231    Split up a formattxt in actions. 
     231/*
     232   Split up a formattxt in actions.
    232233   See ms documentation for the meaning of the letter codes/'specifiers'.
    233234
    234    Notes: 
     235   Notes:
    235236   *'dddddd' is handled as 'dddd' plus 'dd'.
    236    *unrecognized formats are strings (here given the type DT_STRING; 
     237   *unrecognized formats are strings (here given the type DT_STRING;
    237238   start of the string is encoded in lower bits of DT_STRING.
    238239   Therefore, 'string' ends finally up as '<show seconds>tring'.
    … …  
    241242
    242243
    243 static void 
     244static void
    244245DATETIME_UseFormat (DATETIME_INFO *infoPtr, const char *formattxt)
    245246{
    … …  
    256257
    257258 for (i=0; i<strlen (formattxt); i++)  {
    258         TRACE ("\n%d %c:",i, formattxt[i]);
    259         for (j=0; j<len; j++) {
    260                 if (allowedformatchars[j]==formattxt[i]) {   
    261                         TRACE ("%c[%d,%x]",allowedformatchars[j], *nrFields,
    262                                                         infoPtr->fieldspec[*nrFields]);
    263                         if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
    264                                 infoPtr->fieldspec[*nrFields]=(j<<4) +1;
    265                                 break;
    266                         }
    267                         if (infoPtr->fieldspec[*nrFields]>>4!=j) {   
    268                                 (*nrFields)++; 
    269                                 infoPtr->fieldspec[*nrFields]=(j<<4) +1;
    270                                 break;
    271                         }
    272                         if ((infoPtr->fieldspec[*nrFields] & 0x0f)==maxrepetition[j]) {
    273                                 (*nrFields)++; 
    274                                 infoPtr->fieldspec[*nrFields]=(j<<4) +1;
    275                                 break;
    276                         }
    277                         infoPtr->fieldspec[*nrFields]++;
    278                         break;
    279                 }   /* if allowedformatchar */
    280         } /* for j */
    281 
    282 
    283                         /* char is not a specifier: handle char like a string */
    284         if (j==len) {
    285                 if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
    286                         infoPtr->fieldspec[*nrFields]=DT_STRING+k;
    287                         infoPtr->buflen[*nrFields]=0;
    288         } else 
    289                 if ((infoPtr->fieldspec[*nrFields] & DT_STRING)!=DT_STRING)  {
    290                         (*nrFields)++;
    291                         infoPtr->fieldspec[*nrFields]=DT_STRING+k;
    292                         infoPtr->buflen[*nrFields]=0;
    293                 }
    294                 infoPtr->textbuf[k]=formattxt[i];
    295                 k++;
    296                 infoPtr->buflen[*nrFields]++;
    297         }   /* if j=len */
    298 
    299         if (*nrFields==infoPtr->nrFieldsAllocated) {
    300                 FIXME ("out of memory; should reallocate. crash ahead.\n");
    301         }
     259    TRACE ("\n%d %c:",i, formattxt[i]);
     260    for (j=0; j<len; j++) {
     261        if (allowedformatchars[j]==formattxt[i]) {
     262            TRACE ("%c[%d,%x]",allowedformatchars[j], *nrFields,
     263                            infoPtr->fieldspec[*nrFields]);
     264            if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
     265                infoPtr->fieldspec[*nrFields]=(j<<4) +1;
     266                break;
     267            }
     268            if (infoPtr->fieldspec[*nrFields]>>4!=j) {
     269                (*nrFields)++;
     270                infoPtr->fieldspec[*nrFields]=(j<<4) +1;
     271                break;
     272            }
     273            if ((infoPtr->fieldspec[*nrFields] & 0x0f)==maxrepetition[j]) {
     274                (*nrFields)++;
     275                infoPtr->fieldspec[*nrFields]=(j<<4) +1;
     276                break;
     277            }
     278            infoPtr->fieldspec[*nrFields]++;
     279            break;
     280        }   /* if allowedformatchar */
     281    } /* for j */
     282
     283
     284            /* char is not a specifier: handle char like a string */
     285    if (j==len) {
     286        if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
     287            infoPtr->fieldspec[*nrFields]=DT_STRING+k;
     288            infoPtr->buflen[*nrFields]=0;
     289        } else
     290        if ((infoPtr->fieldspec[*nrFields] & DT_STRING)!=DT_STRING)  {
     291            (*nrFields)++;
     292            infoPtr->fieldspec[*nrFields]=DT_STRING+k;
     293            infoPtr->buflen[*nrFields]=0;
     294        }
     295        infoPtr->textbuf[k]=formattxt[i];
     296        k++;
     297        infoPtr->buflen[*nrFields]++;
     298    }   /* if j=len */
     299
     300    if (*nrFields==infoPtr->nrFieldsAllocated) {
     301        FIXME ("out of memory; should reallocate. crash ahead.\n");
     302    }
    302303
    303304  } /* for i */
    … …  
    309310
    310311
    311 static LRESULT 
     312static LRESULT
    312313DATETIME_SetFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
    313314{
    … …  
    318319 TRACE("%04x %08lx\n",wParam,lParam);
    319320 if (!lParam) {
    320         DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
    321 
    322         if (dwStyle & DTS_LONGDATEFORMAT)
    323                 format_item=LOCALE_SLONGDATE;
    324         else if (dwStyle & DTS_TIMEFORMAT)
    325                 format_item=LOCALE_STIMEFORMAT;
     321    DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
     322
     323    if (dwStyle & DTS_LONGDATEFORMAT)
     324        format_item=LOCALE_SLONGDATE;
     325    else if (dwStyle & DTS_TIMEFORMAT)
     326        format_item=LOCALE_STIMEFORMAT;
    326327        else /* DTS_SHORTDATEFORMAT */
    327                 format_item=LOCALE_SSHORTDATE;
    328         GetLocaleInfoA( GetSystemDefaultLCID(), format_item,format_buf,sizeof(format_buf));
    329         DATETIME_UseFormat (infoPtr, format_buf);
    330  }     
     328        format_item=LOCALE_SSHORTDATE;
     329    GetLocaleInfoA( GetSystemDefaultLCID(), format_item,format_buf,sizeof(format_buf));
     330    DATETIME_UseFormat (infoPtr, format_buf);
     331 }
    331332 else
    332         DATETIME_UseFormat (infoPtr, (char *) lParam);
     333    DATETIME_UseFormat (infoPtr, (char *) lParam);
    333334
    334335 return infoPtr->nrFields;
    … …  
    336337
    337338
    338 static LRESULT 
     339static LRESULT
    339340DATETIME_SetFormatW (HWND hwnd, WPARAM wParam, LPARAM lParam)
    340341
    … …  
    342343 TRACE("%04x %08lx\n",wParam,lParam);
    343344 if (lParam) {
    344         LPSTR buf;
    345         int retval;
     345    LPSTR buf;
     346    int retval;
    346347        int len = WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, NULL, 0, NULL, NULL );
    347348
    348         buf = (LPSTR) COMCTL32_Alloc (len);
     349    buf = (LPSTR) COMCTL32_Alloc (len);
    349350        WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, buf, len, NULL, NULL );
    350         retval=DATETIME_SetFormat (hwnd, 0, (LPARAM) buf);
    351         COMCTL32_Free (buf);
    352         return retval;
    353  } 
     351    retval=DATETIME_SetFormat (hwnd, 0, (LPARAM) buf);
     352    COMCTL32_Free (buf);
     353    return retval;
     354 }
    354355 else
    355         return DATETIME_SetFormat (hwnd, 0, 0);
    356 
    357 }
    358 
    359 
    360 static void 
     356    return DATETIME_SetFormat (hwnd, 0, 0);
     357
     358}
     359
     360
     361static void
    361362DATETIME_ReturnTxt (DATETIME_INFO *infoPtr, int count, char *result)
    362363{
    … …  
    368369 TRACE ("%d,%d\n", infoPtr->nrFields, count);
    369370 if ((count>infoPtr->nrFields) || (count<0)) {
    370         WARN ("buffer overrun, have %d want %d\n", infoPtr->nrFields, count);
    371         return;
     371    WARN ("buffer overrun, have %d want %d\n", infoPtr->nrFields, count);
     372    return;
    372373 }
    373374
    374375 if (!infoPtr->fieldspec) return;
    375  
     376
    376377 spec=infoPtr->fieldspec[count];
    377378 if (spec & DT_STRING) {
    378         int txtlen=infoPtr->buflen[count];
    379 
    380         strncpy (result, infoPtr->textbuf + (spec &~ DT_STRING), txtlen);
    381         result[txtlen]=0;
    382         TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
    383         return;
     379    int txtlen=infoPtr->buflen[count];
     380
     381    strncpy (result, infoPtr->textbuf + (spec &~ DT_STRING), txtlen);
     382    result[txtlen]=0;
     383    TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
     384    return;
    384385 }
    385386
    386                
     387
    387388 switch (spec) {
    388         case DT_END_FORMAT:
    389                 *result=0;
    390                 break;
    391         case ONEDIGITDAY:
    392                 sprintf (result,"%d",date.wDay);
    393                 break;
    394         case TWODIGITDAY:
    395                 sprintf (result,"%.2d",date.wDay);
    396                 break;
    397         case THREECHARDAY:
    398                 GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1+(date.wDayOfWeek+6)%7,
    399                                 result,4);
    400                 /*sprintf (result,"%.3s",days[date.wDayOfWeek]);*/
    401                 break;
    402         case FULLDAY:
    403                 GetLocaleInfoA( LOCALE_USER_DEFAULT,LOCALE_SDAYNAME1+ (date.wDayOfWeek+6)%7,
    404                                 buffer,sizeof(buffer));
    405                 strcpy  (result,buffer);
    406                 break;
    407         case ONEDIGIT12HOUR:
    408                 if (date.wHour>12)
    409                         sprintf (result,"%d",date.wHour-12);
    410                 else
    411                         sprintf (result,"%d",date.wHour);
    412                 break;
    413         case TWODIGIT12HOUR:
    414                 if (date.wHour>12)
    415                         sprintf (result,"%.2d",date.wHour-12);
    416                 else
    417                         sprintf (result,"%.2d",date.wHour);
    418                 break;
    419         case ONEDIGIT24HOUR:
    420                 sprintf (result,"%d",date.wHour);
    421                 break;
    422         case TWODIGIT24HOUR:
    423                 sprintf (result,"%.2d",date.wHour);
    424                 break;
    425         case ONEDIGITSECOND:
    426                 sprintf (result,"%d",date.wSecond);
    427                 break;
    428         case TWODIGITSECOND:
    429                 sprintf (result,"%.2d",date.wSecond);
    430                 break;
    431         case ONEDIGITMINUTE:
    432                 sprintf (result,"%d",date.wMinute);
    433                 break;
    434         case TWODIGITMINUTE:
    435                 sprintf (result,"%.2d",date.wMinute);
    436                 break;
    437         case ONEDIGITMONTH:
    438                 sprintf (result,"%d",date.wMonth);
    439                 break;
    440         case TWODIGITMONTH:
    441                 sprintf (result,"%.2d",date.wMonth);
    442                 break;
    443         case THREECHARMONTH:
    444                 GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
    445                   buffer,sizeof(buffer));
    446                 sprintf (result,"%.3s",buffer);
    447                 break;
    448         case FULLMONTH:   
    449                 GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
     389    case DT_END_FORMAT:
     390        *result=0;
     391        break;
     392    case ONEDIGITDAY:
     393        sprintf (result,"%d",date.wDay);
     394        break;
     395    case TWODIGITDAY:
     396        sprintf (result,"%.2d",date.wDay);
     397        break;
     398    case THREECHARDAY:
     399            GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1+(date.wDayOfWeek+6)%7,
     400                result,4);
     401        /*sprintf (result,"%.3s",days[date.wDayOfWeek]);*/
     402        break;
     403    case FULLDAY:
     404            GetLocaleInfoA( LOCALE_USER_DEFAULT,LOCALE_SDAYNAME1+ (date.wDayOfWeek+6)%7,
     405                buffer,sizeof(buffer));
     406        strcpy  (result,buffer);
     407        break;
     408    case ONEDIGIT12HOUR:
     409        if (date.wHour>12)
     410            sprintf (result,"%d",date.wHour-12);
     411        else
     412            sprintf (result,"%d",date.wHour);
     413        break;
     414    case TWODIGIT12HOUR:
     415        if (date.wHour>12)
     416            sprintf (result,"%.2d",date.wHour-12);
     417        else
     418            sprintf (result,"%.2d",date.wHour);
     419        break;
     420    case ONEDIGIT24HOUR:
     421        sprintf (result,"%d",date.wHour);
     422        break;
     423    case TWODIGIT24HOUR:
     424        sprintf (result,"%.2d",date.wHour);
     425        break;
     426    case ONEDIGITSECOND:
     427        sprintf (result,"%d",date.wSecond);
     428        break;
     429    case TWODIGITSECOND:
     430        sprintf (result,"%.2d",date.wSecond);
     431        break;
     432    case ONEDIGITMINUTE:
     433        sprintf (result,"%d",date.wMinute);
     434        break;
     435    case TWODIGITMINUTE:
     436        sprintf (result,"%.2d",date.wMinute);
     437        break;
     438    case ONEDIGITMONTH:
     439        sprintf (result,"%d",date.wMonth);
     440        break;
     441    case TWODIGITMONTH:
     442        sprintf (result,"%.2d",date.wMonth);
     443        break;
     444    case THREECHARMONTH:
     445        GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
     446          buffer,sizeof(buffer));
     447        sprintf (result,"%.3s",buffer);
     448        break;
     449    case FULLMONTH:
     450        GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
    450451#ifdef __WIN32OS2__
    451                                 buffer,sizeof(buffer));
    452                 strcpy  (result,buffer);
     452                buffer,sizeof(buffer));
     453        strcpy  (result,buffer);
    453454#else
    454                   result,sizeof(result));
     455          result,sizeof(result));
    455456#endif
    456                 break;
    457         case ONELETTERAMPM:   
    458                 if (date.wHour<12)
    459                         strcpy (result,"A");
    460                 else
    461                         strcpy (result,"P");
    462                 break;
    463         case TWOLETTERAMPM:   
    464                 if (date.wHour<12)
    465                         strcpy (result,"AM");
    466                 else
    467                         strcpy (result,"PM");
    468                 break;
    469         case FORMATCALLBACK:   
    470                 FIXME ("Not implemented\n");
    471                 strcpy (result,"xxx");
    472                 break;
    473         case ONEDIGITYEAR:
    474                 sprintf (result,"%d",date.wYear-10* (int) floor(date.wYear/10));
    475                 break;
    476         case TWODIGITYEAR:
    477                 sprintf (result,"%.2d",date.wYear-100* (int) floor(date.wYear/100));
    478                 break;
    479         case FULLYEAR:   
    480                 sprintf (result,"%d",date.wYear);
    481                 break;
     457        break;
     458    case ONELETTERAMPM:
     459        if (date.wHour<12)
     460            strcpy (result,"A");
     461        else
     462            strcpy (result,"P");
     463        break;
     464    case TWOLETTERAMPM:
     465        if (date.wHour<12)
     466            strcpy (result,"AM");
     467        else
     468            strcpy (result,"PM");
     469        break;
     470    case FORMATCALLBACK:
     471        FIXME ("Not implemented\n");
     472        strcpy (result,"xxx");
     473        break;
     474    case ONEDIGITYEAR:
     475        sprintf (result,"%d",date.wYear-10* (int) floor(date.wYear/10));
     476        break;
     477    case TWODIGITYEAR:
     478        sprintf (result,"%.2d",date.wYear-100* (int) floor(date.wYear/100));
     479        break;
     480    case FULLYEAR:
     481        sprintf (result,"%d",date.wYear);
     482        break;
    482483    }
    483        
    484         TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
    485 }
    486 
    487 
    488 static void 
     484
     485    TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
     486}
     487
     488
     489static void
    489490DATETIME_IncreaseField (DATETIME_INFO *infoPtr, int number)
    490491{
    … …  
    497498 spec=infoPtr->fieldspec[number];
    498499 if ((spec & DTHT_DATEFIELD)==0) return;
    499                
     500
    500501 switch (spec) {
    501         case ONEDIGITDAY:
    502         case TWODIGITDAY:
    503         case THREECHARDAY:
    504         case FULLDAY:
    505                 date->wDay++;
    506                 if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
    507                   date->wDay=1;
    508                 break;
    509         case ONEDIGIT12HOUR:
    510         case TWODIGIT12HOUR:
    511         case ONEDIGIT24HOUR:
    512         case TWODIGIT24HOUR:
    513                 date->wHour++;
    514                 if (date->wHour>23) date->wHour=0;
    515                 break;
    516         case ONEDIGITSECOND:
    517         case TWODIGITSECOND:
    518                 date->wSecond++;
    519                 if (date->wSecond>59) date->wSecond=0;
    520                 break;
    521         case ONEDIGITMINUTE:
    522         case TWODIGITMINUTE:
    523                 date->wMinute++;
    524                 if (date->wMinute>59) date->wMinute=0;
    525                 break;
    526         case ONEDIGITMONTH:
    527         case TWODIGITMONTH:
    528         case THREECHARMONTH:
    529         case FULLMONTH:   
    530                 date->wMonth++;
    531                 if (date->wMonth>12) date->wMonth=1;
    532                 if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
    533                         date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
    534                 break;
    535         case ONELETTERAMPM:   
    536         case TWOLETTERAMPM:   
    537                 date->wHour+=12;
    538                 if (date->wHour>23) date->wHour-=24;
    539                 break;
    540         case FORMATCALLBACK:   
    541                 FIXME ("Not implemented\n");
    542                 break;
    543         case ONEDIGITYEAR:
    544         case TWODIGITYEAR:
    545         case FULLYEAR:   
    546                 date->wYear++;
    547                 break;
    548         }
    549 
    550 }
    551 
    552 
    553 static void 
     502    case ONEDIGITDAY:
     503    case TWODIGITDAY:
     504    case THREECHARDAY:
     505    case FULLDAY:
     506        date->wDay++;
     507        if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
     508          date->wDay=1;
     509        break;
     510    case ONEDIGIT12HOUR:
     511    case TWODIGIT12HOUR:
     512    case ONEDIGIT24HOUR:
     513    case TWODIGIT24HOUR:
     514        date->wHour++;
     515        if (date->wHour>23) date->wHour=0;
     516        break;
     517    case ONEDIGITSECOND:
     518    case TWODIGITSECOND:
     519        date->wSecond++;
     520        if (date->wSecond>59) date->wSecond=0;
     521        break;
     522    case ONEDIGITMINUTE:
     523    case TWODIGITMINUTE:
     524        date->wMinute++;
     525        if (date->wMinute>59) date->wMinute=0;
     526        break;
     527    case ONEDIGITMONTH:
     528    case TWODIGITMONTH:
     529    case THREECHARMONTH:
     530    case FULLMONTH:
     531        date->wMonth++;
     532        if (date->wMonth>12) date->wMonth=1;
     533        if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
     534            date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
     535        break;
     536    case ONELETTERAMPM:
     537    case TWOLETTERAMPM:
     538        date->wHour+=12;
     539        if (date->wHour>23) date->wHour-=24;
     540        break;
     541    case FORMATCALLBACK:
     542        FIXME ("Not implemented\n");
     543        break;
     544    case ONEDIGITYEAR:
     545    case TWODIGITYEAR:
     546    case FULLYEAR:
     547        date->wYear++;
     548        break;
     549    }
     550
     551}
     552
     553
     554static void
    554555DATETIME_DecreaseField (DATETIME_INFO *infoPtr, int number)
    555556{
    … …  
    562563 spec = infoPtr->fieldspec[number];
    563564 if ((spec & DTHT_DATEFIELD)==0) return;
    564                
     565
    565566 TRACE ("%x\n",spec);
    566567
    567568 switch (spec) {
    568         case ONEDIGITDAY:
    569         case TWODIGITDAY:
    570         case THREECHARDAY:
    571         case FULLDAY:
    572                 date->wDay--;
    573                 if (date->wDay<1)
    574                   date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
    575                 break;
    576         case ONEDIGIT12HOUR:
    577         case TWODIGIT12HOUR:
    578         case ONEDIGIT24HOUR:
    579         case TWODIGIT24HOUR:
    580                 if (date->wHour)
    581                         date->wHour--;
    582                 else
    583                         date->wHour=23;
    584                 break;
    585         case ONEDIGITSECOND:
    586         case TWODIGITSECOND:
    587                 if (date->wHour)
    588                         date->wSecond--;
    589                 else
    590                         date->wHour=59;
    591                 break;
    592         case ONEDIGITMINUTE:
    593         case TWODIGITMINUTE:
    594                 if (date->wMinute)
    595                         date->wMinute--;
    596                 else
    597                         date->wMinute=59;
    598                 break;
    599         case ONEDIGITMONTH:
    600         case TWODIGITMONTH:
    601         case THREECHARMONTH:
    602         case FULLMONTH:   
    603                 if (date->wMonth>1)
    604                         date->wMonth--;
    605                 else
    606                         date->wMonth=12;
    607                 if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
    608                         date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
    609                 break;
    610         case ONELETTERAMPM:   
    611         case TWOLETTERAMPM:   
    612                 if (date->wHour<12)
    613                         date->wHour+=12;
    614                 else
    615                         date->wHour-=12;
    616                 break;
    617         case FORMATCALLBACK:   
    618                 FIXME ("Not implemented\n");
    619                 break;
    620         case ONEDIGITYEAR:
    621         case TWODIGITYEAR:
    622         case FULLYEAR:   
    623                 date->wYear--;
    624                 break;
    625         }
    626 
    627 }
    628 
    629 
    630 static void 
     569    case ONEDIGITDAY:
     570    case TWODIGITDAY:
     571    case THREECHARDAY:
     572    case FULLDAY:
     573        date->wDay--;
     574        if (date->wDay<1)
     575          date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
     576        break;
     577    case ONEDIGIT12HOUR:
     578    case TWODIGIT12HOUR:
     579    case ONEDIGIT24HOUR:
     580    case TWODIGIT24HOUR:
     581        if (date->wHour)
     582            date->wHour--;
     583        else
     584            date->wHour=23;
     585        break;
     586    case ONEDIGITSECOND:
     587    case TWODIGITSECOND:
     588        if (date->wHour)
     589            date->wSecond--;
     590        else
     591            date->wHour=59;
     592        break;
     593    case ONEDIGITMINUTE:
     594    case TWODIGITMINUTE:
     595        if (date->wMinute)
     596            date->wMinute--;
     597        else
     598            date->wMinute=59;
     599        break;
     600    case ONEDIGITMONTH:
     601    case TWODIGITMONTH:
     602    case THREECHARMONTH:
     603    case FULLMONTH:
     604        if (date->wMonth>1)
     605            date->wMonth--;
     606        else
     607            date->wMonth=12;
     608        if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
     609            date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
     610        break;
     611    case ONELETTERAMPM:
     612    case TWOLETTERAMPM:
     613        if (date->wHour<12)
     614            date->wHour+=12;
     615        else
     616            date->wHour-=12;
     617        break;
     618    case FORMATCALLBACK:
     619        FIXME ("Not implemented\n");
     620        break;
     621    case ONEDIGITYEAR:
     622    case TWODIGITYEAR:
     623    case FULLYEAR:
     624        date->wYear--;
     625        break;
     626    }
     627
     628}
     629
     630
     631static void
    631632DATETIME_ResetFieldDown (DATETIME_INFO *infoPtr, int number)
    632633{
    … …  
    639640 spec = infoPtr->fieldspec[number];
    640641 if ((spec & DTHT_DATEFIELD)==0) return;
    641                
     642
    642643
    643644 switch (spec) {
    644         case ONEDIGITDAY:
    645         case TWODIGITDAY:
    646         case THREECHARDAY:
    647         case FULLDAY:
    648                 date->wDay = 1;
    649                 break;
    650         case ONEDIGIT12HOUR:
    651         case TWODIGIT12HOUR:
    652         case ONEDIGIT24HOUR:
    653         case TWODIGIT24HOUR:
    654         case ONELETTERAMPM:   
    655         case TWOLETTERAMPM:   
    656                 date->wHour = 0;
    657                 break;
    658         case ONEDIGITSECOND:
    659         case TWODIGITSECOND:
    660                 date->wSecond = 0;
    661                 break;
    662         case ONEDIGITMINUTE:
    663         case TWODIGITMINUTE:
    664                 date->wMinute = 0;
    665                 break;
    666         case ONEDIGITMONTH:
    667         case TWODIGITMONTH:
    668         case THREECHARMONTH:
    669         case FULLMONTH:   
    670                 date->wMonth = 1;
    671         case FORMATCALLBACK:   
    672                 FIXME ("Not implemented\n");
    673                 break;
    674         case ONEDIGITYEAR:
    675         case TWODIGITYEAR:
     645    case ONEDIGITDAY:
     646    case TWODIGITDAY:
     647    case THREECHARDAY:
     648    case FULLDAY:
     649        date->wDay = 1;
     650        break;
     651    case ONEDIGIT12HOUR:
     652    case TWODIGIT12HOUR:
     653    case ONEDIGIT24HOUR:
     654    case TWODIGIT24HOUR:
     655    case ONELETTERAMPM:
     656    case TWOLETTERAMPM:
     657        date->wHour = 0;
     658        break;
     659    case ONEDIGITSECOND:
     660    case TWODIGITSECOND:
     661        date->wSecond = 0;
     662        break;
     663    case ONEDIGITMINUTE:
     664    case TWODIGITMINUTE:
     665        date->wMinute = 0;
     666        break;
     667    case ONEDIGITMONTH:
     668    case TWODIGITMONTH:
     669    case THREECHARMONTH:
     670    case FULLMONTH:
     671        date->wMonth = 1;
     672    case FORMATCALLBACK:
     673        FIXME ("Not implemented\n");
     674        break;
     675    case ONEDIGITYEAR:
     676    case TWODIGITYEAR:
    676677        /* FYI: On 9/14/1752 the calender changed and England and the American */
    677678        /* colonies changed to the Gregorian calender.  This change involved */
    678679        /* having September 14th following September 2nd.  So no date algorithms */
    679680        /* work before that date. */
    680         case FULLYEAR:   
    681                 date->wSecond = 0;
    682                 date->wMinute = 0;
    683                 date->wHour = 0;
    684                 date->wDay = 14;                /* overactive ms-programmers..*/
    685                 date->wMonth = 9;
    686                 date->wYear = 1752;
    687                 break;
    688         }
    689 
    690 }
    691 
    692 
    693 static void 
     681    case FULLYEAR:
     682        date->wSecond = 0;
     683        date->wMinute = 0;
     684        date->wHour = 0;
     685        date->wDay = 14;        /* overactive ms-programmers..*/
     686        date->wMonth = 9;
     687        date->wYear = 1752;
     688        break;
     689    }
     690
     691}
     692
     693
     694static void
    694695DATETIME_ResetFieldUp (DATETIME_INFO *infoPtr, int number)
    695696{
    … …  
    702703 spec=infoPtr->fieldspec[number];
    703704 if ((spec & DTHT_DATEFIELD)==0) return;
    704                
     705
    705706 switch (spec) {
    706         case ONEDIGITDAY:
    707         case TWODIGITDAY:
    708         case THREECHARDAY:
    709         case FULLDAY:
    710                 date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
    711                 break;
    712         case ONEDIGIT12HOUR:
    713         case TWODIGIT12HOUR:
    714         case ONEDIGIT24HOUR:
    715         case TWODIGIT24HOUR:
    716         case ONELETTERAMPM:   
    717         case TWOLETTERAMPM:   
    718                 date->wHour=23;
    719                 break;
    720         case ONEDIGITSECOND:
    721         case TWODIGITSECOND:
    722                 date->wSecond=59;
    723                 break;
    724         case ONEDIGITMINUTE:
    725         case TWODIGITMINUTE:
    726                 date->wMinute=59;
    727                 break;
    728         case ONEDIGITMONTH:
    729         case TWODIGITMONTH:
    730         case THREECHARMONTH:
    731         case FULLMONTH:   
    732                 date->wMonth=12;
    733         case FORMATCALLBACK:   
    734                 FIXME ("Not implemented\n");
    735                 break;
    736         case ONEDIGITYEAR:
    737         case TWODIGITYEAR:
    738         case FULLYEAR:   
    739                 date->wYear=9999;    /* Y10K problem? naaah. */
    740                 break;
    741         }
     707    case ONEDIGITDAY:
     708    case TWODIGITDAY:
     709    case THREECHARDAY:
     710    case FULLDAY:
     711        date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
     712        break;
     713    case ONEDIGIT12HOUR:
     714    case TWODIGIT12HOUR:
     715    case ONEDIGIT24HOUR:
     716    case TWODIGIT24HOUR:
     717    case ONELETTERAMPM:
     718    case TWOLETTERAMPM:
     719        date->wHour=23;
     720        break;
     721    case ONEDIGITSECOND:
     722    case TWODIGITSECOND:
     723        date->wSecond=59;
     724        break;
     725    case ONEDIGITMINUTE:
     726    case TWODIGITMINUTE:
     727        date->wMinute=59;
     728        break;
     729    case ONEDIGITMONTH:
     730    case TWODIGITMONTH:
     731    case THREECHARMONTH:
     732    case FULLMONTH:
     733        date->wMonth=12;
     734    case FORMATCALLBACK:
     735        FIXME ("Not implemented\n");
     736        break;
     737    case ONEDIGITYEAR:
     738    case TWODIGITYEAR:
     739    case FULLYEAR:
     740        date->wYear=9999;    /* Y10K problem? naaah. */
     741        break;
     742    }
    742743
    743744}
    … …  
    758759  SIZE size;
    759760  COLORREF oldBk, oldTextColor;
    760  
     761
    761762  /* draw control edge */
    762763  TRACE("\n");
    … …  
    764765  FillRect(hdc, rcClient, hbr);
    765766  DrawEdge(hdc, rcClient, EDGE_SUNKEN, BF_RECT);
    766   DeleteObject(hbr);   
    767        
     767  DeleteObject(hbr);
     768
    768769  if (infoPtr->dateValid) {
    769770    char txt[80];
    … …  
    798799              DT_RIGHT | DT_VCENTER | DT_SINGLELINE );
    799800        SetBkColor (hdc, oldBk);
    800                 SetTextColor (hdc, oldTextColor);
     801        SetTextColor (hdc, oldTextColor);
    801802      }
    802803      else
    … …  
    832833    if (PtInRect (&infoPtr->fieldRect[i], pt)) {
    833834      retval = i;
    834       TRACE("Hit in date text in field %d\n", i);           
     835      TRACE("Hit in date text in field %d\n", i);
    835836      break;
    836837    }
    … …  
    845846DATETIME_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
    846847{
    847   DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd); 
     848  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
    848849  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
    849850  int old, new;
    … …  
    874875      infoPtr->monthcal_pos.x = infoPtr->rcClient.right - ((infoPtr->calbutton.right -
    875876                                infoPtr->calbutton.left) + 145);
    876     else 
     877    else
    877878      infoPtr->monthcal_pos.x = 8;
    878879
    … …  
    888889
    889890    TRACE ("dt:%x mc:%x mc parent:%x, desktop:%x, mcpp:%x\n",
    890               hwnd,infoPtr->hMonthCal, 
     891              hwnd,infoPtr->hMonthCal,
    891892              GetParent (infoPtr->hMonthCal),
    892893              GetDesktopWindow (),
    … …  
    904905DATETIME_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
    905906{
    906   DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd); 
     907  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
    907908
    908909  TRACE("\n");
    909  
     910
    910911  if(infoPtr->bCalDepressed == TRUE) {
    911912    infoPtr->bCalDepressed = FALSE;
    … …  
    934935DATETIME_ParentNotify (HWND hwnd, WPARAM wParam, LPARAM lParam)
    935936{
    936  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);   
     937 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
    937938 LPNMHDR lpnmh = (LPNMHDR) lParam;
    938939
    … …  
    954955
    955956{
    956  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);   
     957 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
    957958 LPNMHDR lpnmh = (LPNMHDR) lParam;
    958959
    … …  
    964965
    965966
    966 static LRESULT 
     967static LRESULT
    967968DATETIME_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
    968969{
    … …  
    978979
    979980 if (infoPtr->select & FORMATCALLMASK) {
    980         FIXME ("Callbacks not implemented yet\n");
     981    FIXME ("Callbacks not implemented yet\n");
    981982 }
    982983
    983984 switch (wParam) {
    984         case VK_ADD:
    985         case VK_UP:
    986                 DATETIME_IncreaseField (infoPtr,FieldNum);
    987                 DATETIME_SendDateTimeChangeNotify (hwnd);
    988                 break;
    989         case VK_SUBTRACT:
    990         case VK_DOWN:
    991                 DATETIME_DecreaseField (infoPtr,FieldNum);
    992                 DATETIME_SendDateTimeChangeNotify (hwnd);
    993                 break;
    994         case VK_HOME:
    995                 DATETIME_ResetFieldDown (infoPtr,FieldNum);
    996                 DATETIME_SendDateTimeChangeNotify (hwnd);
    997                 break;
    998         case VK_END:
    999                 DATETIME_ResetFieldUp(infoPtr,FieldNum);
    1000                 DATETIME_SendDateTimeChangeNotify (hwnd);
    1001                 break;
    1002         case VK_LEFT:
    1003                 do {
    1004                         if (infoPtr->select==0) {
    1005                                 infoPtr->select = infoPtr->nrFields - 1;
    1006                                 wrap++;
    1007                         } else
    1008                         infoPtr->select--;
    1009                 }
    1010                 while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
    1011                 break;
    1012         case VK_RIGHT: 
    1013                 do {
    1014                         infoPtr->select++;
    1015                         if (infoPtr->select==infoPtr->nrFields) {
    1016                                 infoPtr->select = 0;
    1017                                 wrap++;
    1018                         }
    1019                         }
    1020                 while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
    1021                 break;
    1022         }
     985    case VK_ADD:
     986        case VK_UP:
     987        DATETIME_IncreaseField (infoPtr,FieldNum);
     988        DATETIME_SendDateTimeChangeNotify (hwnd);
     989        break;
     990    case VK_SUBTRACT:
     991    case VK_DOWN:
     992        DATETIME_DecreaseField (infoPtr,FieldNum);
     993        DATETIME_SendDateTimeChangeNotify (hwnd);
     994        break;
     995    case VK_HOME:
     996        DATETIME_ResetFieldDown (infoPtr,FieldNum);
     997        DATETIME_SendDateTimeChangeNotify (hwnd);
     998        break;
     999    case VK_END:
     1000        DATETIME_ResetFieldUp(infoPtr,FieldNum);
     1001        DATETIME_SendDateTimeChangeNotify (hwnd);
     1002        break;
     1003    case VK_LEFT:
     1004        do {
     1005            if (infoPtr->select==0) {
     1006                infoPtr->select = infoPtr->nrFields - 1;
     1007                wrap++;
     1008            } else
     1009            infoPtr->select--;
     1010        }
     1011        while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
     1012        break;
     1013    case VK_RIGHT:
     1014        do {
     1015            infoPtr->select++;
     1016            if (infoPtr->select==infoPtr->nrFields) {
     1017                infoPtr->select = 0;
     1018                wrap++;
     1019            }
     1020            }
     1021        while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
     1022        break;
     1023    }
    10231024
    10241025  InvalidateRect(hwnd, NULL, FALSE);
    … …  
    10311032DATETIME_KillFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
    10321033{
    1033     DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);       
     1034    DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
    10341035
    10351036    TRACE ("\n");
    10361037
    10371038    if (infoPtr->haveFocus) {
    1038         DATETIME_SendSimpleNotify (hwnd, NM_KILLFOCUS);
    1039         infoPtr->haveFocus = 0;
     1039    DATETIME_SendSimpleNotify (hwnd, NM_KILLFOCUS);
     1040    infoPtr->haveFocus = 0;
    10401041    }
    10411042
    … …  
    10491050DATETIME_SetFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
    10501051{
    1051     DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);       
     1052    DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
    10521053
    10531054    TRACE ("\n");
    10541055
    10551056    if (infoPtr->haveFocus==0) {
    1056         DATETIME_SendSimpleNotify (hwnd, NM_SETFOCUS); 
    1057         infoPtr->haveFocus = DTHT_GOTFOCUS;
     1057    DATETIME_SendSimpleNotify (hwnd, NM_SETFOCUS);
     1058    infoPtr->haveFocus = DTHT_GOTFOCUS;
    10581059    }
    10591060
    … …  
    10681069
    10691070{
    1070  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);   
     1071 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
    10711072 NMDATETIMECHANGE dtdtc;
    10721073
    … …  
    11361137    infoPtr->monthcal_pos.x = infoPtr->rcClient.right - ((infoPtr->calbutton.right -
    11371138                                infoPtr->calbutton.left) + 145);
    1138   else 
     1139  else
    11391140    infoPtr->monthcal_pos.x = 8;
    11401141
    … …  
    11721173
    11731174  if (dwStyle & DTS_SHOWNONE) {
    1174     infoPtr->hwndCheckbut=CreateWindowExA (0,"button", 0, 
    1175          WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, 
     1175    infoPtr->hwndCheckbut=CreateWindowExA (0,"button", 0,
     1176         WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
    11761177         2,2,13,13,
    1177          hwnd, 
     1178         hwnd,
    11781179         0, GetWindowLongA  (hwnd, GWL_HINSTANCE), 0);
    11791180         SendMessageA (infoPtr->hwndCheckbut, BM_SETCHECK, 1, 0);
    … …  
    11961197
    11971198  /* create the monthcal control */
    1198     infoPtr->hMonthCal = CreateWindowExA (0,"SysMonthCal32", 0, 
    1199         WS_BORDER | WS_POPUP | WS_CLIPSIBLINGS,
    1200         0, 0, 0, 0,
    1201         GetParent(hwnd),
    1202         0, 0, 0);
     1199    infoPtr->hMonthCal = CreateWindowExA (0,"SysMonthCal32", 0,
     1200    WS_BORDER | WS_POPUP | WS_CLIPSIBLINGS,
     1201    0, 0, 0, 0,
     1202    GetParent(hwnd),
     1203    0, 0, 0);
    12031204
    12041205  /* initialize info structure */
    … …  
    12141215{
    12151216    DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
    1216        
     1217
    12171218    TRACE("\n");
    12181219    COMCTL32_Free (infoPtr);
    … …  
    12271228
    12281229    if (!DATETIME_GetInfoPtr(hwnd) && (uMsg != WM_CREATE))
    1229         return DefWindowProcA( hwnd, uMsg, wParam, lParam );
    1230    
     1230    return DefWindowProcA( hwnd, uMsg, wParam, lParam );
     1231
    12311232    switch (uMsg)
    12321233    {
    … …  
    12361237
    12371238    case DTM_SETSYSTEMTIME:
    1238         return DATETIME_SetSystemTime (hwnd, wParam, lParam);
     1239    return DATETIME_SetSystemTime (hwnd, wParam, lParam);
    12391240
    12401241    case DTM_GETRANGE:
    … …  
    12661267
    12671268    case WM_PARENTNOTIFY:
    1268         return DATETIME_ParentNotify (hwnd, wParam, lParam);
     1269    return DATETIME_ParentNotify (hwnd, wParam, lParam);
    12691270
    12701271    case WM_NOTIFY:
    1271         return DATETIME_Notify (hwnd, wParam, lParam);
     1272    return DATETIME_Notify (hwnd, wParam, lParam);
    12721273
    12731274    case WM_GETDLGCODE:
    … …  
    12961297
    12971298    case WM_CREATE:
    1298         return DATETIME_Create (hwnd, wParam, lParam);
     1299    return DATETIME_Create (hwnd, wParam, lParam);
    12991300
    13001301    case WM_DESTROY:
    1301         return DATETIME_Destroy (hwnd, wParam, lParam);
     1302    return DATETIME_Destroy (hwnd, wParam, lParam);
    13021303
    13031304    default:
    1304         if (uMsg >= WM_USER)
    1305                 ERR("unknown msg %04x wp=%08x lp=%08lx\n",
    1306                      uMsg, wParam, lParam);
     1305    if (uMsg >= WM_USER)
     1306        ERR("unknown msg %04x wp=%08x lp=%08lx\n",
     1307             uMsg, wParam, lParam);
    13071308#ifdef __WIN32OS2__
    13081309        return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
    13091310#else
    1310         return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     1311    return DefWindowProcA (hwnd, uMsg, wParam, lParam);
    13111312#endif
    13121313    }
    … …  
    13291330    wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    13301331    wndClass.lpszClassName = DATETIMEPICK_CLASSA;
    1331  
     1332
    13321333    RegisterClassA (&wndClass);
    13331334}
Note: See TracChangeset for help on using the changeset viewer.